Source:NetHack 3.1.0/mkmap.c

Below is the full text to mkmap.c from the source code of NetHack 3.1.0. To link to a particular line, write [[NetHack 3.1.0/mkmap.c#line123 ]], for example.

Warning! This is the source code from an old release. For the latest release, see Source code

1.   /*	SCCS Id: @(#)mkmap.c	3.1	92/07/15	*/ 2.   /* Copyright (c) J. C. Collet, M. Stephenson and D. Cohrs, 1992   */ 3.   /* NetHack may be freely redistributed. See license for details. */ 4.     5.    #include "hack.h"  6.    #include "sp_lev.h"  7. 8.   #define	HEIGHT	(ROWNO - 1) 9.   #define WIDTH	(COLNO - 2) 10.   11.   static void FDECL(init_map,(SCHAR_P)); 12.  static void FDECL(init_fill,(SCHAR_P,SCHAR_P)); 13.  static schar FDECL(get_map,(int,int,SCHAR_P)); 14.  static void FDECL(pass_one,(SCHAR_P,SCHAR_P)); 15.  static void FDECL(pass_two,(SCHAR_P,SCHAR_P)); 16.  static void FDECL(pass_three,(SCHAR_P,SCHAR_P)); 17.  static void NDECL(wallify_map); 18.  static void FDECL(join_map,(SCHAR_P,SCHAR_P)); 19.  static void FDECL(finish_map,(SCHAR_P,SCHAR_P,XCHAR_P,XCHAR_P)); 20.  void FDECL(mkmap, (lev_init *)); 21.   22.   char *new_locations; 23.  int min_rx, max_rx, min_ry, max_ry; /* rectangle bounds for regions */ 24.  static int n_loc_filled; 25.   26.   static void 27.  init_map(bg_typ) 28.  	schar	bg_typ; 29.  {  30.   	register int i,j; 31.   32.   	for(i=1; i<COLNO; i++) 33.  	    for(j=0; j<ROWNO; j++) 34.  		levl[i][j].typ = bg_typ; 35.  }  36.    37.   static void 38.  init_fill(bg_typ, fg_typ) 39.  	schar	bg_typ, fg_typ; 40.  {  41.   	register int i,j; 42.  	long limit, count; 43.   44.   	limit = (WIDTH * HEIGHT * 2) / 5; 45.  	count = 0; 46.  	while(count < limit) { 47.  	    i = rn1(WIDTH-1, 2); 48.  	    j = rnd(HEIGHT-1); 49.  	    if (levl[i][j].typ == bg_typ) { 50.  		levl[i][j].typ = fg_typ; 51.  		count++; 52.  	    }  53.   	}  54.   }  55.    56.   static schar 57.  get_map(col,row, bg_typ) 58.  	int col,row; 59.  	schar	bg_typ; 60.  {  61.   	if (col <= 0 || row < 0 || col > WIDTH || row >= HEIGHT) 62.  		return bg_typ; 63.  	return levl[col][row].typ; 64.  }  65.    66.   static int dirs[16] = { 67.      -1, -1 /**/, -1, 0 /**/, -1, 1 /**/,  68.        0, -1 /**/,              0, 1 /**/,  69.        1, -1 /**/,  1, 0 /**/,  1, 1};  70.    71.   static void 72.  pass_one(bg_typ, fg_typ) 73.  	schar	bg_typ, fg_typ; 74.  {  75.   	register int i,j; 76.  	short count, dr; 77.   78.   	for(i=2; i<=WIDTH; i++) 79.  	    for(j=1; j<HEIGHT; j++) { 80.  		for(count=0, dr=0; dr < 8; dr++) 81.  		    if(get_map(i+dirs[dr*2], j+dirs[(dr*2)+1], bg_typ)  82.   								== fg_typ) 83.  			count++; 84.   85.   		switch(count) { 86.  		  case 0 : /* death */ 87.  		  case 1 : 88.  		  case 2: 89.  			  levl[i][j].typ = bg_typ; 90.  			  break; 91.  		  case 5: 92.  		  case 6: 93.  		  case 7: 94.  		  case 8: 95.  			  levl[i][j].typ = fg_typ; 96.  			  break; 97.  		  default: 98.  			  break; 99.  		  }  100.  	    }  101.  }  102.   103.  #define new_loc(i,j)	*(new_locations+ ((j)*(WIDTH+1)) + (i)) 104.  105.  static void 106. pass_two(bg_typ, fg_typ) 107. 	schar	bg_typ, fg_typ; 108. {  109.  	register int i,j; 110. 	short count, dr; 111.  112.  	for(i=2; i<=WIDTH; i++) 113. 	    for(j=1; j<HEIGHT; j++) { 114. 		for(count=0, dr=0; dr < 8; dr++) 115. 		    if(get_map(i+dirs[dr*2], j+dirs[(dr*2)+1], bg_typ)  116.  								== fg_typ) 117. 			count++; 118. 		    if (count == 5) 119. 			new_loc(i,j) = bg_typ; 120. 		    else 121. 			new_loc(i,j) = get_map(i,j, bg_typ); 122. 	    }  123.   124.  	for(i=2; i<=WIDTH; i++) 125. 	    for(j=1; j<HEIGHT; j++) 126. 		levl[i][j].typ = new_loc(i,j); 127. }  128.   129.  static void 130. pass_three(bg_typ, fg_typ) 131. 	schar	bg_typ, fg_typ; 132. {  133.  	register int i,j; 134. 	short count, dr; 135.  136.  	for(i=2; i<=WIDTH; i++) 137. 	    for(j=1; j<HEIGHT; j++) { 138. 		for(count=0, dr=0; dr < 8; dr++) 139. 		    if(get_map(i+dirs[dr*2], j+dirs[(dr*2)+1], bg_typ)  140.  								== fg_typ) 141. 			count++; 142. 		if (count < 3) 143. 		    new_loc(i,j) = bg_typ; 144. 		else 145. 		    new_loc(i,j) = get_map(i,j, bg_typ); 146. 	    }  147.   148.  	for(i=2; i<=WIDTH; i++) 149. 	    for(j=1; j<HEIGHT; j++) 150. 		levl[i][j].typ = new_loc(i,j); 151. }  152.   153.  /*  154.   * use a flooding algorithm to find all locations that should 155.  * have the same rm number as the current location. 156.  * if anyroom is TRUE, use IS_ROOM to check room membership instead of  157. * exactly matching levl[sx][sy].typ and walls are included as well. 158.  */  159.  void 160. flood_fill_rm(sx, sy, rmno, lit, anyroom) 161.     int sx; 162.     register int sy; 163.     register int rmno; 164.     boolean lit; 165.     boolean anyroom; 166. {  167.      register int i;  168. int nx; 169.     schar fg_typ = levl[sx][sy].typ; 170.  171.      /* back up to find leftmost uninitialized location */ 172.     while(sx > 0  173.  	  && (anyroom ? IS_ROOM(levl[sx][sy].typ) : levl[sx][sy].typ == fg_typ) 174.  	  && levl[sx][sy].roomno != rmno) 175. 	sx--; 176.     sx++; /* compensate for extra decrement */ 177.  178.      /* assume sx,sy is valid */ 179.     if(sx < min_rx) min_rx = sx; 180.     if(sy < min_ry) min_ry = sy; 181.  182.      for(i=sx; i<=WIDTH && levl[i][sy].typ == fg_typ; i++) { 183. 	levl[i][sy].roomno = rmno; 184. 	levl[i][sy].lit = lit; 185. 	if(anyroom) { 186. 	    /* add walls to room as well */ 187. 	    register int ii,jj; 188. 	    for(ii= (i == sx ? i-1 : i); ii <= i+1; ii++) 189. 		for(jj = sy-1; jj <= sy+1; jj++) 190. 		    if(isok(ii,jj) &&  191.  		       (IS_WALL(levl[ii][jj].typ) || 192. 			IS_DOOR(levl[ii][jj].typ))) { 193. 			levl[ii][jj].edge = 1; 194. 			if(lit) levl[ii][jj].lit = lit; 195. 			if (levl[ii][jj].roomno != rmno) 196. 			    levl[ii][jj].roomno = SHARED; 197. 			else 198. 			    levl[ii][jj].roomno = rmno; 199. 		    }  200.  	}  201.  	n_loc_filled++; 202.     }  203.      nx = i;  204. 205.     if(isok(sx,sy-1)) 206. 	for(i=sx; isx || isok(i-1,sy-1)) &&  212.  		      levl[i-1][sy-1].typ == fg_typ) { 213. 		    if(levl[i-1][sy-1].roomno != rmno) 214. 			flood_fill_rm(i-1,sy-1,rmno,lit,anyroom); 215. 		}  216.  		if((isx || isok(i-1,sy+1)) &&  229.  		      levl[i-1][sy+1].typ == fg_typ) { 230. 		    if(levl[i-1][sy+1].roomno != rmno) 231. 			flood_fill_rm(i-1,sy+1,rmno,lit,anyroom); 232. 		}  233.  		if((i max_rx) max_rx = nx - 1; /* nx is just past valid region */ 241.     if(sy > max_ry) max_ry = sy; 242. }  243.   244.  /*  245.   *	If we have drawn a map without walls, this allows us to  246. *	auto-magically wallify it. Taken from lev_main.c. 247. */ 248.  static void 249. wallify_map 250. {  251.   252.      int x, y, xx, yy; 253.  254.      for(x = 1; x < COLNO; x++) 255. 	for(y = 0; y < ROWNO; y++) 256. 	    if(levl[x][y].typ == STONE) { 257. 		for(yy = y - 1; yy <= y+1; yy++) 258. 		    for(xx = x - 1; xx <= x+1; xx++) 259. 			if(isok(xx,yy) && levl[xx][yy].typ == ROOM) { 260. 			    if(yy != y)	levl[x][y].typ = HWALL; 261. 			    else	levl[x][y].typ = VWALL; 262. 			}  263.  	    }  264.  }  265.   266.  static void 267. join_map(bg_typ, fg_typ) 268. 	schar	bg_typ, fg_typ; 269. {  270.      register struct mkroom *croom, *croom2; 271.  272.      register int i, j;  273. int sx, sy; 274.     coord sm, em; 275.  276.      /* first, use flood filling to find all of the regions that need joining */ 277.     for(i=2; i<=WIDTH; i++) 278. 	for(j=1; j 3) { 285. 		    add_room(min_rx, min_ry, max_rx, max_ry,  286.  			     FALSE, OROOM, TRUE); 287. 		    rooms[nroom-1].irregular = TRUE; 288. 		    if(nroom >= (MAXNROFROOMS*2)) 289. 			goto joinm; 290. 		} else { 291. 		    /*  292.  		     * it's a tiny hole; erase it from the map to avoid 293. 		     * having the player end up here with no way out. 294. 		     */  295.  		    for(sx = min_rx; sx<=max_rx; sx++) 296. 			for(sy = min_ry; sy<=max_ry; sy++) 297. 			    if(levl[sx][sy].roomno == nroom+ROOMOFFSET) { 298. 				levl[sx][sy].typ = bg_typ; 299. 				levl[sx][sy].roomno = NO_ROOM; 300. 			    }  301.  		}  302.  	    }  303.  	}  304.   305.  joinm: 306.     /*  307.       * Ok, now we can actually join the regions with fg_typ's.  308. * The rooms are already sorted due to the previous loop, 309.      * so don't call sort_rooms, which can screw up the roomno's  310. * validity in the levl structure. 311.      */  312.      for(croom = &rooms[0], croom2 = croom + 1; croom2 < &rooms[nroom]; ) { 313. 	/* pick random starting and end locations for "corridor" */ 314. 	if(!somexy(croom, &sm) || !somexy(croom2, &em)) { 315. 	    /* ack! -- the level is going to be busted */ 316. 	    /* arbitrarily pick centers of both rooms and hope for the best */ 317. 	    impossible("No start/end room loc in join_map."); 318. 	    sm.x = croom->lx + ((croom->hx - croom->lx) / 2); 319. 	    sm.y = croom->ly + ((croom->hy - croom->ly) / 2); 320. 	    em.x = croom2->lx + ((croom2->hx - croom2->lx) / 2); 321. 	    em.y = croom2->ly + ((croom2->hy - croom2->ly) / 2); 322. 	}  323.   324.  	(void) dig_corridor(sm, em, FALSE, fg_typ, bg_typ); 325.  326.  	/* choose next region to join */ 327. 	/* only increment croom if croom and croom2 are non-overlapping */ 328. 	if(croom2->lx > croom->hx ||  329.  	   ((croom2->ly > croom->hy || croom2->hy < croom->ly) && rn2(3))) { 330. 	    croom = croom2; 331. 	}  332.  	croom2++; /* always increment the next room */ 333.     }  334.  }  335.   336.  static void 337. finish_map(fg_typ, bg_typ, lit, walled) 338.         schar	fg_typ, bg_typ; 339.         boolean	lit, walled; 340. {  341.  	int	i, j;  342. 343. 	if(walled) wallify_map; 344.  345.  	if(lit) { 346. 	    for(i=1; i<COLNO; i++) 347. 		for(j=0; j<ROWNO; j++) 348. 		    if((!IS_ROCK(fg_typ) && levl[i][j].typ == fg_typ) ||  349.  		       (!IS_ROCK(bg_typ) && levl[i][j].typ == bg_typ) ||  350.  			(walled && IS_WALL(levl[i][j].typ))) 351. 			levl[i][j].lit = TRUE; 352. 	    for(i = 0; i < nroom; i++) 353. 		rooms[i].rlit = 1; 354. 	}  355.  }  356.   357.  #define	N_P1_ITER	1	/* tune map generation via this value */ 358. #define	N_P2_ITER	1	/* tune map generation via this value */ 359. #define	N_P3_ITER	2	/* tune map smoothing via this value */ 360.  361.  void 362. mkmap(init_lev) 363.  364.  	lev_init	*init_lev; 365. {  366.  	schar	bg_typ = init_lev->bg, 367. 		fg_typ = init_lev->fg; 368. 	boolean smooth = init_lev->smoothed, 369.                 join = init_lev->joined; 370.         xchar   lit = init_lev->lit, 371.                 walled = init_lev->walled; 372. 	int i;  373. 374. 	if(lit < 0) 375. 	    lit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77)) ? 1 : 0; 376.   377.  	new_locations = (char *)alloc((WIDTH+1) * HEIGHT); 378.  379.  	init_map(bg_typ); 380. 	init_fill(bg_typ, fg_typ); 381.  382.  	for(i = 0; i < N_P1_ITER; i++) 383. 	    pass_one(bg_typ, fg_typ); 384.  385.  	for(i = 0; i < N_P2_ITER; i++) 386. 	pass_two(bg_typ, fg_typ); 387.  388.  	if(smooth) 389. 	    for(i = 0; i < N_P3_ITER; i++) 390. 		pass_three(bg_typ, fg_typ); 391.  392.  	if(join) 393. 	    join_map(bg_typ, fg_typ); 394.  395.  	finish_map(fg_typ, bg_typ, (boolean)lit, (boolean)walled); 396. 	/* a walled, joined level is cavernous, not mazelike -dlc */ 397. 	if (walled && join) { 398. 	    level.flags.is_maze_lev = FALSE; 399. 	    level.flags.is_cavernous_lev = TRUE; 400. 	}  401.  	free(new_locations); 402. }