Fandom

Wikihack

Source:NetHack 3.1.0/mklev.c

2,034pages on
this wiki
Add New Page
Talk0

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.

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

Also on Fandom

Random Wiki