Source:Sp lev.c

Below is the full text to src/sp_lev.c from NetHack 3.4.3. To link to a particular line, write [[sp_lev.c#line123 ]], for example. 1.   /*	SCCS Id: @(#)sp_lev.c	3.4	2001/09/06	*/ 2.   /*	Copyright (c) 1989 by Jean-Christophe Collet */ 3.   /* NetHack may be freely redistributed. See license for details. */ 4.

5.   /*  6.     * This file contains the various functions that are related to the special 7.    * levels. 8.    * It contains also the special level loader. 9.    *  10.    */  11.    12.   #include "hack.h"  13. #include "dlb.h" 14. /* #define DEBUG */	/* uncomment to enable code debugging */ 15.   16.   #ifdef DEBUG 17.  # ifdef WIZARD 18.  #define debugpline	if (wizard) pline 19.  # else 20.  #define debugpline	pline 21.  # endif 22.  #endif 23.   24.   #include "sp_lev.h"  25. #include "rect.h" 26. 27.  extern void FDECL(mkmap, (lev_init *)); 28.   29.   STATIC_DCL void FDECL(get_room_loc, (schar *, schar *, struct mkroom *)); 30.  STATIC_DCL void FDECL(get_free_room_loc, (schar *, schar *, struct mkroom *)); 31.  STATIC_DCL void FDECL(create_trap, (trap *, struct mkroom *)); 32.  STATIC_DCL int FDECL(noncoalignment, (ALIGNTYP_P)); 33.  STATIC_DCL void FDECL(create_monster, (monster *, struct mkroom *)); 34.  STATIC_DCL void FDECL(create_object, (object *, struct mkroom *)); 35.  STATIC_DCL void FDECL(create_engraving, (engraving *,struct mkroom *)); 36.  STATIC_DCL void FDECL(create_stairs, (stair *, struct mkroom *)); 37.  STATIC_DCL void FDECL(create_altar, (altar *, struct mkroom *)); 38.  STATIC_DCL void FDECL(create_gold, (gold *, struct mkroom *)); 39.  STATIC_DCL void FDECL(create_feature, (int,int,struct mkroom *,int)); 40.  STATIC_DCL boolean FDECL(search_door, (struct mkroom *, xchar *, xchar *, 41.  					XCHAR_P, int)); 42.  STATIC_DCL void NDECL(fix_stair_rooms); 43.  STATIC_DCL void FDECL(create_corridor, (corridor *)); 44.   45.   STATIC_DCL boolean FDECL(create_subroom, (struct mkroom *, XCHAR_P, XCHAR_P, 46.  					XCHAR_P, XCHAR_P, XCHAR_P, XCHAR_P)); 47.   48.   #define LEFT	1 49.  #define H_LEFT	2 50.  #define CENTER	3 51.  #define H_RIGHT	4 52.  #define RIGHT	5 53.   54.   #define TOP	1 55.  #define BOTTOM	5 56.   57.   #define sq(x) ((x)*(x)) 58.   59.   #define XLIM	4 60.  #define YLIM	3 61.   62.   #define Fread	(void)dlb_fread 63.  #define Fgetc	(schar)dlb_fgetc 64.  #define New(type)		(type *) alloc(sizeof(type)) 65.  #define NewTab(type, size)	(type **) alloc(sizeof(type *) * (unsigned)size) 66.  #define Free(ptr)		if(ptr) free((genericptr_t) (ptr)) 67.   68.   static NEARDATA walk walklist[50]; 69.  extern int min_rx, max_rx, min_ry, max_ry; /* from mkmap.c */ 70.   71.   static char Map[COLNO][ROWNO]; 72.  static char robjects[10], rloc_x[10], rloc_y[10], rmonst[10]; 73.  static aligntyp	ralign[3] = { AM_CHAOTIC, AM_NEUTRAL, AM_LAWFUL }; 74.  static NEARDATA xchar xstart, ystart; 75.  static NEARDATA char xsize, ysize; 76.   77.   STATIC_DCL void FDECL(set_wall_property, (XCHAR_P,XCHAR_P,XCHAR_P,XCHAR_P,int)); 78.  STATIC_DCL int NDECL(rnddoor); 79.  STATIC_DCL int NDECL(rndtrap); 80.  STATIC_DCL void FDECL(get_location, (schar *,schar *,int)); 81.  STATIC_DCL void FDECL(sp_lev_shuffle, (char *,char *,int)); 82.  STATIC_DCL void FDECL(light_region, (region *)); 83.  STATIC_DCL void FDECL(load_common_data, (dlb *,int)); 84.  STATIC_DCL void FDECL(load_one_monster, (dlb *,monster *)); 85.  STATIC_DCL void FDECL(load_one_object, (dlb *,object *)); 86.  STATIC_DCL void FDECL(load_one_engraving, (dlb *,engraving *)); 87.  STATIC_DCL boolean FDECL(load_rooms, (dlb *)); 88.  STATIC_DCL void FDECL(maze1xy, (coord *,int)); 89.  STATIC_DCL boolean FDECL(load_maze, (dlb *)); 90.  STATIC_DCL void FDECL(create_door, (room_door *, struct mkroom *)); 91.  STATIC_DCL void FDECL(free_rooms,(room **, int)); 92.  STATIC_DCL void FDECL(build_room, (room *, room*)); 93.   94.   char *lev_message = 0; 95.  lev_region *lregions = 0; 96.  int num_lregions = 0; 97.  lev_init init_lev; 98.   99.   /*  100.   * Make walls of the area (x1, y1, x2, y2) non diggable/non passwall-able 101.  */  102.   103.  STATIC_OVL void 104. set_wall_property(x1,y1,x2,y2, prop) 105. xchar x1, y1, x2, y2; 106. int prop; 107. {  108.  	register xchar x, y;  109. 110. 	for(y = y1; y <= y2; y++) 111. 	    for(x = x1; x <= x2; x++) 112. 		if(IS_STWALL(levl[x][y].typ)) 113. 		    levl[x][y].wall_info |= prop; 114. }  115.   116.  /*  117.   * Choose randomly the state (nodoor, open, closed or locked) for a door 118.  */  119.  STATIC_OVL int 120. rnddoor 121. {  122.  	int i = 1 << rn2(5); 123. 	i >>= 1; 124. 	return i;  125. } 126.   127.  /*  128.   * Select a random trap 129.  */  130.  STATIC_OVL int 131. rndtrap 132. {  133.  	int rtrap; 134.  135.  	do { 136. 	    rtrap = rnd(TRAPNUM-1); 137. 	    switch (rtrap) { 138. 	     case HOLE:		/* no random holes on special levels */ 139. 	     case MAGIC_PORTAL:	rtrap = NO_TRAP; 140. 				break; 141. 	     case TRAPDOOR:	if (!Can_dig_down(&u.uz)) rtrap = NO_TRAP; 142. 				break; 143. 	     case LEVEL_TELEP: 144. 	     case TELEP_TRAP:	if (level.flags.noteleport) rtrap = NO_TRAP; 145. 				break; 146. 	     case ROLLING_BOULDER_TRAP: 147. 	     case ROCKTRAP:	if (In_endgame(&u.uz)) rtrap = NO_TRAP; 148. 				break; 149. 	    }  150.  	} while (rtrap == NO_TRAP); 151. 	return rtrap; 152. }  153.   154.  /*  155.   * Coordinates in special level files are handled specially: 156.  *  157.   *	if x or y is -11, we generate a random coordinate. 158.  *	if x or y is between -1 and -10, we read one from the corresponding 159.  *	register (x0, x1, ... x9). 160.  *	if x or y is nonnegative, we convert it from relative to the local map 161.  *	to global coordinates. 162.  *	The "humidity" flag is used to insure that engravings aren't  163. *	created underwater, or eels on dry land. 164.  */  165.  #define DRY	0x1 166. #define WET	0x2 167.  168.  STATIC_DCL boolean FDECL(is_ok_location, (SCHAR_P, SCHAR_P, int)); 169.  170.  STATIC_OVL void 171. get_location(x, y, humidity) 172. schar *x, *y; 173. int humidity; 174. {  175.  	int cpt = 0; 176.  177.  	if (*x >= 0) {			/* normal locations */ 178. 		*x += xstart; 179. 		*y += ystart; 180. 	} else if (*x > -11) {		/* special locations */ 181. 		*y = ystart + rloc_y[ - *y - 1]; 182. 		*x = xstart + rloc_x[ - *x - 1]; 183. 	} else {			/* random location */ 184. 	    do { 185. 		*x = xstart + rn2((int)xsize); 186. 		*y = ystart + rn2((int)ysize); 187. 		if (is_ok_location(*x,*y,humidity)) break; 188. 	    } while (++cpt < 100); 189. 	    if (cpt >= 100) { 190. 		register int xx, yy; 191. 		/* last try */ 192. 		for (xx = 0; xx < xsize; xx++) 193. 		    for (yy = 0; yy < ysize; yy++) { 194. 			*x = xstart + xx; 195. 			*y = ystart + yy; 196. 			if (is_ok_location(*x,*y,humidity)) goto found_it; 197. 		    }  198.  		panic("get_location:  can't find a place!"); 199. 	    }  200.  	}  201.  found_it:; 202.  203.  	if (!isok(*x,*y)) { 204. 	    impossible("get_location:  (%d,%d) out of bounds", *x, *y); 205. 	    *x = x_maze_max; *y = y_maze_max; 206. 	}  207.  }  208.   209.  STATIC_OVL boolean 210. is_ok_location(x, y, humidity) 211. register schar x, y;  212. register int humidity; 213. {  214.  	register int typ; 215.  216.  	if (Is_waterlevel(&u.uz)) return TRUE;	/* accept any spot */ 217.  218.  	if (humidity & DRY) { 219. 	    typ = levl[x][y].typ; 220. 	    if (typ == ROOM || typ == AIR ||  221.  		    typ == CLOUD || typ == ICE || typ == CORR) 222. 		return TRUE; 223. 	}  224.  	if (humidity & WET) { 225. 	    if (is_pool(x,y) || is_lava(x,y)) 226. 		return TRUE; 227. 	}  228.  	return FALSE; 229. }  230.   231.  /*  232.   * Shuffle the registers for locations, objects or monsters 233.  */  234.   235.  STATIC_OVL void 236. sp_lev_shuffle(list1, list2, n)  237. char list1[], list2[]; 238. int n;  239. { 240.  	register int i, j;  241. register char k; 242. 243. 	for (i = n - 1; i > 0; i--) { 244. 		if ((j = rn2(i + 1)) == i) continue; 245. 		k = list1[j]; 246. 		list1[j] = list1[i]; 247. 		list1[i] = k;  248. if (list2) { 249. 			k = list2[j]; 250. 			list2[j] = list2[i]; 251. 			list2[i] = k;  252. } 253.  	}  254.  }  255.   256.  /*  257.   * Get a relative position inside a room. 258.  * negative values for x or y means RANDOM! 259.  */  260.   261.  STATIC_OVL void 262. get_room_loc(x,y, croom) 263. schar		*x, *y; 264. struct mkroom	*croom; 265. {  266.  	coord c;  267. 268. 	if (*x <0 && *y <0) { 269. 		if (somexy(croom, &c)) { 270. 			*x = c.x;  271. *y = c.y; 272. } else 273. 		    panic("get_room_loc : can't find a place!"); 274. 	} else { 275. 		if (*x < 0) 276. 		    *x = rn2(croom->hx - croom->lx + 1); 277. 		if (*y < 0) 278. 		    *y = rn2(croom->hy - croom->ly + 1); 279. 		*x += croom->lx; 280. 		*y += croom->ly; 281. 	}  282.  }  283.   284.  /*  285.   * Get a relative position inside a room. 286.  * negative values for x or y means RANDOM! 287.  */  288.   289.  STATIC_OVL void 290. get_free_room_loc(x,y, croom) 291. schar		*x, *y; 292. struct mkroom	*croom; 293. {  294.  	schar try_x, try_y; 295. 	register int trycnt = 0; 296.  297.  	do { 298. 	    try_x = *x,  try_y = *y; 299. 	    get_room_loc(&try_x, &try_y, croom); 300. 	} while (levl[try_x][try_y].typ != ROOM && ++trycnt <= 100); 301.  302.  	if (trycnt > 100) 303. 	    panic("get_free_room_loc:  can't find a place!"); 304. 	*x = try_x,  *y = try_y; 305. }  306.   307.  boolean 308. check_room(lowx, ddx, lowy, ddy, vault) 309. xchar *lowx, *ddx, *lowy, *ddy; 310. boolean vault; 311. {  312.  	register int x,y,hix = *lowx + *ddx, hiy = *lowy + *ddy; 313. 	register struct rm *lev; 314. 	int xlim, ylim, ymax; 315.  316.  	xlim = XLIM + (vault ? 1 : 0); 317. 	ylim = YLIM + (vault ? 1 : 0); 318.  319.  	if (*lowx < 3)		*lowx = 3; 320. 	if (*lowy < 2)		*lowy = 2; 321. 	if (hix > COLNO-3)	hix = COLNO-3; 322. 	if (hiy > ROWNO-3)	hiy = ROWNO-3; 323. chk: 324. 	if (hix <= *lowx || hiy <= *lowy)	return FALSE; 325.  326.  	/* check area around room (and make room smaller if necessary) */ 327. 	for (x = *lowx - xlim; x<= hix + xlim; x++) { 328. 		if(x <= 0 || x >= COLNO) continue; 329. 		y = *lowy - ylim;	ymax = hiy + ylim; 330. 		if(y < 0) y = 0; 331. 		if(ymax >= ROWNO) ymax = (ROWNO-1); 332. 		lev = &levl[x][y]; 333. 		for (y <= ymax; y++) { 334. 			if (lev++->typ) { 335. #ifdef DEBUG 336. 				if(!vault) 337. 				    debugpline("strange area [%d,%d] in check_room.",x,y); 338. #endif 339. 				if (!rn2(3))	return FALSE; 340. 				if (x < *lowx) 341. 				    *lowx = x + xlim + 1; 342. 				else 343. 				    hix = x - xlim - 1; 344. 				if (y < *lowy) 345. 				    *lowy = y + ylim + 1; 346. 				else 347. 				    hiy = y - ylim - 1; 348. 				goto chk; 349. 			}  350.  		}  351.  	}  352.  	*ddx = hix - *lowx; 353. 	*ddy = hiy - *lowy; 354. 	return TRUE; 355. }  356.   357.  /*  358.   * Create a new room. 359.  * This is still very incomplete...  360. */ 361.   362.  boolean 363. create_room(x,y,w,h,xal,yal,rtype,rlit) 364. xchar	x,y; 365. xchar	w,h; 366. xchar	xal,yal; 367. xchar	rtype, rlit; 368. {  369.  	xchar	xabs, yabs; 370. 	int	wtmp, htmp, xaltmp, yaltmp, xtmp, ytmp; 371. 	NhRect	*r1 = 0, r2; 372. 	int	trycnt = 0; 373. 	boolean	vault = FALSE; 374. 	int	xlim = XLIM, ylim = YLIM; 375.  376.  	if (rtype == -1)	/* Is the type random ? */ 377.  	    rtype = OROOM; 378.  379.  	if (rtype == VAULT) { 380. 		vault = TRUE; 381. 		xlim++; 382. 		ylim++; 383. 	}  384.   385.  	/* on low levels the room is lit (usually) */ 386. 	/* some other rooms may require lighting */ 387.  388.  	/* is light state random ? */ 389.  	if (rlit == -1) 390. 	    rlit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77)) ? TRUE : FALSE; 391.  392.  	/*  393.  	 * Here we will try to create a room. If some parameters are 394. 	 * random we are willing to make several try before we give 395. 	 * it up. 396. 	 */  397.  	do { 398. 		xchar xborder, yborder; 399. 		wtmp = w; htmp = h;  400. xtmp = x; ytmp = y; 401. xaltmp = xal; yaltmp = yal; 402.  403.  		/* First case : a totaly random room */ 404.  405.  		if((xtmp < 0 && ytmp <0 && wtmp < 0 && xaltmp < 0 && 406. 		   yaltmp < 0) || vault) { 407. 			xchar hx, hy, lx, ly, dx, dy; 408. 			r1 = rnd_rect; /* Get a random rectangle */ 409.  410.  			if (!r1) { /* No more free rectangles ! */ 411.  #ifdef DEBUG 412. 				debugpline("No more rects..."); 413. #endif 414. 				return FALSE; 415. 			}  416.  			hx = r1->hx; 417. 			hy = r1->hy; 418. 			lx = r1->lx; 419. 			ly = r1->ly; 420. 			if (vault) 421. 			    dx = dy = 1; 422. 			else { 423. 				dx = 2 + rn2((hx-lx > 28) ? 12 : 8); 424. 				dy = 2 + rn2(4); 425. 				if(dx*dy > 50) 426. 				    dy = 50/dx; 427. 			}  428.  			xborder = (lx > 0 && hx < COLNO -1) ? 2*xlim : xlim+1; 429. 			yborder = (ly > 0 && hy < ROWNO -1) ? 2*ylim : ylim+1; 430. 			if(hx-lx < dx + 3 + xborder ||  431.  			   hy-ly < dy + 3 + yborder) { 432. 				r1 = 0; 433. 				continue; 434. 			}  435.  			xabs = lx + (lx > 0 ? xlim : 3) 436. 			    + rn2(hx - (lx>0?lx : 3) - dx - xborder + 1); 437. 			yabs = ly + (ly > 0 ? ylim : 2) 438. 			    + rn2(hy - (ly>0?ly : 2) - dy - yborder + 1); 439. 			if (ly == 0 && hy >= (ROWNO-1) &&  440.  			    (!nroom || !rn2(nroom)) && (yabs+dy > ROWNO/2)) { 441. 			    yabs = rn1(3, 2); 442. 			    if(nroom < 4 && dy>1) dy--; 443. 		        }  444.  			if (!check_room(&xabs, &dx, &yabs, &dy, vault)) { 445. 				r1 = 0; 446. 				continue; 447. 			}  448.  			wtmp = dx+1; 449. 			htmp = dy+1; 450. 			r2.lx = xabs-1; r2.ly = yabs-1; 451. 			r2.hx = xabs + wtmp; 452. 			r2.hy = yabs + htmp; 453. 		} else {	/* Only some parameters are random */ 454. 			int rndpos = 0; 455. 			if (xtmp < 0 && ytmp < 0) { /* Position is RANDOM */ 456. 				xtmp = rnd(5); 457. 				ytmp = rnd(5); 458. 				rndpos = 1; 459. 			}  460.  			if (wtmp < 0 || htmp < 0) { /* Size is RANDOM */ 461. 				wtmp = rn1(15, 3); 462. 				htmp = rn1(8, 2); 463. 			}  464.  			if (xaltmp == -1) /* Horizontal alignment is RANDOM */ 465. 			    xaltmp = rnd(3); 466. 			if (yaltmp == -1) /* Vertical alignment is RANDOM */ 467. 			    yaltmp = rnd(3); 468.  469.  			/* Try to generate real (absolute) coordinates here! */ 470.   471.  			xabs = (((xtmp-1) * COLNO) / 5) + 1; 472. 			yabs = (((ytmp-1) * ROWNO) / 5) + 1; 473. 			switch (xaltmp) { 474. 			      case LEFT: 475. 				break; 476. 			      case RIGHT: 477. 				xabs += (COLNO / 5) - wtmp; 478. 				break; 479. 			      case CENTER: 480. 				xabs += ((COLNO / 5) - wtmp) / 2; 481. 				break; 482. 			}  483.  			switch (yaltmp) { 484. 			      case TOP: 485. 				break; 486. 			      case BOTTOM: 487. 				yabs += (ROWNO / 5) - htmp; 488. 				break; 489. 			      case CENTER: 490. 				yabs += ((ROWNO / 5) - htmp) / 2; 491. 				break; 492. 			}  493.   494.  			if (xabs + wtmp - 1 > COLNO - 2) 495. 			    xabs = COLNO - wtmp - 3; 496. 			if (xabs < 2) 497. 			    xabs = 2; 498. 			if (yabs + htmp - 1> ROWNO - 2) 499. 			    yabs = ROWNO - htmp - 3; 500. 			if (yabs < 2) 501. 			    yabs = 2; 502.  503.  			/* Try to find a rectangle that fit our room ! */ 504.   505.  			r2.lx = xabs-1; r2.ly = yabs-1; 506. 			r2.hx = xabs + wtmp + rndpos; 507. 			r2.hy = yabs + htmp + rndpos; 508. 			r1 = get_rect(&r2); 509. 		}  510.  	} while (++trycnt <= 100 && !r1); 511. 	if (!r1) {	/* creation of room failed ? */ 512.  		return FALSE; 513. 	}  514.  	split_rects(r1, &r2); 515.  516.  	if (!vault) { 517. 		smeq[nroom] = nroom; 518. 		add_room(xabs, yabs, xabs+wtmp-1, yabs+htmp-1,  519.  			 rlit, rtype, FALSE); 520. 	} else { 521. 		rooms[nroom].lx = xabs; 522. 		rooms[nroom].ly = yabs; 523. 	}  524.  	return TRUE; 525. }  526.   527.  /*  528.   * Create a subroom in room proom at pos x,y with width w & height h.  529. * x & y are relative to the parent room. 530.  */  531.   532.  STATIC_OVL boolean 533. create_subroom(proom, x, y, w,  h, rtype, rlit) 534. struct mkroom *proom; 535. xchar x,y; 536. xchar w,h; 537. xchar rtype, rlit; 538. {  539.  	xchar width, height; 540.  541.  	width = proom->hx - proom->lx + 1; 542. 	height = proom->hy - proom->ly + 1; 543.  544.  	/* There is a minimum size for the parent room */ 545. 	if (width < 4 || height < 4) 546. 	    return FALSE; 547.  548.  	/* Check for random position, size, etc... */ 549.   550.  	if (w == -1) 551. 	    w = rnd(width - 3); 552. 	if (h == -1) 553. 	    h = rnd(height - 3); 554. 	if (x == -1) 555. 	    x = rnd(width - w - 1) - 1; 556. 	if (y == -1) 557. 	    y = rnd(height - h - 1) - 1; 558. 	if (x == 1) 559. 	    x = 0; 560. 	if (y == 1) 561. 	    y = 0; 562. 	if ((x + w + 1) == width) 563. 	    x++; 564. 	if ((y + h + 1) == height) 565. 	    y++; 566. 	if (rtype == -1) 567. 	    rtype = OROOM; 568. 	if (rlit == -1) 569. 	    rlit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77)) ? TRUE : FALSE; 570. 	add_subroom(proom, proom->lx + x, proom->ly + y,  571.  		    proom->lx + x + w - 1, proom->ly + y + h - 1,  572.  		    rlit, rtype, FALSE); 573. 	return TRUE; 574. }  575.   576.  /*  577.   * Create a new door in a room. 578.  * It's placed on a wall (north, south, east or west). 579.  */  580.   581.  STATIC_OVL void 582. create_door(dd, broom) 583. room_door *dd; 584. struct mkroom *broom; 585. {  586.  	int	x, y;  587. int	trycnt = 0; 588.  589.  	if (dd->secret == -1) 590. 	    dd->secret = rn2(2); 591.  592.  	if (dd->mask == -1) { 593. 		/* is it a locked door, closed, or a doorway? */ 594.  		if (!dd->secret) { 595. 			if(!rn2(3)) { 596. 				if(!rn2(5)) 597. 				    dd->mask = D_ISOPEN; 598. 				else if(!rn2(6)) 599. 				    dd->mask = D_LOCKED; 600. 				else 601. 				    dd->mask = D_CLOSED; 602. 				if (dd->mask != D_ISOPEN && !rn2(25)) 603. 				    dd->mask |= D_TRAPPED; 604. 			} else 605. 			    dd->mask = D_NODOOR; 606. 		} else { 607. 			if(!rn2(5))	dd->mask = D_LOCKED; 608. 			else		dd->mask = D_CLOSED; 609.  610.  			if(!rn2(20)) dd->mask |= D_TRAPPED; 611. 		}  612.  	}  613.   614.  	do { 615. 		register int dwall, dpos; 616.  617.  		dwall = dd->wall; 618. 		if (dwall == -1)	/* The wall is RANDOM */ 619. 		    dwall = 1 << rn2(4); 620.  621.  		dpos = dd->pos; 622. 		if (dpos == -1)	/* The position is RANDOM */ 623. 		    dpos = rn2((dwall == W_WEST || dwall == W_EAST) ?  624.  			    (broom->hy - broom->ly) : (broom->hx - broom->lx)); 625.  626.  		/* Convert wall and pos into an absolute coordinate! */ 627.   628.  		switch (dwall) { 629. 		      case W_NORTH: 630. 			y = broom->ly - 1; 631. 			x = broom->lx + dpos; 632. 			break; 633. 		      case W_SOUTH: 634. 			y = broom->hy + 1; 635. 			x = broom->lx + dpos; 636. 			break; 637. 		      case W_WEST: 638. 			x = broom->lx - 1; 639. 			y = broom->ly + dpos; 640. 			break; 641. 		      case W_EAST: 642. 			x = broom->hx + 1; 643. 			y = broom->ly + dpos; 644. 			break; 645. 		      default: 646. 			x = y = 0; 647. 			panic("create_door: No wall for door!"); 648. 			break; 649. 		}  650.  		if (okdoor(x,y)) 651. 		    break; 652. 	} while (++trycnt <= 100); 653. 	if (trycnt > 100) { 654. 		impossible("create_door: Can't find a proper place!"); 655. 		return; 656. 	}  657.  	add_door(x,y,broom); 658. 	levl[x][y].typ = (dd->secret ? SDOOR : DOOR); 659. 	levl[x][y].doormask = dd->mask; 660. }  661.   662.  /*  663.   * Create a secret door in croom on any one of the specified walls. 664.  */  665.  void 666. create_secret_door(croom, walls) 667.     struct mkroom *croom; 668.     xchar walls; /* any of W_NORTH | W_SOUTH | W_EAST | W_WEST (or W_ANY) */ 669. {  670.      xchar sx, sy; /* location of the secret door */ 671.     int count; 672.  673.      for(count = 0; count < 100; count++) { 674. 	sx = rn1(croom->hx - croom->lx + 1, croom->lx); 675. 	sy = rn1(croom->hy - croom->ly + 1, croom->ly); 676.  677.  	switch(rn2(4)) { 678. 	case 0:  /* top */ 679. 	    if(!(walls & W_NORTH)) continue; 680. 	    sy = croom->ly-1; break; 681. 	case 1: /* bottom */ 682. 	    if(!(walls & W_SOUTH)) continue; 683. 	    sy = croom->hy+1; break; 684. 	case 2: /* left */ 685. 	    if(!(walls & W_EAST)) continue; 686. 	    sx = croom->lx-1; break; 687. 	case 3: /* right */ 688. 	    if(!(walls & W_WEST)) continue; 689. 	    sx = croom->hx+1; break; 690. 	}  691.   692.  	if(okdoor(sx,sy)) { 693. 	    levl[sx][sy].typ = SDOOR; 694. 	    levl[sx][sy].doormask = D_CLOSED; 695. 	    add_door(sx,sy,croom); 696. 	    return; 697. 	}  698.      }  699.   700.      impossible("couldn't create secret door on any walls 0x%x", walls); 701. }  702.   703.  /*  704.   * Create a trap in a room. 705.  */  706.   707.  STATIC_OVL void 708. create_trap(t,croom) 709. trap	*t; 710. struct mkroom	*croom; 711. {  712.      schar	x,y; 713.     coord	tm; 714.  715.      if (rn2(100) < t->chance) { 716. 	x = t->x; 717. 	y = t->y; 718. 	if (croom) 719. 	    get_free_room_loc(&x, &y, croom); 720. 	else 721. 	    get_location(&x, &y, DRY); 722.  723.  	tm.x = x;  724. tm.y = y; 725. 726. 	mktrap(t->type, 1, (struct mkroom*) 0, &tm); 727.     }  728.  }  729.   730.  /*  731.   * Create a monster in a room. 732.  */  733.   734.  STATIC_OVL int 735. noncoalignment(alignment) 736. aligntyp alignment; 737. {  738.  	int k;  739. 740. 	k = rn2(2); 741. 	if (!alignment) 742. 		return(k ? -1 : 1); 743. 	return(k ? -alignment : 0); 744. }  745.   746.  STATIC_OVL void 747. create_monster(m,croom) 748. monster	*m; 749. struct mkroom	*croom; 750. {  751.      struct monst *mtmp; 752.     schar x, y;  753. char class; 754.     aligntyp amask; 755.     coord cc; 756.     struct permonst *pm; 757.     unsigned g_mvflags; 758.  759.      if (rn2(100) < m->chance) { 760.  761.  	if (m->class >= 0) 762. 	    class = (char) def_char_to_monclass((char)m->class); 763. 	else if (m->class > -11) 764. 	    class = (char) def_char_to_monclass(rmonst[- m->class - 1]); 765. 	else 766. 	    class = 0; 767.  768.  	if (class == MAXMCLASSES) 769. 	    panic("create_monster: unknown monster class '%c'", m->class); 770.  771.  	amask = (m->align == AM_SPLEV_CO) ? 772. 			Align2amask(u.ualignbase[A_ORIGINAL]) : 773. 		(m->align == AM_SPLEV_NONCO) ? 774. 			Align2amask(noncoalignment(u.ualignbase[A_ORIGINAL])) : 775. 		(m->align <= -11) ? induced_align(80) : 776. 		(m->align < 0 ? ralign[-m->align-1] : m->align); 777.  778.  	if (!class) 779. 	    pm = (struct permonst *) 0; 780. 	else if (m->id != NON_PM) { 781. 	    pm = &mons[m->id]; 782. 	    g_mvflags = (unsigned) mvitals[monsndx(pm)].mvflags; 783. 	    if ((pm->geno & G_UNIQ) && (g_mvflags & G_EXTINCT)) 784. 		goto m_done; 785. 	    else if (g_mvflags & G_GONE)	/* genocided or extinct */ 786. 		pm = (struct permonst *) 0;	/* make random monster */ 787. 	} else { 788. 	    pm = mkclass(class,G_NOGEN); 789. 	    /* if we can't get a specific monster type (pm == 0) then the 790. 	       class has been genocided, so settle for a random monster */ 791. 	}  792.  	if (In_mines(&u.uz) && pm && your_race(pm) &&  793.  			(Race_if(PM_DWARF) || Race_if(PM_GNOME)) && rn2(3)) 794. 	    pm = (struct permonst *) 0; 795.  796.  	x = m->x; 797. 	y = m->y; 798. 	if (croom) 799. 	    get_room_loc(&x, &y, croom); 800. 	else { 801. 	    if (!pm || !is_swimmer(pm)) 802. 		get_location(&x, &y, DRY); 803. 	    else if (pm->mlet == S_EEL) 804. 		get_location(&x, &y, WET); 805. 	    else 806. 		get_location(&x, &y, DRY|WET); 807. 	}  808.  	/* try to find a close place if someone else is already there */ 809. 	if (MON_AT(x,y) && enexto(&cc, x, y, pm)) 810. 	    x = cc.x,  y = cc.y;  811. 812. 	if(m->align != -12) 813. 	    mtmp = mk_roamer(pm, Amask2align(amask), x, y, m->peaceful); 814. 	else if(PM_ARCHEOLOGIST <= m->id && m->id <= PM_WIZARD) 815. 	         mtmp = mk_mplayer(pm, x, y, FALSE); 816. 	else mtmp = makemon(pm, x, y, NO_MM_FLAGS); 817.  818.  	if (mtmp) { 819. 	    /* handle specific attributes for some special monsters */ 820. 	    if (m->name.str) mtmp = christen_monst(mtmp, m->name.str); 821.  822.  	    /*  823.  	     * This is currently hardwired for mimics only. It should 824. 	     * eventually be expanded. 825. 	     */  826.  	    if (m->appear_as.str && mtmp->data->mlet == S_MIMIC) { 827. 		int i;  828. 829. 		switch (m->appear) { 830. 		    case M_AP_NOTHING: 831. 			impossible(  832.  		"create_monster: mon has an appearance, \"%s\", but no type",  833.  				m->appear_as.str); 834. 			break; 835.  836.  		    case M_AP_FURNITURE: 837. 			for (i = 0; i < MAXPCHARS; i++) 838. 			    if (!strcmp(defsyms[i].explanation, 839. 					m->appear_as.str)) 840. 				break; 841. 			if (i == MAXPCHARS) { 842. 			    impossible(  843.  				"create_monster: can't find feature \"%s\"",  844.  				m->appear_as.str); 845. 			} else { 846. 			    mtmp->m_ap_type = M_AP_FURNITURE; 847. 			    mtmp->mappearance = i;  848. } 849.  			break; 850.  851.  		    case M_AP_OBJECT: 852. 			for (i = 0; i < NUM_OBJECTS; i++) 853. 			    if (OBJ_NAME(objects[i]) &&  854.  				!strcmp(OBJ_NAME(objects[i]),m->appear_as.str)) 855. 				break; 856. 			if (i == NUM_OBJECTS) { 857. 			    impossible(  858.  				"create_monster: can't find object \"%s\"",  859.  				m->appear_as.str); 860. 			} else { 861. 			    mtmp->m_ap_type = M_AP_OBJECT; 862. 			    mtmp->mappearance = i;  863. } 864.  			break; 865.  866.  		    case M_AP_MONSTER: 867. 			/* note: mimics don't appear as monsters! */ 868.  			/*	 (but chameleons can :-)	  */ 869. 		    default: 870. 			impossible(  871.  		"create_monster: unimplemented mon appear type [%d,\"%s\"]",  872.  				m->appear, m->appear_as.str); 873. 			break; 874. 		}  875.  		if (does_block(x, y, &levl[x][y])) 876. 		    block_point(x, y); 877. 	    }  878.   879.  	    if (m->peaceful >= 0) { 880. 		mtmp->mpeaceful = m->peaceful; 881. 		/* changed mpeaceful again; have to reset malign */ 882. 		set_malign(mtmp); 883. 	    }  884.  	    if (m->asleep >= 0) { 885. #ifdef UNIXPC 886. 		/* optimizer bug strikes again */ 887. 		if (m->asleep) 888. 			mtmp->msleeping = 1; 889. 		else 890. 			mtmp->msleeping = 0; 891. #else 892. 		mtmp->msleeping = m->asleep; 893. #endif 894. 	    }  895.  	}  896.   897.      }		/* if (rn2(100) < m->chance) */ 898.  m_done: 899.     Free(m->name.str); 900.     Free(m->appear_as.str); 901. }  902.   903.  /*  904.   * Create an object in a room. 905.  */  906.   907.  STATIC_OVL void 908. create_object(o,croom) 909. object	*o; 910. struct mkroom	*croom; 911. {  912.      struct obj *otmp; 913.     schar x, y;  914. char c; 915. boolean named;	/* has a name been supplied in level description? */ 916.   917.      if (rn2(100) < o->chance) { 918. 	named = o->name.str ? TRUE : FALSE; 919.  920.  	x = o->x; y = o->y; 921. 	if (croom) 922. 	    get_room_loc(&x, &y, croom); 923. 	else 924. 	    get_location(&x, &y, DRY); 925.  926.  	if (o->class >= 0) 927. 	    c = o->class; 928. 	else if (o->class > -11) 929. 	    c = robjects[ -(o->class+1)]; 930. 	else 931. 	    c = 0; 932.  933.  	if (!c) 934. 	    otmp = mkobj_at(RANDOM_CLASS, x, y, !named); 935. 	else if (o->id != -1) 936. 	    otmp = mksobj_at(o->id, x, y, TRUE, !named); 937. 	else { 938. 	    /*  939.  	     * The special levels are compiled with the default "text" object 940. 	     * class characters. We must convert them to the internal format. 941. 	     */  942.  	    char oclass = (char) def_char_to_objclass(c); 943.  944.  	    if (oclass == MAXOCLASSES) 945. 		panic("create_object:  unexpected object class '%c'",c); 946.  947.  	    /* KMH -- Create piles of gold properly */ 948. 	    if (oclass == COIN_CLASS) 949. 		otmp = mkgold(0L, x, y); 950. 	    else 951. 		otmp = mkobj_at(oclass, x, y, !named); 952. 	}  953.   954.  	if (o->spe != -127)	/* That means NOT RANDOM! */ 955.  	    otmp->spe = (schar)o->spe; 956.  957.  	switch (o->curse_state) { 958. 	      case 1:	bless(otmp); break; /* BLESSED */ 959. 	      case 2:	unbless(otmp); uncurse(otmp); break; /* uncursed */ 960. 	      case 3:	curse(otmp); break; /* CURSED */ 961. 	      default:	break;	/* Otherwise it's random and we're happy 962. 				 * with what mkobj gave us! */ 963.  	}  964.   965.  	/*	corpsenm is "empty" if -1, random if -2, otherwise specific */ 966. 	if (o->corpsenm == NON_PM - 1) otmp->corpsenm = rndmonnum; 967. 	else if (o->corpsenm != NON_PM) otmp->corpsenm = o->corpsenm; 968.  969.  	/* assume we wouldn't be given an egg corpsenm unless it was 970. 	   hatchable */ 971. 	if (otmp->otyp == EGG && otmp->corpsenm != NON_PM) { 972. 	    if (dead_species(otmp->otyp, TRUE)) 973. 		kill_egg(otmp);	/* make sure nothing hatches */ 974. 	    else 975. 		attach_egg_hatch_timeout(otmp);	/* attach new hatch timeout */ 976. 	}  977.   978.  	if (named) 979. 	    otmp = oname(otmp, o->name.str); 980.  981.  	switch(o->containment) { 982. 	    static struct obj *container = 0; 983.  984.  	    /* contents */ 985. 	    case 1: 986. 		if (!container) { 987. 		    impossible("create_object: no container"); 988. 		    break; 989. 		}  990.  		remove_object(otmp); 991. 		(void) add_to_container(container, otmp); 992. 		goto o_done;		/* don't stack, but do other cleanup */ 993. 	    /* container */ 994. 	    case 2: 995. 		delete_contents(otmp); 996. 		container = otmp; 997. 		break; 998. 	    /* nothing */ 999. 	    case 0: break; 1000. 1001. 	    default: impossible("containment type %d?", (int) o->containment); 1002. 	} 1003.  1004. 	/* Medusa level special case: statues are petrified monsters, so they 1005. 	 * are not stone-resistant and have monster inventory. They also lack 1006. 	 * other contents, but that can be specified as an empty container. 1007. 	 */ 1008. 	if (o->id == STATUE && Is_medusa_level(&u.uz) &&  1009. 		    o->corpsenm == NON_PM) { 1010. 	   struct monst *was; 1011. 	   struct obj *obj; 1012. 	   int wastyp; 1013. 1014. 	    /* Named random statues are of player types, and aren't stone- 1015. 	    * resistant (if they were, we'd have to reset the name as well as  1016. 	     * setting corpsenm). 1017. 	    */  1018. 	    for (wastyp = otmp->corpsenm; ; wastyp = rndmonnum) { 1019. 		/* makemon without rndmonst might create a group */ 1020. 		was = makemon(&mons[wastyp], 0, 0, NO_MM_FLAGS); 1021. 		if (!resists_ston(was)) break; 1022. 		mongone(was); 1023. 	   }  1024. 	    otmp->corpsenm = wastyp; 1025. 	   while(was->minvent) { 1026. 		obj = was->minvent; 1027. 		obj->owornmask = 0; 1028. 		obj_extract_self(obj); 1029. 		(void) add_to_container(otmp, obj); 1030. 	   }  1031. 	    otmp->owt = weight(otmp); 1032. 	   mongone(was); 1033. 	} 1034.  1035. 	stackobj(otmp); 1036. 1037.     }		/* if (rn2(100) < o->chance) */ 1038. o_done: 1039.    Free(o->name.str); 1040. } 1041.  1042. /*  1043.  * Randomly place a specific engraving, then release its memory. 1044. */  1045. STATIC_OVL void 1046. create_engraving(e, croom) 1047. engraving *e; 1048. struct mkroom *croom; 1049. { 1050. 	xchar x, y;  1051. 1052. 	x = e->x, y = e->y; 1053. 	if (croom) 1054. 	   get_room_loc(&x, &y, croom); 1055. 	else 1056. 	   get_location(&x, &y, DRY); 1057. 1058. 	make_engr_at(x, y, e->engr.str, 0L, e->etype); 1059. 	free((genericptr_t) e->engr.str); 1060. } 1061.  1062. /*  1063.  * Create stairs in a room. 1064. *  1065.  */  1066.  1067. STATIC_OVL void 1068. create_stairs(s,croom) 1069. stair	*s; 1070. struct mkroom	*croom; 1071. { 1072. 	schar		x,y; 1073. 1074. 	x = s->x; y = s->y; 1075. 	get_free_room_loc(&x, &y, croom); 1076. 	mkstairs(x,y,(char)s->up, croom); 1077. } 1078.  1079. /*  1080.  * Create an altar in a room. 1081. */  1082.  1083. STATIC_OVL void 1084. create_altar(a, croom) 1085. 	altar		*a; 1086. 	struct mkroom	*croom; 1087. { 1088. 	schar		sproom,x,y; 1089. 	aligntyp	amask; 1090. 	boolean		croom_is_temple = TRUE; 1091. 	int oldtyp; 1092. 1093. 	x = a->x; y = a->y; 1094. 1095. 	if (croom) { 1096. 	   get_free_room_loc(&x, &y, croom); 1097. 	   if (croom->rtype != TEMPLE) 1098. 		croom_is_temple = FALSE; 1099. 	} else { 1100. 	   get_location(&x, &y, DRY); 1101. 	   if ((sproom = (schar) *in_rooms(x, y, TEMPLE)) != 0) 1102. 		croom = &rooms[sproom - ROOMOFFSET]; 1103. 	   else 1104. 		croom_is_temple = FALSE; 1105. 	} 1106.  1107. 	/* check for existing features */ 1108. 	oldtyp = levl[x][y].typ; 1109. 	if (oldtyp == STAIRS || oldtyp == LADDER) 1110. 	   return; 1111. 1112. 	a->x = x;  1113. a->y = y; 1114. 1115. 	/* Is the alignment random ? 1116. 	 * If so, it's an 80% chance that the altar will be co-aligned. 1117. 	 * 1118. 	 * The alignment is encoded as amask values instead of alignment 1119. 	 * values to avoid conflicting with the rest of the encoding, 1120. 	 * shared by many other parts of the special level code. 1121. 	 */ 1122.  1123. 	amask = (a->align == AM_SPLEV_CO) ? 1124. 			Align2amask(u.ualignbase[A_ORIGINAL]) : 1125. 		(a->align == AM_SPLEV_NONCO) ? 1126. 			Align2amask(noncoalignment(u.ualignbase[A_ORIGINAL])) : 1127. 		(a->align == -11) ? induced_align(80) : 1128. 		(a->align < 0 ? ralign[-a->align-1] : a->align); 1129. 1130. 	levl[x][y].typ = ALTAR; 1131. 	levl[x][y].altarmask = amask; 1132. 1133. 	if (a->shrine < 0) a->shrine = rn2(2);	/* handle random case */ 1134. 1135. 	if (oldtyp == FOUNTAIN) 1136. 	   level.flags.nfountains--; 1137. 	else if (oldtyp == SINK) 1138. 	   level.flags.nsinks--; 1139. 1140. 	if (!croom_is_temple || !a->shrine) return; 1141. 1142. 	if (a->shrine) {	/* Is it a shrine  or sanctum? */ 1143. 	    priestini(&u.uz, croom, x, y, (a->shrine > 1)); 1144. 	   levl[x][y].altarmask |= AM_SHRINE; 1145. 	   level.flags.has_temple = TRUE; 1146. 	} 1147. }  1148.  1149. /*  1150.  * Create a gold pile in a room. 1151. */  1152.  1153. STATIC_OVL void 1154. create_gold(g,croom) 1155. gold *g; 1156. struct mkroom	*croom; 1157. { 1158. 	schar		x,y; 1159. 1160. 	x = g->x; y= g->y; 1161. 	if (croom) 1162. 	   get_room_loc(&x, &y, croom); 1163. 	else 1164. 	   get_location(&x, &y, DRY); 1165. 1166. 	if (g->amount == -1) 1167. 	   g->amount = rnd(200); 1168. 	(void) mkgold((long) g->amount, x, y); 1169. } 1170.  1171. /*  1172.  * Create a feature (e.g a fountain) in a room. 1173. */  1174.  1175. STATIC_OVL void 1176. create_feature(fx, fy, croom, typ) 1177. int		fx, fy; 1178. struct mkroom	*croom; 1179. int		typ; 1180. { 1181. 	schar		x,y; 1182. 	int		trycnt = 0; 1183. 1184. 	x = fx;  y = fy; 1185. 	if (croom) { 1186. 	   if (x < 0 && y < 0) 1187. 		do { 1188. 		   x = -1;  y = -1; 1189. 		   get_room_loc(&x, &y, croom); 1190. 		} while (++trycnt <= 200 && occupied(x,y)); 1191. 	   else 1192. 		get_room_loc(&x, &y, croom); 1193. 	   if(trycnt > 200) 1194. 		return; 1195. 	} else { 1196. 	   get_location(&x, &y, DRY); 1197. 	} 1198. 	/* Don't cover up an existing feature (particularly randomly  1199. 	   placed stairs). However, if the _same_ feature is already 1200. 	  here, it came from the map drawing and we still need to  1201. update the special counters. */ 1202. 	if (IS_FURNITURE(levl[x][y].typ) && levl[x][y].typ != typ) 1203. 	   return; 1204. 1205. 	levl[x][y].typ = typ; 1206. 	if (typ == FOUNTAIN) 1207. 	   level.flags.nfountains++; 1208. 	else if (typ == SINK) 1209. 	   level.flags.nsinks++; 1210. } 1211.  1212. /*  1213.  * Search for a door in a room on a specified wall. 1214. */  1215.  1216. STATIC_OVL boolean 1217. search_door(croom,x,y,wall,cnt) 1218. struct mkroom *croom; 1219. xchar *x, *y; 1220. xchar wall; 1221. int cnt; 1222. { 1223. 	int dx, dy; 1224. 	int xx,yy; 1225. 1226. 	switch(wall) { 1227. 	     case W_NORTH: 1228. 		dy = 0; dx = 1; 1229. 		xx = croom->lx; 1230. 		yy = croom->hy + 1; 1231. 		break; 1232. 	     case W_SOUTH: 1233. 		dy = 0; dx = 1; 1234. 		xx = croom->lx; 1235. 		yy = croom->ly - 1; 1236. 		break; 1237. 	     case W_EAST: 1238. 		dy = 1; dx = 0; 1239. 		xx = croom->hx + 1; 1240. 		yy = croom->ly; 1241. 		break; 1242. 	     case W_WEST: 1243. 		dy = 1; dx = 0; 1244. 		xx = croom->lx - 1; 1245. 		yy = croom->ly; 1246. 		break; 1247. 	     default: 1248. 		dx = dy = xx = yy = 0; 1249. 		panic("search_door: Bad wall!"); 1250. 		break; 1251. 	} 1252. 	while (xx <= croom->hx+1 && yy <= croom->hy+1) { 1253. 		if (IS_DOOR(levl[xx][yy].typ) || levl[xx][yy].typ == SDOOR) { 1254. 			*x = xx; 1255. 			*y = yy; 1256. 			if (cnt-- <= 0) 1257. 			   return TRUE; 1258. 		} 1259. 		xx += dx; 1260. 		yy += dy; 1261. 	} 1262. 	return FALSE; 1263. } 1264.  1265. /*  1266.  * Dig a corridor between two points. 1267. */  1268.  1269. boolean 1270. dig_corridor(org,dest,nxcor,ftyp,btyp) 1271. coord *org, *dest; 1272. boolean nxcor; 1273. schar ftyp, btyp; 1274. { 1275. 	register int dx=0, dy=0, dix, diy, cct; 1276. 	register struct rm *crm; 1277. 	register int tx, ty, xx, yy; 1278. 1279. 	xx = org->x;  yy = org->y; 1280. 	tx = dest->x; ty = dest->y; 1281. 	if (xx <= 0 || yy <= 0 || tx <= 0 || ty <= 0 || 1282. 	    xx > COLNO-1 || tx > COLNO-1 ||  1283. 	    yy > ROWNO-1 || ty > ROWNO-1) { 1284. #ifdef DEBUG 1285. 		debugpline("dig_corridor: bad coords : (%d,%d) (%d,%d).", 1286. 			   xx,yy,tx,ty); 1287. #endif 1288. 		return FALSE; 1289. 	} 1290. 	if (tx > xx)		dx = 1; 1291. 	else if (ty > yy)	dy = 1; 1292. 	else if (tx < xx)	dx = -1; 1293. 	else			dy = -1; 1294. 1295. 	xx -= dx; 1296. 	yy -= dy; 1297. 	cct = 0; 1298. 	while(xx != tx || yy != ty) { 1299. 	   /* loop: dig corridor at [xx,yy] and find new [xx,yy] */ 1300. 	   if(cct++ > 500 || (nxcor && !rn2(35))) 1301. 		return FALSE; 1302. 1303. 	    xx += dx; 1304. 	   yy += dy; 1305. 1306. 	    if(xx >= COLNO-1 || xx <= 0 || yy <= 0 || yy >= ROWNO-1) 1307. 		return FALSE;		/* impossible */ 1308. 1309. 	    crm = &levl[xx][yy]; 1310. 	   if(crm->typ == btyp) { 1311. 		if(ftyp != CORR || rn2(100)) { 1312. 			crm->typ = ftyp; 1313. 			if(nxcor && !rn2(50)) 1314. 				(void) mksobj_at(BOULDER, xx, yy, TRUE, FALSE); 1315. 		} else { 1316. 			crm->typ = SCORR; 1317. 		} 1318. 	    } else 1319. 	   if(crm->typ != ftyp && crm->typ != SCORR) { 1320. 		/* strange ... */ 1321. 		return FALSE; 1322. 	   }  1323.  1324. 	    /* find next corridor position */ 1325. 	   dix = abs(xx-tx); 1326. 	   diy = abs(yy-ty); 1327. 1328. 	    /* do we have to change direction ? */ 1329. 	    if(dy && dix > diy) { 1330. 		register int ddx = (xx > tx) ? -1 : 1; 1331.  1332. 		crm = &levl[xx+ddx][yy]; 1333. 		if(crm->typ == btyp || crm->typ == ftyp || crm->typ == SCORR) { 1334. 		   dx = ddx; 1335. 		   dy = 0; 1336. 		   continue; 1337. 		} 1338. 	    } else if(dx && diy > dix) { 1339. 		register int ddy = (yy > ty) ? -1 : 1; 1340.  1341. 		crm = &levl[xx][yy+ddy]; 1342. 		if(crm->typ == btyp || crm->typ == ftyp || crm->typ == SCORR) { 1343. 		   dy = ddy; 1344. 		   dx = 0; 1345. 		   continue; 1346. 		} 1347. 	    }  1348.  1349. 	    /* continue straight on? */ 1350. 	    crm = &levl[xx+dx][yy+dy]; 1351. 	   if(crm->typ == btyp || crm->typ == ftyp || crm->typ == SCORR) 1352. 		continue; 1353. 1354. 	    /* no, what must we do now?? */ 1355. 	    if(dx) { 1356. 		dx = 0; 1357. 		dy = (ty < yy) ? -1 : 1; 1358. 	    } else { 1359. 		dy = 0; 1360. 		dx = (tx < xx) ? -1 : 1; 1361. 	    }  1362. 	    crm = &levl[xx+dx][yy+dy]; 1363. 	   if(crm->typ == btyp || crm->typ == ftyp || crm->typ == SCORR) 1364. 		continue; 1365. 	   dy = -dy; 1366. 	   dx = -dx; 1367. 	} 1368. 	return TRUE; 1369. } 1370.  1371. /*  1372.  * Disgusting hack: since special levels have their rooms filled before 1373. * sorting the rooms, we have to re-arrange the speed values upstairs_room 1374. * and dnstairs_room after the rooms have been sorted. On normal levels, 1375. * stairs don't get created until _after_ sorting takes place. 1376. */  1377. STATIC_OVL void 1378. fix_stair_rooms 1379. { 1380.     int i;  1381. struct mkroom *croom; 1382. 1383.     if(xdnstair &&  1384.        !((dnstairs_room->lx <= xdnstair && xdnstair <= dnstairs_room->hx) && 1385. 	 (dnstairs_room->ly <= ydnstair && ydnstair <= dnstairs_room->hy))) { 1386. 	for(i=0; i < nroom; i++) { 1387. 	   croom = &rooms[i]; 1388. 	   if((croom->lx <= xdnstair && xdnstair <= croom->hx) &&  1389. 	       (croom->ly <= ydnstair && ydnstair <= croom->hy)) { 1390. 		dnstairs_room = croom; 1391. 		break; 1392. 	   }  1393. 	}  1394. 	if(i == nroom) 1395. 	   panic("Couldn't find dnstair room in fix_stair_rooms!"); 1396.    }  1397.     if(xupstair &&  1398.        !((upstairs_room->lx <= xupstair && xupstair <= upstairs_room->hx) && 1399. 	 (upstairs_room->ly <= yupstair && yupstair <= upstairs_room->hy))) { 1400. 	for(i=0; i < nroom; i++) { 1401. 	   croom = &rooms[i]; 1402. 	   if((croom->lx <= xupstair && xupstair <= croom->hx) &&  1403. 	       (croom->ly <= yupstair && yupstair <= croom->hy)) { 1404. 		upstairs_room = croom; 1405. 		break; 1406. 	   }  1407. 	}  1408. 	if(i == nroom) 1409. 	   panic("Couldn't find upstair room in fix_stair_rooms!"); 1410.    }  1411. }  1412.  1413. /*  1414.  * Corridors always start from a door. But it can end anywhere... 1415. * Basically we search for door coordinates or for endpoints coordinates 1416. * (from a distance). 1417. */  1418.  1419. STATIC_OVL void 1420. create_corridor(c) 1421. corridor	*c; 1422. { 1423. 	coord org, dest; 1424. 1425. 	if (c->src.room == -1) { 1426. 		sort_rooms; 1427. 		fix_stair_rooms; 1428. 		makecorridors; 1429. 		return; 1430. 	} 1431.  1432. 	if( !search_door(&rooms[c->src.room], &org.x, &org.y, c->src.wall, 1433. 			 c->src.door)) 1434. 	   return; 1435. 1436. 	if (c->dest.room != -1) { 1437. 		if(!search_door(&rooms[c->dest.room], &dest.x, &dest.y, 1438. c->dest.wall, c->dest.door)) 1439. 		   return; 1440. 		switch(c->src.wall) { 1441. 		     case W_NORTH: org.y--; break; 1442. 		     case W_SOUTH: org.y++; break; 1443. 		     case W_WEST:  org.x--; break; 1444. 		     case W_EAST:  org.x++; break; 1445. 		} 1446. 		switch(c->dest.wall) { 1447. 		     case W_NORTH: dest.y--; break; 1448. 		     case W_SOUTH: dest.y++; break; 1449. 		     case W_WEST:  dest.x--; break; 1450. 		     case W_EAST:  dest.x++; break; 1451. 		} 1452. 		(void) dig_corridor(&org, &dest, FALSE, CORR, STONE); 1453. 	} 1454. }  1455.  1456.  1457. /*  1458.  * Fill a room (shop, zoo, etc...) with appropriate stuff. 1459. */  1460.  1461. void 1462. fill_room(croom, prefilled) 1463. struct mkroom *croom; 1464. boolean prefilled; 1465. { 1466. 	if (!croom || croom->rtype == OROOM) 1467. 	   return; 1468. 1469. 	if (!prefilled) { 1470. 	   int x,y; 1471. 1472. 	    /* Shop ? */ 1473. 	    if (croom->rtype >= SHOPBASE) { 1474. 		   stock_room(croom->rtype - SHOPBASE, croom); 1475. 		   level.flags.has_shop = TRUE; 1476. 		   return; 1477. 	   }  1478.  1479. 	    switch (croom->rtype) { 1480. 		case VAULT: 1481. 		   for (x=croom->lx;x<=croom->hx;x++) 1482. 			for (y=croom->ly;y<=croom->hy;y++) 1483. 			   (void) mkgold((long)rn1(abs(depth(&u.uz))*100, 51), x, y); 1484. 		   break; 1485. 		case COURT: 1486. 		case ZOO: 1487. 		case BEEHIVE: 1488. 		case MORGUE: 1489. 		case BARRACKS: 1490. 		   fill_zoo(croom); 1491. 		   break; 1492. 	   }  1493. 	}  1494. 	switch (croom->rtype) { 1495. 	   case VAULT: 1496. 		level.flags.has_vault = TRUE; 1497. 		break; 1498. 	   case ZOO: 1499. 		level.flags.has_zoo = TRUE; 1500. 		break; 1501. 	   case COURT: 1502. 		level.flags.has_court = TRUE; 1503. 		break; 1504. 	   case MORGUE: 1505. 		level.flags.has_morgue = TRUE; 1506. 		break; 1507. 	   case BEEHIVE: 1508. 		level.flags.has_beehive = TRUE; 1509. 		break; 1510. 	   case BARRACKS: 1511. 		level.flags.has_barracks = TRUE; 1512. 		break; 1513. 	   case TEMPLE: 1514. 		level.flags.has_temple = TRUE; 1515. 		break; 1516. 	   case SWAMP: 1517. 		level.flags.has_swamp = TRUE; 1518. 		break; 1519. 	} 1520. }  1521.  1522. STATIC_OVL void 1523. free_rooms(ro, n) 1524. room **ro; 1525. int n; 1526. { 1527. 	short j;  1528. room *r; 1529. 1530. 	while(n--) { 1531. 		r = ro[n]; 1532. 		Free(r->name); 1533. 		Free(r->parent); 1534. 		if ((j = r->ndoor) != 0) { 1535. 			while(j--) 1536. 			   Free(r->doors[j]); 1537. 			Free(r->doors); 1538. 		} 1539. 		if ((j = r->nstair) != 0) { 1540. 			while(j--) 1541. 			   Free(r->stairs[j]); 1542. 			Free(r->stairs); 1543. 		} 1544. 		if ((j = r->naltar) != 0) { 1545. 			while (j--) 1546. 			   Free(r->altars[j]); 1547. 			Free(r->altars); 1548. 		} 1549. 		if ((j = r->nfountain) != 0) { 1550. 			while(j--) 1551. 			   Free(r->fountains[j]); 1552. 			Free(r->fountains); 1553. 		} 1554. 		if ((j = r->nsink) != 0) { 1555. 			while(j--) 1556. 			   Free(r->sinks[j]); 1557. 			Free(r->sinks); 1558. 		} 1559. 		if ((j = r->npool) != 0) { 1560. 			while(j--) 1561. 			   Free(r->pools[j]); 1562. 			Free(r->pools); 1563. 		} 1564. 		if ((j = r->ntrap) != 0) { 1565. 			while (j--) 1566. 			   Free(r->traps[j]); 1567. 			Free(r->traps); 1568. 		} 1569. 		if ((j = r->nmonster) != 0) { 1570. 			while (j--) 1571. 				Free(r->monsters[j]); 1572. 			Free(r->monsters); 1573. 		} 1574. 		if ((j = r->nobject) != 0) { 1575. 			while (j--) 1576. 				Free(r->objects[j]); 1577. 			Free(r->objects); 1578. 		} 1579. 		if ((j = r->ngold) != 0) { 1580. 			while(j--) 1581. 			   Free(r->golds[j]); 1582. 			Free(r->golds); 1583. 		} 1584. 		if ((j = r->nengraving) != 0) { 1585. 			while (j--) 1586. 				Free(r->engravings[j]); 1587. 			Free(r->engravings); 1588. 		} 1589. 		Free(r); 1590. 	} 1591. 	Free(ro); 1592. } 1593.  1594. STATIC_OVL void 1595. build_room(r, pr) 1596. room *r, *pr; 1597. { 1598. 	boolean okroom; 1599. 	struct mkroom	*aroom; 1600. 	short i; 1601. xchar rtype = (!r->chance || rn2(100) < r->chance) ? r->rtype : OROOM; 1602. 1603. 	if(pr) { 1604. 		aroom = &subrooms[nsubroom]; 1605. 		okroom = create_subroom(pr->mkr, r->x, r->y, r->w, r->h, 1606. 					rtype, r->rlit); 1607. 	} else { 1608. 		aroom = &rooms[nroom]; 1609. 		okroom = create_room(r->x, r->y, r->w, r->h, r->xalign, 1610. 				     r->yalign, rtype, r->rlit); 1611. 		r->mkr = aroom; 1612. 	} 1613.  1614. 	if (okroom) { 1615. 		/* Create subrooms if necessary... */ 1616. 		for(i=0; i < r->nsubroom; i++) 1617. 		   build_room(r->subrooms[i], r); 1618. 		/* And now we can fill the room! */ 1619.  1620. 		/* Priority to the stairs */ 1621. 1622. 		for(i=0; i nstair; i++) 1623. 		   create_stairs(r->stairs[i], aroom); 1624. 1625. 		/* Then to the various elements (sinks, etc..) */ 1626. 		for(i = 0; insink; i++) 1627. 		   create_feature(r->sinks[i]->x, r->sinks[i]->y, aroom, SINK); 1628. 		for(i = 0; inpool; i++) 1629. 		   create_feature(r->pools[i]->x, r->pools[i]->y, aroom, POOL); 1630. 		for(i = 0; infountain; i++) 1631. 		   create_feature(r->fountains[i]->x, r->fountains[i]->y,  1632. 				   aroom, FOUNTAIN); 1633. 		for(i = 0; inaltar; i++) 1634. 		   create_altar(r->altars[i], aroom); 1635. 		for(i = 0; indoor; i++) 1636. 		   create_door(r->doors[i], aroom); 1637. 1638. 		/* The traps */ 1639. 		for(i = 0; intrap; i++) 1640. 		   create_trap(r->traps[i], aroom); 1641. 1642. 		/* The monsters */ 1643. 		for(i = 0; inmonster; i++) 1644. 		   create_monster(r->monsters[i], aroom); 1645. 1646. 		/* The objects */ 1647. 		for(i = 0; inobject; i++) 1648. 		   create_object(r->objects[i], aroom); 1649. 1650. 		/* The gold piles */ 1651. 		for(i = 0; ingold; i++) 1652. 		   create_gold(r->golds[i], aroom); 1653. 1654. 		/* The engravings */ 1655. 		for (i = 0; i < r->nengraving; i++) 1656. 		   create_engraving(r->engravings[i], aroom); 1657. 1658. #ifdef SPECIALIZATION 1659. 		topologize(aroom,FALSE);		/* set roomno */ 1660. #else 1661. 		topologize(aroom);			/* set roomno */ 1662. #endif 1663. 		/* MRS - 07/04/91 - This is temporary but should result 1664. 		 * in proper filling of shops, etc. 1665. 		 * DLC - this can fail if corridors are added to this room 1666. 		 * at a later point. Currently no good way to fix this. 1667. 		 */ 1668. 		if(aroom->rtype != OROOM && r->filled) fill_room(aroom, FALSE); 1669. 	} 1670. }  1671.  1672. /*  1673.  * set lighting in a region that will not become a room. 1674. */  1675. STATIC_OVL void 1676. light_region(tmpregion) 1677.    region  *tmpregion; 1678. { 1679.     register boolean litstate = tmpregion->rlit ? 1 : 0; 1680.     register int hiy = tmpregion->y2; 1681.    register int x, y;  1682. register struct rm *lev; 1683.    int lowy = tmpregion->y1; 1684.    int lowx = tmpregion->x1, hix = tmpregion->x2; 1685. 1686.     if(litstate) { 1687. 	/* adjust region size for walls, but only if lighted */ 1688. 	lowx = max(lowx-1,1); 1689. 	hix = min(hix+1,COLNO-1); 1690. 	lowy = max(lowy-1,0); 1691. 	hiy = min(hiy+1, ROWNO-1); 1692.    }  1693.     for(x = lowx; x <= hix; x++) { 1694. 	lev = &levl[x][lowy]; 1695. 	for(y = lowy; y <= hiy; y++) { 1696. 	   if (lev->typ != LAVAPOOL) /* this overrides normal lighting */ 1697. 		lev->lit = litstate; 1698. 	   lev++; 1699. 	} 1700.     }  1701. }  1702.  1703. /* initialization common to all special levels */ 1704. STATIC_OVL void 1705. load_common_data(fd, typ) 1706. dlb *fd; 1707. int typ; 1708. { 1709. 	uchar	n; 1710. 	long	lev_flags; 1711. 	int	i; 1712. 1713.       {  1714. 	aligntyp atmp; 1715. 	/* shuffle 3 alignments; can't use sp_lev_shuffle on aligntyp's */ 1716. 	i = rn2(3);  atmp=ralign[2]; ralign[2]=ralign[i]; ralign[i]=atmp; 1717. 	if (rn2(2)) { atmp=ralign[1]; ralign[1]=ralign[0]; ralign[0]=atmp; } 1718.      }  1719.  1720. 	level.flags.is_maze_lev = typ == SP_LEV_MAZE; 1721. 1722. 	/* Read the level initialization data */ 1723. 	Fread((genericptr_t) &init_lev, 1, sizeof(lev_init), fd); 1724. 	if(init_lev.init_present) { 1725. 	   if(init_lev.lit < 0) 1726. 		init_lev.lit = rn2(2); 1727. 	   mkmap(&init_lev); 1728. 	} 1729.  1730. 	/* Read the per level flags */ 1731. 	Fread((genericptr_t) &lev_flags, 1, sizeof(lev_flags), fd); 1732. 	if (lev_flags & NOTELEPORT) 1733. 	   level.flags.noteleport = 1; 1734. 	if (lev_flags & HARDFLOOR) 1735. 	   level.flags.hardfloor = 1; 1736. 	if (lev_flags & NOMMAP) 1737. 	   level.flags.nommap = 1; 1738. 	if (lev_flags & SHORTSIGHTED) 1739. 	   level.flags.shortsighted = 1; 1740. 	if (lev_flags & ARBOREAL) 1741. 	   level.flags.arboreal = 1; 1742. 1743. 	/* Read message */ 1744. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 1745. 	if (n) { 1746. 	   lev_message = (char *) alloc(n + 1); 1747. 	   Fread((genericptr_t) lev_message, 1, (int) n, fd); 1748. 	   lev_message[n] = 0; 1749. 	} 1750. }  1751.  1752. STATIC_OVL void 1753. load_one_monster(fd, m) 1754. dlb *fd; 1755. monster *m; 1756. { 1757. 	int size; 1758. 1759. 	Fread((genericptr_t) m, 1, sizeof *m, fd); 1760. 	if ((size = m->name.len) != 0) { 1761. 	   m->name.str = (char *) alloc((unsigned)size + 1); 1762. 	   Fread((genericptr_t) m->name.str, 1, size, fd); 1763. 	   m->name.str[size] = '\0'; 1764. 	} else 1765. 	   m->name.str = (char *) 0; 1766. 	if ((size = m->appear_as.len) != 0) { 1767. 	   m->appear_as.str = (char *) alloc((unsigned)size + 1); 1768. 	   Fread((genericptr_t) m->appear_as.str, 1, size, fd); 1769. 	   m->appear_as.str[size] = '\0'; 1770. 	} else 1771. 	   m->appear_as.str = (char *) 0; 1772. } 1773.  1774. STATIC_OVL void 1775. load_one_object(fd, o) 1776. dlb *fd; 1777. object *o; 1778. { 1779. 	int size; 1780. 1781. 	Fread((genericptr_t) o, 1, sizeof *o, fd); 1782. 	if ((size = o->name.len) != 0) { 1783. 	   o->name.str = (char *) alloc((unsigned)size + 1); 1784. 	   Fread((genericptr_t) o->name.str, 1, size, fd); 1785. 	   o->name.str[size] = '\0'; 1786. 	} else 1787. 	   o->name.str = (char *) 0; 1788. } 1789.  1790. STATIC_OVL void 1791. load_one_engraving(fd, e) 1792. dlb *fd; 1793. engraving *e; 1794. { 1795. 	int size; 1796. 1797. 	Fread((genericptr_t) e, 1, sizeof *e, fd); 1798. 	size = e->engr.len; 1799. 	e->engr.str = (char *) alloc((unsigned)size+1); 1800. 	Fread((genericptr_t) e->engr.str, 1, size, fd); 1801. 	e->engr.str[size] = '\0'; 1802. } 1803.  1804. STATIC_OVL boolean 1805. load_rooms(fd) 1806. dlb *fd; 1807. { 1808. 	xchar		nrooms, ncorr; 1809. 	char		n; 1810. 	short		size; 1811. 	corridor	tmpcor; 1812. 	room**		tmproom; 1813. 	int		i, j; 1814. 1815. 	load_common_data(fd, SP_LEV_ROOMS); 1816. 1817. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); /* nrobjects */ 1818. 	if (n) { 1819. 		Fread((genericptr_t)robjects, sizeof(*robjects), n, fd); 1820. 		sp_lev_shuffle(robjects, (char *)0, (int)n); 1821. 	} 1822.  1823. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); /* nrmonst */ 1824. 	if (n) { 1825. 		Fread((genericptr_t)rmonst, sizeof(*rmonst), n, fd); 1826. 		sp_lev_shuffle(rmonst, (char *)0, (int)n); 1827. 	} 1828.  1829. 	Fread((genericptr_t) &nrooms, 1, sizeof(nrooms), fd); 1830. 						/* Number of rooms to read */ 1831. 	tmproom = NewTab(room,nrooms); 1832. 	for (i=0;i 0) {	/* Yup, it does! */ 1840. 			r->name = (char *) alloc((unsigned)size + 1); 1841. 			Fread((genericptr_t) r->name, 1, size, fd); 1842. 			r->name[size] = 0; 1843. 		} else 1844. 		   r->name = (char *) 0; 1845. 1846. 		/* Let's see if this room has a parent */ 1847. 		Fread((genericptr_t) &size, 1, sizeof(size), fd); 1848. 		if (size > 0) {	/* Yup, it does! */ 1849. 			r->parent = (char *) alloc((unsigned)size + 1); 1850. 			Fread((genericptr_t) r->parent, 1, size, fd); 1851. 			r->parent[size] = 0; 1852. 		} else 1853. 		   r->parent = (char *) 0; 1854. 1855. 		Fread((genericptr_t) &r->x, 1, sizeof(r->x), fd); 1856. 					/* x pos on the grid (1-5) */ 1857. 		Fread((genericptr_t) &r->y, 1, sizeof(r->y), fd); 1858. 					 /* y pos on the grid (1-5) */ 1859. 		Fread((genericptr_t) &r->w, 1, sizeof(r->w), fd); 1860. 					 /* width of the room */ 1861. 		Fread((genericptr_t) &r->h, 1, sizeof(r->h), fd); 1862. 					 /* height of the room */ 1863. 		Fread((genericptr_t) &r->xalign, 1, sizeof(r->xalign), fd); 1864. 					 /* horizontal alignment */ 1865. 		Fread((genericptr_t) &r->yalign, 1, sizeof(r->yalign), fd); 1866. 					 /* vertical alignment */ 1867. 		Fread((genericptr_t) &r->rtype, 1, sizeof(r->rtype), fd); 1868. 					 /* type of room (zoo, shop, etc.) */ 1869. 		Fread((genericptr_t) &r->chance, 1, sizeof(r->chance), fd); 1870. 					 /* chance of room being special. */ 1871. 		Fread((genericptr_t) &r->rlit, 1, sizeof(r->rlit), fd); 1872. 					 /* lit or not ? */ 1873. 		Fread((genericptr_t) &r->filled, 1, sizeof(r->filled), fd); 1874. 					 /* to be filled? */ 1875. 		r->nsubroom= 0; 1876. 1877. 		/* read the doors */ 1878. 		Fread((genericptr_t) &r->ndoor, 1, sizeof(r->ndoor), fd); 1879. 		if ((n = r->ndoor) != 0) 1880. 		   r->doors = NewTab(room_door, n); 1881. 		while(n--) { 1882. 			r->doors[(int)n] = New(room_door); 1883. 			Fread((genericptr_t) r->doors[(int)n], 1, 1884. 				sizeof(room_door), fd); 1885. 		} 1886.  1887. 		/* read the stairs */ 1888. 		Fread((genericptr_t) &r->nstair, 1, sizeof(r->nstair), fd); 1889. 		if ((n = r->nstair) != 0) 1890. 		   r->stairs = NewTab(stair, n); 1891. 		while (n--) { 1892. 			r->stairs[(int)n] = New(stair); 1893. 			Fread((genericptr_t) r->stairs[(int)n], 1, 1894. 				sizeof(stair), fd); 1895. 		} 1896.  1897. 		/* read the altars */ 1898. 		Fread((genericptr_t) &r->naltar, 1, sizeof(r->naltar), fd); 1899. 		if ((n = r->naltar) != 0) 1900. 		   r->altars = NewTab(altar, n); 1901. 		while (n--) { 1902. 			r->altars[(int)n] = New(altar); 1903. 			Fread((genericptr_t) r->altars[(int)n], 1, 1904. 				sizeof(altar), fd); 1905. 		} 1906.  1907. 		/* read the fountains */ 1908. 		Fread((genericptr_t) &r->nfountain, 1, 1909. 			sizeof(r->nfountain), fd); 1910. 		if ((n = r->nfountain) != 0) 1911. 		   r->fountains = NewTab(fountain, n); 1912. 		while (n--) { 1913. 			r->fountains[(int)n] = New(fountain); 1914. 			Fread((genericptr_t) r->fountains[(int)n], 1, 1915. 				sizeof(fountain), fd); 1916. 		} 1917.  1918. 		/* read the sinks */ 1919. 		Fread((genericptr_t) &r->nsink, 1, sizeof(r->nsink), fd); 1920. 		if ((n = r->nsink) != 0) 1921. 		   r->sinks = NewTab(sink, n); 1922. 		while (n--) { 1923. 			r->sinks[(int)n] = New(sink); 1924. 			Fread((genericptr_t) r->sinks[(int)n], 1, sizeof(sink), fd); 1925. 		} 1926.  1927. 		/* read the pools */ 1928. 		Fread((genericptr_t) &r->npool, 1, sizeof(r->npool), fd); 1929. 		if ((n = r->npool) != 0) 1930. 		   r->pools = NewTab(pool,n); 1931. 		while (n--) { 1932. 			r->pools[(int)n] = New(pool); 1933. 			Fread((genericptr_t) r->pools[(int)n], 1, sizeof(pool), fd); 1934. 		} 1935.  1936. 		/* read the traps */ 1937. 		Fread((genericptr_t) &r->ntrap, 1, sizeof(r->ntrap), fd); 1938. 		if ((n = r->ntrap) != 0) 1939. 		   r->traps = NewTab(trap, n); 1940. 		while(n--) { 1941. 			r->traps[(int)n] = New(trap); 1942. 			Fread((genericptr_t) r->traps[(int)n], 1, sizeof(trap), fd); 1943. 		} 1944.  1945. 		/* read the monsters */ 1946. 		Fread((genericptr_t) &r->nmonster, 1, sizeof(r->nmonster), fd); 1947. 		if ((n = r->nmonster) != 0) { 1948. 		   r->monsters = NewTab(monster, n); 1949. 		   while(n--) { 1950. 			r->monsters[(int)n] = New(monster); 1951. 			load_one_monster(fd, r->monsters[(int)n]); 1952. 		   }  1953. 		} else 1954. 		   r->monsters = 0; 1955. 1956. 		/* read the objects, in same order as mazes */ 1957. 		Fread((genericptr_t) &r->nobject, 1, sizeof(r->nobject), fd); 1958. 		if ((n = r->nobject) != 0) { 1959. 		   r->objects = NewTab(object, n); 1960. 		   for (j = 0; j < n; ++j) { 1961. 			r->objects[j] = New(object); 1962. 			load_one_object(fd, r->objects[j]); 1963. 		   }  1964. 		} else 1965. 		   r->objects = 0; 1966. 1967. 		/* read the gold piles */ 1968. 		Fread((genericptr_t) &r->ngold, 1, sizeof(r->ngold), fd); 1969. 		if ((n = r->ngold) != 0) 1970. 		   r->golds = NewTab(gold, n); 1971. 		while (n--) { 1972. 			r->golds[(int)n] = New(gold); 1973. 			Fread((genericptr_t) r->golds[(int)n], 1, sizeof(gold), fd); 1974. 		} 1975.  1976. 		/* read the engravings */ 1977. 		Fread((genericptr_t) &r->nengraving, 1, 1978. 			sizeof(r->nengraving), fd); 1979. 		if ((n = r->nengraving) != 0) { 1980. 		   r->engravings = NewTab(engraving,n); 1981. 		   while (n--) { 1982. 			r->engravings[(int)n] = New(engraving); 1983. 			load_one_engraving(fd, r->engravings[(int)n]); 1984. 		   }  1985. 		} else 1986. 		   r->engravings = 0; 1987. 1988. 	}  1989.  1990. 	/* Now that we have loaded all the rooms, search the 1991. 	 * subrooms and create the links. 1992. 	 */ 1993.  1994. 	for (i = 0; iparent) { 1996. 		   /* Search the parent room */ 1997. 		   for(j=0; jname && !strcmp(tmproom[j]->name, 1999. 						      tmproom[i]->parent)) { 2000. 				n = tmproom[j]->nsubroom++; 2001. 				tmproom[j]->subrooms[(int)n] = tmproom[i]; 2002. 				break; 2003. 			} 2004. 	    }  2005.  2006. 	/*  2007. 	 * Create the rooms now...  2008. */ 2009.  2010. 	for (i=0; i < nrooms; i++) 2011. 	   if(!tmproom[i]->parent) 2012. 		build_room(tmproom[i], (room *) 0); 2013. 2014. 	free_rooms(tmproom, nrooms); 2015. 2016. 	/* read the corridors */ 2017. 2018. 	Fread((genericptr_t) &ncorr, sizeof(ncorr), 1, fd); 2019. 	for (i=0; i<ncorr; i++) { 2020. 		Fread((genericptr_t) &tmpcor, 1, sizeof(tmpcor), fd); 2021. 		create_corridor(&tmpcor); 2022. 	} 2023.  2024. 	return TRUE; 2025. } 2026.  2027. /*  2028.  * Select a random coordinate in the maze. 2029. *  2030.  * We want a place not 'touched' by the loader. That is, a place in 2031. * the maze outside every part of the special level. 2032. */  2033.  2034. STATIC_OVL void 2035. maze1xy(m, humidity) 2036. coord *m; 2037. int humidity; 2038. { 2039. 	register int x, y, tryct = 2000; 2040. 	/* tryct: normally it won't take more than ten or so tries due 2041. 	  to the circumstances under which we'll be called, but the 2042. 	  `humidity' screening might drastically change the chances */ 2043. 2044. 	do { 2045. 	   x = rn1(x_maze_max - 3, 3); 2046. 	   y = rn1(y_maze_max - 3, 3); 2047. 	   if (--tryct < 0) break;	/* give up */ 2048. 	} while (!(x % 2) || !(y % 2) || Map[x][y] || 2049. 		 !is_ok_location((schar)x, (schar)y, humidity)); 2050. 2051. 	m->x = (xchar)x,  m->y = (xchar)y; 2052. } 2053.  2054. /*  2055.  * The Big Thing: special maze loader 2056. *  2057.  * Could be cleaner, but it works. 2058. */  2059.  2060. STATIC_OVL boolean 2061. load_maze(fd) 2062. dlb *fd; 2063. { 2064.     xchar   x, y, typ; 2065.    boolean prefilled, room_not_needed; 2066. 2067.     char    n, numpart = 0; 2068.    xchar   nwalk = 0, nwalk_sav; 2069.    schar   filling; 2070.    char    halign, valign; 2071. 2072.     int     xi, dir, size; 2073.    coord   mm; 2074.    int     mapcount, mapcountmax, mapfact; 2075. 2076.     lev_region  tmplregion; 2077.    region  tmpregion; 2078.    door    tmpdoor; 2079.    trap    tmptrap; 2080.    monster tmpmons; 2081.    object  tmpobj; 2082.    drawbridge tmpdb; 2083.    walk    tmpwalk; 2084.    digpos  tmpdig; 2085.    lad     tmplad; 2086.    stair   tmpstair, prevstair; 2087.    altar   tmpaltar; 2088.    gold    tmpgold; 2089.    fountain tmpfountain; 2090.    engraving tmpengraving; 2091.    xchar   mustfill[(MAXNROFROOMS+1)*2]; 2092.    struct trap *badtrap; 2093.    boolean has_bounds; 2094. 2095.     (void) memset((genericptr_t)&Map[0][0], 0, sizeof Map); 2096.    load_common_data(fd, SP_LEV_MAZE); 2097. 2098.     /* Initialize map */ 2099.    Fread((genericptr_t) &filling, 1, sizeof(filling), fd); 2100.    if (!init_lev.init_present) { /* don't init if mkmap has been called */ 2101.      for(x = 2; x <= x_maze_max; x++) 2102. 	for(y = 0; y <= y_maze_max; y++) 2103. 	   if (filling == -1) { 2104. #ifndef WALLIFIED_MAZE 2105. 		   levl[x][y].typ = STONE; 2106. #else 2107. 		   levl[x][y].typ = 2108. 			(y < 2 || ((x % 2) && (y % 2))) ? STONE : HWALL; 2109. #endif 2110. 	   } else { 2111. 		   levl[x][y].typ = filling; 2112. 	   }  2113.     }  2114.  2115.     /* Start reading the file */ 2116.    Fread((genericptr_t) &numpart, 1, sizeof(numpart), fd); 2117. 						/* Number of parts */ 2118.    if (!numpart || numpart > 9) 2119. 	panic("load_maze error: numpart = %d", (int) numpart); 2120. 2121.     while (numpart--) { 2122. 	Fread((genericptr_t) &halign, 1, sizeof(halign), fd); 2123. 					/* Horizontal alignment */ 2124. 	Fread((genericptr_t) &valign, 1, sizeof(valign), fd); 2125. 					/* Vertical alignment */ 2126. 	Fread((genericptr_t) &xsize, 1, sizeof(xsize), fd); 2127. 					/* size in X */ 2128. 	Fread((genericptr_t) &ysize, 1, sizeof(ysize), fd); 2129. 					/* size in Y */ 2130. 	switch((int) halign) { 2131. 	   case LEFT:	    xstart = 3;					break; 2132. 	   case H_LEFT:    xstart = 2+((x_maze_max-2-xsize)/4);	break; 2133. 	   case CENTER:    xstart = 2+((x_maze_max-2-xsize)/2);	break; 2134. 	   case H_RIGHT:   xstart = 2+((x_maze_max-2-xsize)*3/4);	break; 2135. 	   case RIGHT:     xstart = x_maze_max-xsize-1;		break; 2136. 	} 2137. 	switch((int) valign) { 2138. 	   case TOP:	    ystart = 3;					break; 2139. 	   case CENTER:    ystart = 2+((y_maze_max-2-ysize)/2);	break; 2140. 	   case BOTTOM:    ystart = y_maze_max-ysize-1;		break; 2141. 	} 2142. 	if (!(xstart % 2)) xstart++; 2143. 	if (!(ystart % 2)) ystart++; 2144. 	if ((ystart < 0) || (ystart + ysize > ROWNO)) { 2145. 	   /* try to move the start a bit */ 2146. 	   ystart += (ystart > 0) ? -2 : 2; 2147. 	    if(ysize == ROWNO) ystart = 0; 2148. 	   if(ystart < 0 || ystart + ysize > ROWNO) 2149. 		panic("reading special level with ysize too large"); 2150. 	} 2151.  2152. 	/*  2153. 	 * If any CROSSWALLs are found, must change to ROOM after REGION's  2154. * are laid out. CROSSWALLS are used to specify "invisible" 2155. 	 * boundaries where DOOR syms look bad or aren't desirable. 2156. 	 */ 2157. 	has_bounds = FALSE; 2158. 2159. 	if(init_lev.init_present && xsize <= 1 && ysize <= 1) { 2160. 	   xstart = 1; 2161. 	   ystart = 0; 2162. 	   xsize = COLNO-1; 2163. 	   ysize = ROWNO; 2164. 	} else { 2165. 	   /* Load the map */ 2166. 	   for(y = ystart; y < ystart+ysize; y++) 2167. 		for(x = xstart; x < xstart+xsize; x++) { 2168. 		   levl[x][y].typ = Fgetc(fd); 2169. 		   levl[x][y].lit = FALSE; 2170. 		   /* clear out levl: load_common_data may set them */ 2171. 		   levl[x][y].flags = 0; 2172. 		   levl[x][y].horizontal = 0; 2173. 		   levl[x][y].roomno = 0; 2174. 		   levl[x][y].edge = 0; 2175. 		   /*  2176. 		     * Note: Even though levl[x][y].typ is type schar, 2177. 		    *	 lev_comp.y saves it as type char. Since schar != char 2178. 		    *	 all the time we must make this exception or hack 2179. 		    *	 through lev_comp.y to fix. 2180. 		    */  2181.  2182. 		    /*  2183. 		     *  Set secret doors to closed (why not trapped too?). Set 2184. 		    *  the horizontal bit. 2185. 		    */  2186. 		    if (levl[x][y].typ == SDOOR || IS_DOOR(levl[x][y].typ)) { 2187. 			if(levl[x][y].typ == SDOOR) 2188. 			   levl[x][y].doormask = D_CLOSED; 2189. 			/* 2190. 			 *  If there is a wall to the left that connects to a  2191. * (secret) door, then it is horizontal. This does 2192. 			 * not allow (secret) doors to be corners of rooms. 2193. 			 */ 2194. 			if (x != xstart && (IS_WALL(levl[x-1][y].typ) || 2195. 					   levl[x-1][y].horizontal)) 2196. 			   levl[x][y].horizontal = 1; 2197. 		   } else if(levl[x][y].typ == HWALL ||  2198. 				levl[x][y].typ == IRONBARS) 2199. 			levl[x][y].horizontal = 1; 2200. 		   else if(levl[x][y].typ == LAVAPOOL) 2201. 			levl[x][y].lit = 1; 2202. 		   else if(levl[x][y].typ == CROSSWALL) 2203. 			has_bounds = TRUE; 2204. 		   Map[x][y] = 1; 2205. 		} 2206. 	    if (init_lev.init_present && init_lev.joined) 2207. 		remove_rooms(xstart, ystart, xstart+xsize, ystart+ysize); 2208. 	} 2209.  2210. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2211. 						/* Number of level regions */ 2212. 	if(n) { 2213. 	   if(num_lregions) { 2214. 		/* realloc the lregion space to add the new ones */ 2215. 		/* don't really free it up until the whole level is done */ 2216. 		lev_region *newl = (lev_region *) alloc(sizeof(lev_region) * 2217. 						(unsigned)(n+num_lregions)); 2218. 		(void) memcpy((genericptr_t)(newl+n), (genericptr_t)lregions, 2219. 					sizeof(lev_region) * num_lregions); 2220. 		Free(lregions); 2221. 		num_lregions += n; 2222. lregions = newl; 2223. 	   } else { 2224. 		num_lregions = n; 2225. lregions = (lev_region *) 2226. 				alloc(sizeof(lev_region) * (unsigned)n); 2227. 	   }  2228. 	}  2229.  2230. 	while(n--) { 2231. 	   Fread((genericptr_t) &tmplregion, sizeof(tmplregion), 1, fd); 2232. 	   if ((size = tmplregion.rname.len) != 0) { 2233. 		tmplregion.rname.str = (char *) alloc((unsigned)size + 1); 2234. 		Fread((genericptr_t) tmplregion.rname.str, size, 1, fd); 2235. 		tmplregion.rname.str[size] = '\0'; 2236. 	   } else 2237. 		tmplregion.rname.str = (char *) 0; 2238. 	   if(!tmplregion.in_islev) { 2239. 		get_location(&tmplregion.inarea.x1, &tmplregion.inarea.y1, 2240. 								DRY|WET); 2241. 		get_location(&tmplregion.inarea.x2, &tmplregion.inarea.y2, 2242. 								DRY|WET); 2243. 	   }  2244. 	    if(!tmplregion.del_islev) { 2245. 		get_location(&tmplregion.delarea.x1, &tmplregion.delarea.y1, 2246. 								DRY|WET); 2247. 		get_location(&tmplregion.delarea.x2, &tmplregion.delarea.y2, 2248. 								DRY|WET); 2249. 	   }  2250. 	    lregions[(int)n] = tmplregion; 2251. 	} 2252.  2253. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2254. 						/* Random objects */ 2255. 	if(n) { 2256. 		Fread((genericptr_t)robjects, sizeof(*robjects), (int) n, fd); 2257. 		sp_lev_shuffle(robjects, (char *)0, (int)n); 2258. 	} 2259.  2260. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2261. 						/* Random locations */ 2262. 	if(n) { 2263. 		Fread((genericptr_t)rloc_x, sizeof(*rloc_x), (int) n, fd); 2264. 		Fread((genericptr_t)rloc_y, sizeof(*rloc_y), (int) n, fd); 2265. 		sp_lev_shuffle(rloc_x, rloc_y, (int)n); 2266. 	} 2267.  2268. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2269. 						/* Random monsters */ 2270. 	if(n) { 2271. 		Fread((genericptr_t)rmonst, sizeof(*rmonst), (int) n, fd); 2272. 		sp_lev_shuffle(rmonst, (char *)0, (int)n); 2273. 	} 2274.  2275. 	(void) memset((genericptr_t)mustfill, 0, sizeof(mustfill)); 2276. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2277. 						/* Number of subrooms */ 2278. 	while(n--) { 2279. 		register struct mkroom *troom; 2280. 2281. 		Fread((genericptr_t)&tmpregion, 1, sizeof(tmpregion), fd); 2282. 2283. 		if(tmpregion.rtype > MAXRTYPE) { 2284. 		   tmpregion.rtype -= MAXRTYPE+1; 2285. 		   prefilled = TRUE; 2286. 		} else 2287. 		   prefilled = FALSE; 2288. 2289. 		if(tmpregion.rlit < 0) 2290. 		   tmpregion.rlit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77)) 2291. 			? TRUE : FALSE; 2292. 2293. 		get_location(&tmpregion.x1, &tmpregion.y1, DRY|WET); 2294. 		get_location(&tmpregion.x2, &tmpregion.y2, DRY|WET); 2295. 2296. 		/* for an ordinary room, `prefilled' is a flag to force 2297. 		  an actual room to be created (such rooms are used to  2298. 		   control placement of migrating monster arrivals) */ 2299. 		room_not_needed = (tmpregion.rtype == OROOM && 2300. 				   !tmpregion.rirreg && !prefilled); 2301. 		if (room_not_needed || nroom >= MAXNROFROOMS) { 2302. 		   if (!room_not_needed) 2303. 			impossible("Too many rooms on new level!"); 2304. 		   light_region(&tmpregion); 2305. 		   continue; 2306. 		} 2307.  2308. 		troom = &rooms[nroom]; 2309. 2310. 		/* mark rooms that must be filled, but do it later */ 2311. 		if (tmpregion.rtype != OROOM) 2312. 		   mustfill[nroom] = (prefilled ? 2 : 1); 2313. 2314. 		if(tmpregion.rirreg) { 2315. 		   min_rx = max_rx = tmpregion.x1; 2316. 		   min_ry = max_ry = tmpregion.y1; 2317. 		   flood_fill_rm(tmpregion.x1, tmpregion.y1,  2318. 				  nroom+ROOMOFFSET, tmpregion.rlit, TRUE); 2319. 		   add_room(min_rx, min_ry, max_rx, max_ry,  2320. 			     FALSE, tmpregion.rtype, TRUE); 2321. 		   troom->rlit = tmpregion.rlit; 2322. 		   troom->irregular = TRUE; 2323. 		} else { 2324. 		   add_room(tmpregion.x1, tmpregion.y1,  2325. 			     tmpregion.x2, tmpregion.y2,  2326. 			     tmpregion.rlit, tmpregion.rtype, TRUE); 2327. #ifdef SPECIALIZATION 2328. 		   topologize(troom,FALSE);		/* set roomno */ 2329. #else 2330. 		   topologize(troom);			/* set roomno */ 2331. #endif 2332. 		} 2333. 	}  2334.  2335. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2336. 						/* Number of doors */ 2337. 	while(n--) { 2338. 		struct mkroom *croom = &rooms[0]; 2339. 2340. 		Fread((genericptr_t)&tmpdoor, 1, sizeof(tmpdoor), fd); 2341. 2342. 		x = tmpdoor.x;	y = tmpdoor.y;  2343. typ = tmpdoor.mask == -1 ? rnddoor : tmpdoor.mask; 2344. 2345. 		get_location(&x, &y, DRY); 2346. 		if(levl[x][y].typ != SDOOR) 2347. 			levl[x][y].typ = DOOR; 2348. 		else { 2349. 			if(typ < D_CLOSED) 2350. 			   typ = D_CLOSED; /* force it to be closed */ 2351. 		} 2352. 		levl[x][y].doormask = typ; 2353. 2354. 		/* Now the complicated part, list it with each subroom */ 2355. 		/* The dog move and mail daemon routines use this */ 2356. 		while(croom->hx >= 0 && doorindex < DOORMAX) { 2357. 		   if(croom->hx >= x-1 && croom->lx <= x+1 &&  2358. 		       croom->hy >= y-1 && croom->ly <= y+1) { 2359. 			/* Found it */ 2360. 			add_door(x, y, croom); 2361. 		   }  2362. 		    croom++; 2363. 		} 2364. 	}  2365.  2366. 	/* now that we have rooms _and_ associated doors, fill the rooms */ 2367. 	for(n = 0; n < SIZE(mustfill); n++) 2368. 	   if(mustfill[(int)n]) 2369. 		fill_room(&rooms[(int)n], (mustfill[(int)n] == 2)); 2370. 2371. 	/* if special boundary syms (CROSSWALL) in map, remove them now */ 2372. 	if(has_bounds) { 2373. 	   for(x = xstart; x < xstart+xsize; x++) 2374. 		for(y = ystart; y < ystart+ysize; y++) 2375. 		   if(levl[x][y].typ == CROSSWALL) 2376. 			levl[x][y].typ = ROOM; 2377. 	} 2378.  2379. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2380. 						/* Number of drawbridges */ 2381. 	while(n--) { 2382. 		Fread((genericptr_t)&tmpdb, 1, sizeof(tmpdb), fd); 2383. 2384. 		x = tmpdb.x;  y = tmpdb.y;  2385. get_location(&x, &y, DRY|WET); 2386. 2387. 		if (!create_drawbridge(x, y, tmpdb.dir, tmpdb.db_open)) 2388. 		   impossible("Cannot create drawbridge."); 2389. 	} 2390.  2391. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2392. 						/* Number of mazewalks */ 2393. 	while(n--) { 2394. 		Fread((genericptr_t)&tmpwalk, 1, sizeof(tmpwalk), fd); 2395. 2396. 		get_location(&tmpwalk.x, &tmpwalk.y, DRY|WET); 2397. 2398. 		walklist[nwalk++] = tmpwalk; 2399. 	} 2400.  2401. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2402. 						/* Number of non_diggables */ 2403. 	while(n--) { 2404. 		Fread((genericptr_t)&tmpdig, 1, sizeof(tmpdig), fd); 2405. 2406. 		get_location(&tmpdig.x1, &tmpdig.y1, DRY|WET); 2407. 		get_location(&tmpdig.x2, &tmpdig.y2, DRY|WET); 2408. 2409. 		set_wall_property(tmpdig.x1, tmpdig.y1,  2410. 				  tmpdig.x2, tmpdig.y2, W_NONDIGGABLE); 2411. 	} 2412.  2413. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2414. 						/* Number of non_passables */ 2415. 	while(n--) { 2416. 		Fread((genericptr_t)&tmpdig, 1, sizeof(tmpdig), fd); 2417. 2418. 		get_location(&tmpdig.x1, &tmpdig.y1, DRY|WET); 2419. 		get_location(&tmpdig.x2, &tmpdig.y2, DRY|WET); 2420. 2421. 		set_wall_property(tmpdig.x1, tmpdig.y1,  2422. 				  tmpdig.x2, tmpdig.y2, W_NONPASSWALL); 2423. 	} 2424.  2425. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2426. 						/* Number of ladders */ 2427. 	while(n--) { 2428. 		Fread((genericptr_t)&tmplad, 1, sizeof(tmplad), fd); 2429. 2430. 		x = tmplad.x;  y = tmplad.y;  2431. get_location(&x, &y, DRY); 2432. 2433. 		levl[x][y].typ = LADDER; 2434. 		if (tmplad.up == 1) { 2435. 			xupladder = x;	yupladder = y; 2436. levl[x][y].ladder = LA_UP; 2437. 		} else { 2438. 			xdnladder = x;	ydnladder = y; 2439. levl[x][y].ladder = LA_DOWN; 2440. 		} 2441. 	}  2442.  2443. 	prevstair.x = prevstair.y = 0; 2444. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2445. 						/* Number of stairs */ 2446. 	while(n--) { 2447. 		Fread((genericptr_t)&tmpstair, 1, sizeof(tmpstair), fd); 2448. 2449. 		xi = 0; 2450. 		do { 2451. 		   x = tmpstair.x;  y = tmpstair.y;  2452. get_location(&x, &y, DRY); 2453. 		} while(prevstair.x && xi++ < 100 && 2454. 			distmin(x,y,prevstair.x,prevstair.y) <= 8); 2455. 		if ((badtrap = t_at(x,y)) != 0) deltrap(badtrap); 2456. 		mkstairs(x, y, (char)tmpstair.up, (struct mkroom *)0); 2457. 		prevstair.x = x; 2458. prevstair.y = y; 2459. } 2460.  2461. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2462. 						/* Number of altars */ 2463. 	while(n--) { 2464. 		Fread((genericptr_t)&tmpaltar, 1, sizeof(tmpaltar), fd); 2465. 2466. 		create_altar(&tmpaltar, (struct mkroom *)0); 2467. 	} 2468.  2469. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2470. 						/* Number of fountains */ 2471. 	while (n--) { 2472. 		Fread((genericptr_t)&tmpfountain, 1, sizeof(tmpfountain), fd); 2473. 2474. 		create_feature(tmpfountain.x, tmpfountain.y,  2475. 			       (struct mkroom *)0, FOUNTAIN); 2476. 	} 2477.  2478. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2479. 						/* Number of traps */ 2480. 	while(n--) { 2481. 		Fread((genericptr_t)&tmptrap, 1, sizeof(tmptrap), fd); 2482. 2483. 		create_trap(&tmptrap, (struct mkroom *)0); 2484. 	} 2485.  2486. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2487. 						/* Number of monsters */ 2488. 	while(n--) { 2489. 		load_one_monster(fd, &tmpmons); 2490. 2491. 		create_monster(&tmpmons, (struct mkroom *)0); 2492. 	} 2493.  2494. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2495. 						/* Number of objects */ 2496. 	while(n--) { 2497. 		load_one_object(fd, &tmpobj); 2498. 2499. 		create_object(&tmpobj, (struct mkroom *)0); 2500. 	} 2501.  2502. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2503. 						/* Number of gold piles */ 2504. 	while (n--) { 2505. 		Fread((genericptr_t)&tmpgold, 1, sizeof(tmpgold), fd); 2506. 2507. 		create_gold(&tmpgold, (struct mkroom *)0); 2508. 	} 2509.  2510. 	Fread((genericptr_t) &n, 1, sizeof(n), fd); 2511. 						/* Number of engravings */ 2512. 	while(n--) { 2513. 		load_one_engraving(fd, &tmpengraving); 2514. 2515. 		create_engraving(&tmpengraving, (struct mkroom *)0); 2516. 	} 2517.  2518.     }		/* numpart loop */ 2519. 2520.     nwalk_sav = nwalk; 2521.    while(nwalk--) { 2522. 	   x = (xchar) walklist[nwalk].x;  2523. y = (xchar) walklist[nwalk].y; 2524. dir = walklist[nwalk].dir; 2525. 2526. 	    /* don't use move - it doesn't use W_NORTH, etc. */ 2527. 	   switch (dir) { 2528. 		case W_NORTH: --y; break; 2529. 		case W_SOUTH: y++; break; 2530. 		case W_EAST: x++; break; 2531. 		case W_WEST: --x; break; 2532. 		default: panic("load_maze: bad MAZEWALK direction"); 2533. 	   }  2534.  2535. 	    if(!IS_DOOR(levl[x][y].typ)) { 2536. #ifndef WALLIFIED_MAZE 2537. 		levl[x][y].typ = CORR; 2538. #else 2539. 		levl[x][y].typ = ROOM; 2540. #endif 2541. 		levl[x][y].flags = 0; 2542. 	   }  2543.  2544. 	    /*  2545. 	     * We must be sure that the parity of the coordinates for 2546. 	    * walkfrom is odd. But we must also take into account 2547. 	    * what direction was chosen. 2548. 	    */  2549. 	    if(!(x % 2)) { 2550. 		if (dir == W_EAST) 2551. 		   x++; 2552. 		else 2553. 		   x--; 2554. 2555. 		/* no need for IS_DOOR check; out of map bounds */ 2556. #ifndef WALLIFIED_MAZE 2557. 		levl[x][y].typ = CORR; 2558. #else 2559. 		levl[x][y].typ = ROOM; 2560. #endif 2561. 		levl[x][y].flags = 0; 2562. 	   }  2563.  2564. 	    if (!(y % 2)) { 2565. 		if (dir == W_SOUTH) 2566. 		   y++; 2567. 		else 2568. 		   y--; 2569. 	   }  2570.  2571. 	    walkfrom(x, y); 2572.    }  2573.     wallification(1, 0, COLNO-1, ROWNO-1); 2574. 2575.     /*  2576.      * If there's a significant portion of maze unused by the special level, 2577.     * we don't want it empty. 2578.     *  2579.      * Makes the number of traps, monsters, etc. proportional 2580.     * to the size of the maze. 2581.     */  2582.     mapcountmax = mapcount = (x_maze_max - 2) * (y_maze_max - 2); 2583. 2584.     for(x = 2; x < x_maze_max; x++) 2585. 	for(y = 0; y < y_maze_max; y++) 2586. 	   if(Map[x][y]) mapcount--; 2587. 2588.     if (nwalk_sav && (mapcount > (int) (mapcountmax / 10))) { 2589. 	   mapfact = (int) ((mapcount * 100L) / mapcountmax); 2590. 	   for(x = rnd((int) (20 * mapfact) / 100); x; x--) { 2591. 		   maze1xy(&mm, DRY); 2592. 		   (void) mkobj_at(rn2(2) ? GEM_CLASS : RANDOM_CLASS,  2593. 							mm.x, mm.y, TRUE); 2594. 	   }  2595. 	    for(x = rnd((int) (12 * mapfact) / 100); x; x--) { 2596. 		   maze1xy(&mm, DRY); 2597. 		   (void) mksobj_at(BOULDER, mm.x, mm.y, TRUE, FALSE); 2598. 	   }  2599. 	    for (x = rn2(2); x; x--) { 2600. 		maze1xy(&mm, DRY); 2601. 		(void) makemon(&mons[PM_MINOTAUR], mm.x, mm.y, NO_MM_FLAGS); 2602. 	   }  2603. 	    for(x = rnd((int) (12 * mapfact) / 100); x; x--) { 2604. 		   maze1xy(&mm, WET|DRY); 2605. 		   (void) makemon((struct permonst *) 0, mm.x, mm.y, NO_MM_FLAGS); 2606. 	   }  2607. 	    for(x = rn2((int) (15 * mapfact) / 100); x; x--) { 2608. 		   maze1xy(&mm, DRY); 2609. 		   (void) mkgold(0L,mm.x,mm.y); 2610. 	   }  2611. 	    for(x = rn2((int) (15 * mapfact) / 100); x; x--) { 2612. 		   int trytrap; 2613. 2614. 		    maze1xy(&mm, DRY); 2615. 		   trytrap = rndtrap; 2616. 		   if (sobj_at(BOULDER, mm.x, mm.y)) 2617. 			while (trytrap == PIT || trytrap == SPIKED_PIT || 2618. 				trytrap == TRAPDOOR || trytrap == HOLE) 2619. 			   trytrap = rndtrap; 2620. 		   (void) maketrap(mm.x, mm.y, trytrap); 2621. 	   }  2622.     }  2623.     return TRUE; 2624. } 2625.  2626. /*  2627.  * General loader 2628. */  2629.  2630. boolean 2631. load_special(name) 2632. const char *name; 2633. { 2634. 	dlb *fd; 2635. 	boolean result = FALSE; 2636. 	char c; 2637. struct version_info vers_info; 2638. 2639. 	fd = dlb_fopen(name, RDBMODE); 2640. 	if (!fd) return FALSE; 2641. 2642. 	Fread((genericptr_t) &vers_info, sizeof vers_info, 1, fd); 2643. 	if (!check_version(&vers_info, name, TRUE)) 2644. 	   goto give_up; 2645. 2646. 	Fread((genericptr_t) &c, sizeof c, 1, fd); /* c Header */ 2647. 2648. 	switch (c) { 2649. 		case SP_LEV_ROOMS: 2650. 		   result = load_rooms(fd); 2651. 		   break; 2652. 		case SP_LEV_MAZE: 2653. 		   result = load_maze(fd); 2654. 		   break; 2655. 		default:	/* ??? */ 2656. 		    result = FALSE; 2657. 	} 2658.  give_up: 2659. 	(void)dlb_fclose(fd); 2660. 	return result; 2661. } 2662.  2663. /*sp_lev.c*/