[unix-history] / usr / othersrc / games / hack / hack.mklev.c

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
/* hack.mklev.c - version 1.0.3 */

#include "hack.h"

extern char *getlogin(), *getenv();
extern struct monst *makemon();
extern struct obj *mkobj_at();
extern struct trap *maketrap();

#define somex() ((random()%(croom->hx-croom->lx+1))+croom->lx)
#define somey() ((random()%(croom->hy-croom->ly+1))+croom->ly)

#include "def.mkroom.h"
#define	XLIM	4	/* define minimum required space around a room */
#define	YLIM	3
boolean secret;		/* TRUE while making a vault: increase [XY]LIM */
struct mkroom rooms[MAXNROFROOMS+1];
int smeq[MAXNROFROOMS+1];
coord doors[DOORMAX];
int doorindex;
struct rm zerorm;
int comp();
schar nxcor;
boolean goldseen;
int nroom;
xchar xdnstair,xupstair,ydnstair,yupstair;

/* Definitions used by makerooms() and addrs() */
#define	MAXRS	50	/* max lth of temp rectangle table - arbitrary */
struct rectangle {
	xchar rlx,rly,rhx,rhy;
} rs[MAXRS+1];
int rscnt,rsmax;	/* 0..rscnt-1: currently under consideration */
			/* rscnt..rsmax: discarded */

makelevel()
{
	register struct mkroom *croom, *troom;
	register unsigned tryct;
	register x,y;

	nroom = 0;
	doorindex = 0;
	rooms[0].hx = -1;	/* in case we are in a maze */

	for(x=0; x<COLNO; x++) for(y=0; y<ROWNO; y++)
		levl[x][y] = zerorm;

	oinit();	/* assign level dependent obj probabilities */

	if(dlevel >= rn1(3, 26)) {	/* there might be several mazes */
		makemaz();
		return;
	}

	/* construct the rooms */
	nroom = 0;
	secret = FALSE;
	(void) makerooms();

	/* construct stairs (up and down in different rooms if possible) */
	croom = &rooms[rn2(nroom)];
	xdnstair = somex();
	ydnstair = somey();
	levl[xdnstair][ydnstair].scrsym ='>';
	levl[xdnstair][ydnstair].typ = STAIRS;
	if(nroom > 1) {
		troom = croom;
		croom = &rooms[rn2(nroom-1)];
		if(croom >= troom) croom++;
	}
	xupstair = somex();	/* %% < and > might be in the same place */
	yupstair = somey();
	levl[xupstair][yupstair].scrsym ='<';
	levl[xupstair][yupstair].typ = STAIRS;

	/* for each room: put things inside */
	for(croom = rooms; croom->hx > 0; croom++) {

		/* put a sleeping monster inside */
		/* Note: monster may be on the stairs. This cannot be
		   avoided: maybe the player fell through a trapdoor
		   while a monster was on the stairs. Conclusion:
		   we have to check for monsters on the stairs anyway. */
		if(!rn2(3)) (void)
			makemon((struct permonst *) 0, somex(), somey());

		/* put traps and mimics inside */
		goldseen = FALSE;
		while(!rn2(8-(dlevel/6))) mktrap(0,0,croom);
		if(!goldseen && !rn2(3)) mkgold(0L,somex(),somey());
		if(!rn2(3)) {
			(void) mkobj_at(0, somex(), somey());
			tryct = 0;
			while(!rn2(5)) {
				if(++tryct > 100){
					printf("tryct overflow4\n");
					break;
				}
				(void) mkobj_at(0, somex(), somey());
			}
		}
	}

	qsort((char *) rooms, nroom, sizeof(struct mkroom), comp);
	makecorridors();
	make_niches();

	/* make a secret treasure vault, not connected to the rest */
	if(nroom <= (2*MAXNROFROOMS/3)) if(rn2(3)) {
		troom = &rooms[nroom];
		secret = TRUE;
		if(makerooms()) {
			troom->rtype = VAULT;		/* treasure vault */
			for(x = troom->lx; x <= troom->hx; x++)
			for(y = troom->ly; y <= troom->hy; y++)
				mkgold((long)(rnd(dlevel*100) + 50), x, y);
			if(!rn2(3))
				makevtele();
		}
	}

#ifndef QUEST
#ifdef WIZARD
	if(wizard && getenv("SHOPTYPE")) mkshop(); else
#endif WIZARD
 	if(dlevel > 1 && dlevel < 20 && rn2(dlevel) < 3) mkshop();
	else
	if(dlevel > 6 && !rn2(7)) mkzoo(ZOO);
	else
	if(dlevel > 9 && !rn2(5)) mkzoo(BEEHIVE);
	else
	if(dlevel > 11 && !rn2(6)) mkzoo(MORGUE);
	else
	if(dlevel > 18 && !rn2(6)) mkswamp();
#endif QUEST
}

makerooms() {
register struct rectangle *rsp;
register int lx, ly, hx, hy, lowx, lowy, hix, hiy, dx, dy;
int tryct = 0, xlim, ylim;

	/* init */
	xlim = XLIM + secret;
	ylim = YLIM + secret;
	if(nroom == 0) {
		rsp = rs;
		rsp->rlx = rsp->rly = 0;
		rsp->rhx = COLNO-1;
		rsp->rhy = ROWNO-1;
		rsmax = 1;
	}
	rscnt = rsmax;

	/* make rooms until satisfied */
	while(rscnt > 0 && nroom < MAXNROFROOMS-1) {
		if(!secret && nroom > (MAXNROFROOMS/3) &&
		   !rn2((MAXNROFROOMS-nroom)*(MAXNROFROOMS-nroom)))
			return(0);

		/* pick a rectangle */
		rsp = &rs[rn2(rscnt)];
		hx = rsp->rhx;
		hy = rsp->rhy;
		lx = rsp->rlx;
		ly = rsp->rly;

		/* find size of room */
		if(secret)
			dx = dy = 1;
		else {
			dx = 2 + rn2((hx-lx-8 > 20) ? 12 : 8);
			dy = 2 + rn2(4);
			if(dx*dy > 50)
				dy = 50/dx;
		}

		/* look whether our room will fit */
		if(hx-lx < dx + dx/2 + 2*xlim || hy-ly < dy + dy/3 + 2*ylim) {
					/* no, too small */
					/* maybe we throw this area out */
			if(secret || !rn2(MAXNROFROOMS+1-nroom-tryct)) {
				rscnt--;
				rs[rsmax] = *rsp;
				*rsp = rs[rscnt];
				rs[rscnt] = rs[rsmax];
				tryct = 0;
			} else
				tryct++;
			continue;
		}

		lowx = lx + xlim + rn2(hx - lx - dx - 2*xlim + 1);
		lowy = ly + ylim + rn2(hy - ly - dy - 2*ylim + 1);
		hix = lowx + dx;
		hiy = lowy + dy;

		if(maker(lowx, dx, lowy, dy)) {
			if(secret)
				return(1);
			addrs(lowx-1, lowy-1, hix+1, hiy+1);
			tryct = 0;
		} else
			if(tryct++ > 100)
				break;
	}
	return(0);	/* failed to make vault - very strange */
}

addrs(lowx,lowy,hix,hiy)
register int lowx,lowy,hix,hiy;
{
	register struct rectangle *rsp;
	register int lx,ly,hx,hy,xlim,ylim;
	boolean discarded;

	xlim = XLIM + secret;
	ylim = YLIM + secret;

	/* walk down since rscnt and rsmax change */
	for(rsp = &rs[rsmax-1]; rsp >= rs; rsp--) {
		
		if((lx = rsp->rlx) > hix || (ly = rsp->rly) > hiy ||
		   (hx = rsp->rhx) < lowx || (hy = rsp->rhy) < lowy)
			continue;
		if((discarded = (rsp >= &rs[rscnt]))) {
			*rsp = rs[--rsmax];
		} else {
			rsmax--;
			rscnt--;
			*rsp = rs[rscnt];
			if(rscnt != rsmax)
				rs[rscnt] = rs[rsmax];
		}
		if(lowy - ly > 2*ylim + 4)
			addrsx(lx,ly,hx,lowy-2,discarded);
		if(lowx - lx > 2*xlim + 4)
			addrsx(lx,ly,lowx-2,hy,discarded);
		if(hy - hiy > 2*ylim + 4)
			addrsx(lx,hiy+2,hx,hy,discarded);
		if(hx - hix > 2*xlim + 4)
			addrsx(hix+2,ly,hx,hy,discarded);
	}
}

addrsx(lx,ly,hx,hy,discarded)
register int lx,ly,hx,hy;
boolean discarded;		/* piece of a discarded area */
{
	register struct rectangle *rsp;

	/* check inclusions */
	for(rsp = rs; rsp < &rs[rsmax]; rsp++) {
		if(lx >= rsp->rlx && hx <= rsp->rhx &&
		   ly >= rsp->rly && hy <= rsp->rhy)
			return;
	}

	/* make a new entry */
	if(rsmax >= MAXRS) {
#ifdef WIZARD
		if(wizard) pline("MAXRS may be too small.");
#endif WIZARD
		return;
	}
	rsmax++;
	if(!discarded) {
		*rsp = rs[rscnt];
		rsp = &rs[rscnt];
		rscnt++;
	}
	rsp->rlx = lx;
	rsp->rly = ly;
	rsp->rhx = hx;
	rsp->rhy = hy;
}

comp(x,y)
register struct mkroom *x,*y;
{
	if(x->lx < y->lx) return(-1);
	return(x->lx > y->lx);
}

coord
finddpos(xl,yl,xh,yh) {
	coord ff;
	register x,y;

	x = (xl == xh) ? xl : (xl + rn2(xh-xl+1));
	y = (yl == yh) ? yl : (yl + rn2(yh-yl+1));
	if(okdoor(x, y))
		goto gotit;

	for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
		if(okdoor(x, y))
			goto gotit;

	for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
		if(levl[x][y].typ == DOOR || levl[x][y].typ == SDOOR)
			goto gotit;
	/* cannot find something reasonable -- strange */
	x = xl;
	y = yh;
gotit:
	ff.x = x;
	ff.y = y;
	return(ff);
}

/* see whether it is allowable to create a door at [x,y] */
okdoor(x,y)
register x,y;
{
	if(levl[x-1][y].typ == DOOR || levl[x+1][y].typ == DOOR ||
	   levl[x][y+1].typ == DOOR || levl[x][y-1].typ == DOOR ||
	   levl[x-1][y].typ == SDOOR || levl[x+1][y].typ == SDOOR ||
	   levl[x][y-1].typ == SDOOR || levl[x][y+1].typ == SDOOR ||
	   (levl[x][y].typ != HWALL && levl[x][y].typ != VWALL) ||
	   doorindex >= DOORMAX)
		return(0);
	return(1);
}

dodoor(x,y,aroom)
register x,y;
register struct mkroom *aroom;
{
	if(doorindex >= DOORMAX) {
		impossible("DOORMAX exceeded?");
		return;
	}
	if(!okdoor(x,y) && nxcor)
		return;
	dosdoor(x,y,aroom,rn2(8) ? DOOR : SDOOR);
}

dosdoor(x,y,aroom,type)
register x,y;
register struct mkroom *aroom;
register type;
{
	register struct mkroom *broom;
	register tmp;

	if(!IS_WALL(levl[x][y].typ))	/* avoid SDOORs with '+' as scrsym */
		type = DOOR;
	levl[x][y].typ = type;
	if(type == DOOR)
		levl[x][y].scrsym = '+';
	aroom->doorct++;
	broom = aroom+1;
	if(broom->hx < 0) tmp = doorindex; else
	for(tmp = doorindex; tmp > broom->fdoor; tmp--)
		doors[tmp] = doors[tmp-1];
	doorindex++;
	doors[tmp].x = x;
	doors[tmp].y = y;
	for( ; broom->hx >= 0; broom++) broom->fdoor++;
}

/* Only called from makerooms() */
maker(lowx,ddx,lowy,ddy)
schar lowx,ddx,lowy,ddy;
{
	register struct mkroom *croom;
	register x, y, hix = lowx+ddx, hiy = lowy+ddy;
	register xlim = XLIM + secret, ylim = YLIM + secret;

	if(nroom >= MAXNROFROOMS) return(0);
	if(lowx < XLIM) lowx = XLIM;
	if(lowy < YLIM) lowy = YLIM;
	if(hix > COLNO-XLIM-1) hix = COLNO-XLIM-1;
	if(hiy > ROWNO-YLIM-1) hiy = ROWNO-YLIM-1;
chk:
	if(hix <= lowx || hiy <= lowy) return(0);

	/* check area around room (and make room smaller if necessary) */
	for(x = lowx - xlim; x <= hix + xlim; x++) {
		for(y = lowy - ylim; y <= hiy + ylim; y++) {
			if(levl[x][y].typ) {
#ifdef WIZARD
			    if(wizard && !secret)
				pline("Strange area [%d,%d] in maker().",x,y);
#endif WIZARD
				if(!rn2(3)) return(0);
				if(x < lowx)
					lowx = x+xlim+1;
				else
					hix = x-xlim-1;
				if(y < lowy)
					lowy = y+ylim+1;
				else
					hiy = y-ylim-1;
				goto chk;
			}
		}
	}

	croom = &rooms[nroom];

	/* on low levels the room is lit (usually) */
	/* secret vaults are always lit */
	if((rnd(dlevel) < 10 && rn2(77)) || (ddx == 1 && ddy == 1)) {
		for(x = lowx-1; x <= hix+1; x++)
			for(y = lowy-1; y <= hiy+1; y++)
				levl[x][y].lit = 1;
		croom->rlit = 1;
	} else
		croom->rlit = 0;
	croom->lx = lowx;
	croom->hx = hix;
	croom->ly = lowy;
	croom->hy = hiy;
	croom->rtype = croom->doorct = croom->fdoor = 0;

	for(x = lowx-1; x <= hix+1; x++)
	    for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) {
		levl[x][y].scrsym = '-';
		levl[x][y].typ = HWALL;
	}
	for(x = lowx-1; x <= hix+1; x += (hix-lowx+2))
	    for(y = lowy; y <= hiy; y++) {
		levl[x][y].scrsym = '|';
		levl[x][y].typ = VWALL;
	}
	for(x = lowx; x <= hix; x++)
	    for(y = lowy; y <= hiy; y++) {
		levl[x][y].scrsym = '.';
		levl[x][y].typ = ROOM;
	}

	smeq[nroom] = nroom;
	croom++;
	croom->hx = -1;
	nroom++;
	return(1);
}

makecorridors() {
	register a,b;

	nxcor = 0;
	for(a = 0; a < nroom-1; a++)
		join(a, a+1);
	for(a = 0; a < nroom-2; a++)
	    if(smeq[a] != smeq[a+2])
		join(a, a+2);
	for(a = 0; a < nroom; a++)
	    for(b = 0; b < nroom; b++)
		if(smeq[a] != smeq[b])
		    join(a, b);
	if(nroom > 2)
	    for(nxcor = rn2(nroom) + 4; nxcor; nxcor--) {
		a = rn2(nroom);
		b = rn2(nroom-2);
		if(b >= a) b += 2;
		join(a, b);
	    }
}

join(a,b)
register a,b;
{
	coord cc,tt;
	register tx, ty, xx, yy;
	register struct rm *crm;
	register struct mkroom *croom, *troom;
	register dx, dy, dix, diy, cct;

	croom = &rooms[a];
	troom = &rooms[b];

	/* find positions cc and tt for doors in croom and troom
	   and direction for a corridor between them */

	if(troom->hx < 0 || croom->hx < 0 || doorindex >= DOORMAX) return;
	if(troom->lx > croom->hx) {
		dx = 1;
		dy = 0;
		xx = croom->hx+1;
		tx = troom->lx-1;
		cc = finddpos(xx,croom->ly,xx,croom->hy);
		tt = finddpos(tx,troom->ly,tx,troom->hy);
	} else if(troom->hy < croom->ly) {
		dy = -1;
		dx = 0;
		yy = croom->ly-1;
		cc = finddpos(croom->lx,yy,croom->hx,yy);
		ty = troom->hy+1;
		tt = finddpos(troom->lx,ty,troom->hx,ty);
	} else if(troom->hx < croom->lx) {
		dx = -1;
		dy = 0;
		xx = croom->lx-1;
		tx = troom->hx+1;
		cc = finddpos(xx,croom->ly,xx,croom->hy);
		tt = finddpos(tx,troom->ly,tx,troom->hy);
	} else {
		dy = 1;
		dx = 0;
		yy = croom->hy+1;
		ty = troom->ly-1;
		cc = finddpos(croom->lx,yy,croom->hx,yy);
		tt = finddpos(troom->lx,ty,troom->hx,ty);
	}
	xx = cc.x;
	yy = cc.y;
	tx = tt.x - dx;
	ty = tt.y - dy;
	if(nxcor && levl[xx+dx][yy+dy].typ)
		return;
	dodoor(xx,yy,croom);

	cct = 0;
	while(xx != tx || yy != ty) {
	    xx += dx;
	    yy += dy;

	    /* loop: dig corridor at [xx,yy] and find new [xx,yy] */
	    if(cct++ > 500 || (nxcor && !rn2(35)))
		return;

	    if(xx == COLNO-1 || xx == 0 || yy == 0 || yy == ROWNO-1)
		return;		/* impossible */

	    crm = &levl[xx][yy];
	    if(!(crm->typ)) {
		if(rn2(100)) {
			crm->typ = CORR;
			crm->scrsym = CORR_SYM;
			if(nxcor && !rn2(50))
				(void) mkobj_at(ROCK_SYM, xx, yy);
		} else {
			crm->typ = SCORR;
			crm->scrsym = ' ';
		}
	    } else
	    if(crm->typ != CORR && crm->typ != SCORR) {
		/* strange ... */
		return;
	    }

	    /* find next corridor position */
	    dix = abs(xx-tx);
	    diy = abs(yy-ty);

	    /* do we have to change direction ? */
	    if(dy && dix > diy) {
		register ddx = (xx > tx) ? -1 : 1;

		crm = &levl[xx+ddx][yy];
		if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
		    dx = ddx;
		    dy = 0;
		    continue;
		}
	    } else if(dx && diy > dix) {
		register ddy = (yy > ty) ? -1 : 1;

		crm = &levl[xx][yy+ddy];
		if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
		    dy = ddy;
		    dx = 0;
		    continue;
		}
	    }

	    /* continue straight on? */
	    crm = &levl[xx+dx][yy+dy];
	    if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
		continue;

	    /* no, what must we do now?? */
	    if(dx) {
		dx = 0;
		dy = (ty < yy) ? -1 : 1;
		crm = &levl[xx+dx][yy+dy];
		if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
		    continue;
		dy = -dy;
		continue;
	    } else {
		dy = 0;
		dx = (tx < xx) ? -1 : 1;
		crm = &levl[xx+dx][yy+dy];
		if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
		    continue;
		dx = -dx;
		continue;
	    }
	}

	/* we succeeded in digging the corridor */
	dodoor(tt.x, tt.y, troom);

	if(smeq[a] < smeq[b])
		smeq[b] = smeq[a];
	else
		smeq[a] = smeq[b];
}

make_niches()
{
	register int ct = rnd(nroom/2 + 1);
	while(ct--) makeniche(FALSE);
}

makevtele()
{
	makeniche(TRUE);
}

makeniche(with_trap)
boolean with_trap;
{
	register struct mkroom *aroom;
	register struct rm *rm;
	register int vct = 8;
	coord dd;
	register dy,xx,yy;
	register struct trap *ttmp;

	if(doorindex < DOORMAX)
	  while(vct--) {
	    aroom = &rooms[rn2(nroom-1)];
	    if(aroom->rtype != 0) continue;	/* not an ordinary room */
	    if(aroom->doorct == 1 && rn2(5)) continue;
	    if(rn2(2)) {
		dy = 1;
		dd = finddpos(aroom->lx,aroom->hy+1,aroom->hx,aroom->hy+1);
	    } else {
		dy = -1;
		dd = finddpos(aroom->lx,aroom->ly-1,aroom->hx,aroom->ly-1);
	    }
	    xx = dd.x;
	    yy = dd.y;
	    if((rm = &levl[xx][yy+dy])->typ) continue;
	    if(with_trap || !rn2(4)) {
		rm->typ = SCORR;
		rm->scrsym = ' ';
		if(with_trap) {
		    ttmp = maketrap(xx, yy+dy, TELEP_TRAP);
		    ttmp->once = 1;
		    make_engr_at(xx, yy-dy, "ad ae?ar um");
		}
		dosdoor(xx, yy, aroom, SDOOR);
	    } else {
		rm->typ = CORR;
		rm->scrsym = CORR_SYM;
		if(rn2(7))
		    dosdoor(xx, yy, aroom, rn2(5) ? SDOOR : DOOR);
		else {
		    mksobj_at(SCR_TELEPORTATION, xx, yy+dy);
		    if(!rn2(3)) (void) mkobj_at(0, xx, yy+dy);
		}
	    }
	    return;
	}
}

/* make a trap somewhere (in croom if mazeflag = 0) */
mktrap(num,mazeflag,croom)
register num,mazeflag;
register struct mkroom *croom;
{
	register struct trap *ttmp;
	register int kind,nopierc,nomimic,fakedoor,fakegold,tryct = 0;
	register xchar mx,my;
	extern char fut_geno[];

	if(!num || num >= TRAPNUM) {
		nopierc = (dlevel < 4) ? 1 : 0;
		nomimic = (dlevel < 9 || goldseen ) ? 1 : 0;
		if(index(fut_geno, 'M')) nomimic = 1;
		kind = rn2(TRAPNUM - nopierc - nomimic);
		/* note: PIERC = 7, MIMIC = 8, TRAPNUM = 9 */
	} else kind = num;

	if(kind == MIMIC) {
		register struct monst *mtmp;

		fakedoor = (!rn2(3) && !mazeflag);
		fakegold = (!fakedoor && !rn2(2));
		if(fakegold) goldseen = TRUE;
		do {
			if(++tryct > 200) return;
			if(fakedoor) {
				/* note: fakedoor maybe on actual door */
				if(rn2(2)){
					if(rn2(2))
						mx = croom->hx+1;
					else mx = croom->lx-1;
					my = somey();
				} else {
					if(rn2(2))
						my = croom->hy+1;
					else my = croom->ly-1;
					mx = somex();
				}
			} else if(mazeflag) {
				extern coord mazexy();
				coord mm;
				mm = mazexy();
				mx = mm.x;
				my = mm.y;
			} else {
				mx = somex();
				my = somey();
			}
		} while(m_at(mx,my) || levl[mx][my].typ == STAIRS);
		if(mtmp = makemon(PM_MIMIC,mx,my)) {
		    mtmp->mimic = 1;
		    mtmp->mappearance =
			fakegold ? '$' : fakedoor ? '+' :
			(mazeflag && rn2(2)) ? AMULET_SYM :
			"=/)%?![<>" [ rn2(9) ];
		}
		return;
	}

	do {
		if(++tryct > 200)
			return;
		if(mazeflag){
			extern coord mazexy();
			coord mm;
			mm = mazexy();
			mx = mm.x;
			my = mm.y;
		} else {
			mx = somex();
			my = somey();
		}
	} while(t_at(mx, my) || levl[mx][my].typ == STAIRS);
	ttmp = maketrap(mx, my, kind);
	if(mazeflag && !rn2(10) && ttmp->ttyp < PIERC)
		ttmp->tseen = 1;
}
Commit	Line	Data
7c496796 WJ	1	/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
	2	/* hack.mklev.c - version 1.0.3 */
	3
	4	#include "hack.h"
	5
	6	extern char getlogin(), getenv();
	7	extern struct monst *makemon();
	8	extern struct obj *mkobj_at();
	9	extern struct trap *maketrap();
	10
	11	#define somex() ((random()%(croom->hx-croom->lx+1))+croom->lx)
	12	#define somey() ((random()%(croom->hy-croom->ly+1))+croom->ly)
	13
	14	#include "def.mkroom.h"
	15	#define XLIM 4 /* define minimum required space around a room */
	16	#define YLIM 3
	17	boolean secret; /* TRUE while making a vault: increase [XY]LIM */
	18	struct mkroom rooms[MAXNROFROOMS+1];
	19	int smeq[MAXNROFROOMS+1];
	20	coord doors[DOORMAX];
	21	int doorindex;
	22	struct rm zerorm;
	23	int comp();
	24	schar nxcor;
	25	boolean goldseen;
	26	int nroom;
	27	xchar xdnstair,xupstair,ydnstair,yupstair;
	28
	29	/* Definitions used by makerooms() and addrs() */
	30	#define MAXRS 50 /* max lth of temp rectangle table - arbitrary */
	31	struct rectangle {
	32	xchar rlx,rly,rhx,rhy;
	33	} rs[MAXRS+1];
	34	int rscnt,rsmax; /* 0..rscnt-1: currently under consideration */
	35	/* rscnt..rsmax: discarded */
	36
	37	makelevel()
	38	{
	39	register struct mkroom croom, troom;
	40	register unsigned tryct;
	41	register x,y;
	42
	43	nroom = 0;
	44	doorindex = 0;
	45	rooms[0].hx = -1; /* in case we are in a maze */
	46
	47	for(x=0; x<COLNO; x++) for(y=0; y<ROWNO; y++)
	48	levl[x][y] = zerorm;
	49
	50	oinit(); /* assign level dependent obj probabilities */
	51
	52	if(dlevel >= rn1(3, 26)) { /* there might be several mazes */
	53	makemaz();
	54	return;
	55	}
	56
	57	/* construct the rooms */
	58	nroom = 0;
	59	secret = FALSE;
	60	(void) makerooms();
	61
	62	/* construct stairs (up and down in different rooms if possible) */
	63	croom = &rooms[rn2(nroom)];
	64	xdnstair = somex();
65	ydnstair = somey();
66	levl[xdnstair][ydnstair].scrsym ='>';
67	levl[xdnstair][ydnstair].typ = STAIRS;
68	if(nroom > 1) {
69	troom = croom;
70	croom = &rooms[rn2(nroom-1)];
71	if(croom >= troom) croom++;
72	}
73	xupstair = somex(); /* %% < and > might be in the same place */
74	yupstair = somey();
75	levl[xupstair][yupstair].scrsym ='<';
76	levl[xupstair][yupstair].typ = STAIRS;
77
78	/* for each room: put things inside */
79	for(croom = rooms; croom->hx > 0; croom++) {
80
81	/* put a sleeping monster inside */
82	/* Note: monster may be on the stairs. This cannot be
83	avoided: maybe the player fell through a trapdoor
84	while a monster was on the stairs. Conclusion:
85	we have to check for monsters on the stairs anyway. */
86	if(!rn2(3)) (void)
87	makemon((struct permonst *) 0, somex(), somey());
88
89	/* put traps and mimics inside */
90	goldseen = FALSE;
91	while(!rn2(8-(dlevel/6))) mktrap(0,0,croom);
92	if(!goldseen && !rn2(3)) mkgold(0L,somex(),somey());
93	if(!rn2(3)) {
94	(void) mkobj_at(0, somex(), somey());
95	tryct = 0;
96	while(!rn2(5)) {
97	if(++tryct > 100){
98	printf("tryct overflow4\n");
99	break;
100	}
101	(void) mkobj_at(0, somex(), somey());
102	}
103	}
104	}
105
106	qsort((char *) rooms, nroom, sizeof(struct mkroom), comp);
107	makecorridors();
108	make_niches();
109
110	/* make a secret treasure vault, not connected to the rest */
111	if(nroom <= (2*MAXNROFROOMS/3)) if(rn2(3)) {
112	troom = &rooms[nroom];
113	secret = TRUE;
114	if(makerooms()) {
115	troom->rtype = VAULT; /* treasure vault */
116	for(x = troom->lx; x <= troom->hx; x++)
117	for(y = troom->ly; y <= troom->hy; y++)
118	mkgold((long)(rnd(dlevel*100) + 50), x, y);
119	if(!rn2(3))
120	makevtele();
121	}
122	}
123
124	#ifndef QUEST
125	#ifdef WIZARD
126	if(wizard && getenv("SHOPTYPE")) mkshop(); else
127	#endif WIZARD
128	if(dlevel > 1 && dlevel < 20 && rn2(dlevel) < 3) mkshop();
129	else
130	if(dlevel > 6 && !rn2(7)) mkzoo(ZOO);
131	else
132	if(dlevel > 9 && !rn2(5)) mkzoo(BEEHIVE);
133	else
134	if(dlevel > 11 && !rn2(6)) mkzoo(MORGUE);
135	else
136	if(dlevel > 18 && !rn2(6)) mkswamp();
137	#endif QUEST
138	}
139
140	makerooms() {
141	register struct rectangle *rsp;
142	register int lx, ly, hx, hy, lowx, lowy, hix, hiy, dx, dy;
143	int tryct = 0, xlim, ylim;
144
145	/* init */
146	xlim = XLIM + secret;
147	ylim = YLIM + secret;
148	if(nroom == 0) {
149	rsp = rs;
150	rsp->rlx = rsp->rly = 0;
151	rsp->rhx = COLNO-1;
152	rsp->rhy = ROWNO-1;
153	rsmax = 1;
154	}
155	rscnt = rsmax;
156
157	/* make rooms until satisfied */
158	while(rscnt > 0 && nroom < MAXNROFROOMS-1) {
159	if(!secret && nroom > (MAXNROFROOMS/3) &&
160	!rn2((MAXNROFROOMS-nroom)*(MAXNROFROOMS-nroom)))
161	return(0);
162
163	/* pick a rectangle */
164	rsp = &rs[rn2(rscnt)];
165	hx = rsp->rhx;
166	hy = rsp->rhy;
167	lx = rsp->rlx;
168	ly = rsp->rly;
169
170	/* find size of room */
171	if(secret)
172	dx = dy = 1;
173	else {
174	dx = 2 + rn2((hx-lx-8 > 20) ? 12 : 8);
175	dy = 2 + rn2(4);
176	if(dx*dy > 50)
177	dy = 50/dx;
178	}
179
180	/* look whether our room will fit */
181	if(hx-lx < dx + dx/2 + 2xlim \|\| hy-ly < dy + dy/3 + 2ylim) {
182	/* no, too small */
183	/* maybe we throw this area out */
184	if(secret \|\| !rn2(MAXNROFROOMS+1-nroom-tryct)) {
185	rscnt--;
186	rs[rsmax] = *rsp;
187	*rsp = rs[rscnt];
188	rs[rscnt] = rs[rsmax];
189	tryct = 0;
190	} else
191	tryct++;
192	continue;
193	}
194
195	lowx = lx + xlim + rn2(hx - lx - dx - 2*xlim + 1);
196	lowy = ly + ylim + rn2(hy - ly - dy - 2*ylim + 1);
197	hix = lowx + dx;
198	hiy = lowy + dy;
199
200	if(maker(lowx, dx, lowy, dy)) {
201	if(secret)
202	return(1);
203	addrs(lowx-1, lowy-1, hix+1, hiy+1);
204	tryct = 0;
205	} else
206	if(tryct++ > 100)
207	break;
208	}
209	return(0); /* failed to make vault - very strange */
210	}
211
212	addrs(lowx,lowy,hix,hiy)
213	register int lowx,lowy,hix,hiy;
214	{
215	register struct rectangle *rsp;
216	register int lx,ly,hx,hy,xlim,ylim;
217	boolean discarded;
218
219	xlim = XLIM + secret;
220	ylim = YLIM + secret;
221
222	/* walk down since rscnt and rsmax change */
223	for(rsp = &rs[rsmax-1]; rsp >= rs; rsp--) {
224
225	if((lx = rsp->rlx) > hix \|\| (ly = rsp->rly) > hiy \|\|
226	(hx = rsp->rhx) < lowx \|\| (hy = rsp->rhy) < lowy)
227	continue;
228	if((discarded = (rsp >= &rs[rscnt]))) {
229	*rsp = rs[--rsmax];
230	} else {
231	rsmax--;
232	rscnt--;
233	*rsp = rs[rscnt];
234	if(rscnt != rsmax)
235	rs[rscnt] = rs[rsmax];
236	}
237	if(lowy - ly > 2*ylim + 4)
238	addrsx(lx,ly,hx,lowy-2,discarded);
239	if(lowx - lx > 2*xlim + 4)
240	addrsx(lx,ly,lowx-2,hy,discarded);
241	if(hy - hiy > 2*ylim + 4)
242	addrsx(lx,hiy+2,hx,hy,discarded);
243	if(hx - hix > 2*xlim + 4)
244	addrsx(hix+2,ly,hx,hy,discarded);
245	}
246	}
247
248	addrsx(lx,ly,hx,hy,discarded)
249	register int lx,ly,hx,hy;
250	boolean discarded; /* piece of a discarded area */
251	{
252	register struct rectangle *rsp;
253
254	/* check inclusions */
255	for(rsp = rs; rsp < &rs[rsmax]; rsp++) {
256	if(lx >= rsp->rlx && hx <= rsp->rhx &&
257	ly >= rsp->rly && hy <= rsp->rhy)
258	return;
259	}
260
261	/* make a new entry */
262	if(rsmax >= MAXRS) {
263	#ifdef WIZARD
264	if(wizard) pline("MAXRS may be too small.");
265	#endif WIZARD
266	return;
267	}
268	rsmax++;
269	if(!discarded) {
270	*rsp = rs[rscnt];
271	rsp = &rs[rscnt];
272	rscnt++;
273	}
274	rsp->rlx = lx;
275	rsp->rly = ly;
276	rsp->rhx = hx;
277	rsp->rhy = hy;
278	}
279
280	comp(x,y)
281	register struct mkroom x,y;
282	{
283	if(x->lx < y->lx) return(-1);
284	return(x->lx > y->lx);
285	}
286
287	coord
288	finddpos(xl,yl,xh,yh) {
289	coord ff;
290	register x,y;
291
292	x = (xl == xh) ? xl : (xl + rn2(xh-xl+1));
293	y = (yl == yh) ? yl : (yl + rn2(yh-yl+1));
294	if(okdoor(x, y))
295	goto gotit;
296
297	for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
298	if(okdoor(x, y))
299	goto gotit;
300
301	for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
302	if(levl[x][y].typ == DOOR \|\| levl[x][y].typ == SDOOR)
303	goto gotit;
304	/* cannot find something reasonable -- strange */
305	x = xl;
306	y = yh;
307	gotit:
308	ff.x = x;
309	ff.y = y;
310	return(ff);
311	}
312
313	/* see whether it is allowable to create a door at [x,y] */
314	okdoor(x,y)
315	register x,y;
316	{
317	if(levl[x-1][y].typ == DOOR \|\| levl[x+1][y].typ == DOOR \|\|
318	levl[x][y+1].typ == DOOR \|\| levl[x][y-1].typ == DOOR \|\|
319	levl[x-1][y].typ == SDOOR \|\| levl[x+1][y].typ == SDOOR \|\|
320	levl[x][y-1].typ == SDOOR \|\| levl[x][y+1].typ == SDOOR \|\|
321	(levl[x][y].typ != HWALL && levl[x][y].typ != VWALL) \|\|
322	doorindex >= DOORMAX)
323	return(0);
324	return(1);
325	}
326
327	dodoor(x,y,aroom)
328	register x,y;
329	register struct mkroom *aroom;
330	{
331	if(doorindex >= DOORMAX) {
332	impossible("DOORMAX exceeded?");
333	return;
334	}
335	if(!okdoor(x,y) && nxcor)
336	return;
337	dosdoor(x,y,aroom,rn2(8) ? DOOR : SDOOR);
338	}
339
340	dosdoor(x,y,aroom,type)
341	register x,y;
342	register struct mkroom *aroom;
343	register type;
344	{
345	register struct mkroom *broom;
346	register tmp;
347
348	if(!IS_WALL(levl[x][y].typ)) /* avoid SDOORs with '+' as scrsym */
349	type = DOOR;
350	levl[x][y].typ = type;
351	if(type == DOOR)
352	levl[x][y].scrsym = '+';
353	aroom->doorct++;
354	broom = aroom+1;
355	if(broom->hx < 0) tmp = doorindex; else
356	for(tmp = doorindex; tmp > broom->fdoor; tmp--)
357	doors[tmp] = doors[tmp-1];
358	doorindex++;
359	doors[tmp].x = x;
360	doors[tmp].y = y;
361	for( ; broom->hx >= 0; broom++) broom->fdoor++;
362	}
363
364	/* Only called from makerooms() */
365	maker(lowx,ddx,lowy,ddy)
366	schar lowx,ddx,lowy,ddy;
367	{
368	register struct mkroom *croom;
369	register x, y, hix = lowx+ddx, hiy = lowy+ddy;
370	register xlim = XLIM + secret, ylim = YLIM + secret;
371
372	if(nroom >= MAXNROFROOMS) return(0);
373	if(lowx < XLIM) lowx = XLIM;
374	if(lowy < YLIM) lowy = YLIM;
375	if(hix > COLNO-XLIM-1) hix = COLNO-XLIM-1;
376	if(hiy > ROWNO-YLIM-1) hiy = ROWNO-YLIM-1;
377	chk:
378	if(hix <= lowx \|\| hiy <= lowy) return(0);
379
380	/* check area around room (and make room smaller if necessary) */
381	for(x = lowx - xlim; x <= hix + xlim; x++) {
382	for(y = lowy - ylim; y <= hiy + ylim; y++) {
383	if(levl[x][y].typ) {
384	#ifdef WIZARD
385	if(wizard && !secret)
386	pline("Strange area [%d,%d] in maker().",x,y);
387	#endif WIZARD
388	if(!rn2(3)) return(0);
389	if(x < lowx)
390	lowx = x+xlim+1;
391	else
392	hix = x-xlim-1;
393	if(y < lowy)
394	lowy = y+ylim+1;
395	else
396	hiy = y-ylim-1;
397	goto chk;
398	}
399	}
400	}
401
402	croom = &rooms[nroom];
403
404	/* on low levels the room is lit (usually) */
405	/* secret vaults are always lit */
406	if((rnd(dlevel) < 10 && rn2(77)) \|\| (ddx == 1 && ddy == 1)) {
407	for(x = lowx-1; x <= hix+1; x++)
408	for(y = lowy-1; y <= hiy+1; y++)
409	levl[x][y].lit = 1;
410	croom->rlit = 1;
411	} else
412	croom->rlit = 0;
413	croom->lx = lowx;
414	croom->hx = hix;
415	croom->ly = lowy;
416	croom->hy = hiy;
417	croom->rtype = croom->doorct = croom->fdoor = 0;
418
419	for(x = lowx-1; x <= hix+1; x++)
420	for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) {
421	levl[x][y].scrsym = '-';
422	levl[x][y].typ = HWALL;
423	}
424	for(x = lowx-1; x <= hix+1; x += (hix-lowx+2))
425	for(y = lowy; y <= hiy; y++) {
426	levl[x][y].scrsym = '\|';
427	levl[x][y].typ = VWALL;
428	}
429	for(x = lowx; x <= hix; x++)
430	for(y = lowy; y <= hiy; y++) {
431	levl[x][y].scrsym = '.';
432	levl[x][y].typ = ROOM;
433	}
434
435	smeq[nroom] = nroom;
436	croom++;
437	croom->hx = -1;
438	nroom++;
439	return(1);
440	}
441
442	makecorridors() {
443	register a,b;
444
445	nxcor = 0;
446	for(a = 0; a < nroom-1; a++)
447	join(a, a+1);
448	for(a = 0; a < nroom-2; a++)
449	if(smeq[a] != smeq[a+2])
450	join(a, a+2);
451	for(a = 0; a < nroom; a++)
452	for(b = 0; b < nroom; b++)
453	if(smeq[a] != smeq[b])
454	join(a, b);
455	if(nroom > 2)
456	for(nxcor = rn2(nroom) + 4; nxcor; nxcor--) {
457	a = rn2(nroom);
458	b = rn2(nroom-2);
459	if(b >= a) b += 2;
460	join(a, b);
461	}
462	}
463
464	join(a,b)
465	register a,b;
466	{
467	coord cc,tt;
468	register tx, ty, xx, yy;
469	register struct rm *crm;
470	register struct mkroom croom, troom;
471	register dx, dy, dix, diy, cct;
472
473	croom = &rooms[a];
474	troom = &rooms[b];
475
476	/* find positions cc and tt for doors in croom and troom
477	and direction for a corridor between them */
478
479	if(troom->hx < 0 \|\| croom->hx < 0 \|\| doorindex >= DOORMAX) return;
480	if(troom->lx > croom->hx) {
481	dx = 1;
482	dy = 0;
483	xx = croom->hx+1;
484	tx = troom->lx-1;
485	cc = finddpos(xx,croom->ly,xx,croom->hy);
486	tt = finddpos(tx,troom->ly,tx,troom->hy);
487	} else if(troom->hy < croom->ly) {
488	dy = -1;
489	dx = 0;
490	yy = croom->ly-1;
491	cc = finddpos(croom->lx,yy,croom->hx,yy);
492	ty = troom->hy+1;
493	tt = finddpos(troom->lx,ty,troom->hx,ty);
494	} else if(troom->hx < croom->lx) {
495	dx = -1;
496	dy = 0;
497	xx = croom->lx-1;
498	tx = troom->hx+1;
499	cc = finddpos(xx,croom->ly,xx,croom->hy);
500	tt = finddpos(tx,troom->ly,tx,troom->hy);
501	} else {
502	dy = 1;
503	dx = 0;
504	yy = croom->hy+1;
505	ty = troom->ly-1;
506	cc = finddpos(croom->lx,yy,croom->hx,yy);
507	tt = finddpos(troom->lx,ty,troom->hx,ty);
508	}
509	xx = cc.x;
510	yy = cc.y;
511	tx = tt.x - dx;
512	ty = tt.y - dy;
513	if(nxcor && levl[xx+dx][yy+dy].typ)
514	return;
515	dodoor(xx,yy,croom);
516
517	cct = 0;
518	while(xx != tx \|\| yy != ty) {
519	xx += dx;
520	yy += dy;
521
522	/* loop: dig corridor at [xx,yy] and find new [xx,yy] */
523	if(cct++ > 500 \|\| (nxcor && !rn2(35)))
524	return;
525
526	if(xx == COLNO-1 \|\| xx == 0 \|\| yy == 0 \|\| yy == ROWNO-1)
527	return; /* impossible */
528
529	crm = &levl[xx][yy];
530	if(!(crm->typ)) {
531	if(rn2(100)) {
532	crm->typ = CORR;
533	crm->scrsym = CORR_SYM;
534	if(nxcor && !rn2(50))
535	(void) mkobj_at(ROCK_SYM, xx, yy);
536	} else {
537	crm->typ = SCORR;
538	crm->scrsym = ' ';
539	}
540	} else
541	if(crm->typ != CORR && crm->typ != SCORR) {
542	/* strange ... */
543	return;
544	}
545
546	/* find next corridor position */
547	dix = abs(xx-tx);
548	diy = abs(yy-ty);
549
550	/* do we have to change direction ? */
551	if(dy && dix > diy) {
552	register ddx = (xx > tx) ? -1 : 1;
553
554	crm = &levl[xx+ddx][yy];
555	if(!crm->typ \|\| crm->typ == CORR \|\| crm->typ == SCORR) {
556	dx = ddx;
557	dy = 0;
558	continue;
559	}
560	} else if(dx && diy > dix) {
561	register ddy = (yy > ty) ? -1 : 1;
562
563	crm = &levl[xx][yy+ddy];
564	if(!crm->typ \|\| crm->typ == CORR \|\| crm->typ == SCORR) {
565	dy = ddy;
566	dx = 0;
567	continue;
568	}
569	}
570
571	/* continue straight on? */
572	crm = &levl[xx+dx][yy+dy];
573	if(!crm->typ \|\| crm->typ == CORR \|\| crm->typ == SCORR)
574	continue;
575
576	/* no, what must we do now?? */
577	if(dx) {
578	dx = 0;
579	dy = (ty < yy) ? -1 : 1;
580	crm = &levl[xx+dx][yy+dy];
581	if(!crm->typ \|\| crm->typ == CORR \|\| crm->typ == SCORR)
582	continue;
583	dy = -dy;
584	continue;
585	} else {
586	dy = 0;
587	dx = (tx < xx) ? -1 : 1;
588	crm = &levl[xx+dx][yy+dy];
589	if(!crm->typ \|\| crm->typ == CORR \|\| crm->typ == SCORR)
590	continue;
591	dx = -dx;
592	continue;
593	}
594	}
595
596	/* we succeeded in digging the corridor */
597	dodoor(tt.x, tt.y, troom);
598
599	if(smeq[a] < smeq[b])
600	smeq[b] = smeq[a];
601	else
602	smeq[a] = smeq[b];
603	}
604
605	make_niches()
606	{
607	register int ct = rnd(nroom/2 + 1);
608	while(ct--) makeniche(FALSE);
609	}
610
611	makevtele()
612	{
613	makeniche(TRUE);
614	}
615
616	makeniche(with_trap)
617	boolean with_trap;
618	{
619	register struct mkroom *aroom;
620	register struct rm *rm;
621	register int vct = 8;
622	coord dd;
623	register dy,xx,yy;
624	register struct trap *ttmp;
625
626	if(doorindex < DOORMAX)
627	while(vct--) {
628	aroom = &rooms[rn2(nroom-1)];
629	if(aroom->rtype != 0) continue; /* not an ordinary room */
630	if(aroom->doorct == 1 && rn2(5)) continue;
631	if(rn2(2)) {
632	dy = 1;
633	dd = finddpos(aroom->lx,aroom->hy+1,aroom->hx,aroom->hy+1);
634	} else {
635	dy = -1;
636	dd = finddpos(aroom->lx,aroom->ly-1,aroom->hx,aroom->ly-1);
637	}
638	xx = dd.x;
639	yy = dd.y;
640	if((rm = &levl[xx][yy+dy])->typ) continue;
641	if(with_trap \|\| !rn2(4)) {
642	rm->typ = SCORR;
643	rm->scrsym = ' ';
644	if(with_trap) {
645	ttmp = maketrap(xx, yy+dy, TELEP_TRAP);
646	ttmp->once = 1;
647	make_engr_at(xx, yy-dy, "ad ae?ar um");
648	}
649	dosdoor(xx, yy, aroom, SDOOR);
650	} else {
651	rm->typ = CORR;
652	rm->scrsym = CORR_SYM;
653	if(rn2(7))
654	dosdoor(xx, yy, aroom, rn2(5) ? SDOOR : DOOR);
655	else {
656	mksobj_at(SCR_TELEPORTATION, xx, yy+dy);
657	if(!rn2(3)) (void) mkobj_at(0, xx, yy+dy);
658	}
659	}
660	return;
661	}
662	}
663
664	/* make a trap somewhere (in croom if mazeflag = 0) */
665	mktrap(num,mazeflag,croom)
666	register num,mazeflag;
667	register struct mkroom *croom;
668	{
669	register struct trap *ttmp;
670	register int kind,nopierc,nomimic,fakedoor,fakegold,tryct = 0;
671	register xchar mx,my;
672	extern char fut_geno[];
673
674	if(!num \|\| num >= TRAPNUM) {
675	nopierc = (dlevel < 4) ? 1 : 0;
676	nomimic = (dlevel < 9 \|\| goldseen ) ? 1 : 0;
677	if(index(fut_geno, 'M')) nomimic = 1;
678	kind = rn2(TRAPNUM - nopierc - nomimic);
679	/* note: PIERC = 7, MIMIC = 8, TRAPNUM = 9 */
680	} else kind = num;
681
682	if(kind == MIMIC) {
683	register struct monst *mtmp;
684
685	fakedoor = (!rn2(3) && !mazeflag);
686	fakegold = (!fakedoor && !rn2(2));
687	if(fakegold) goldseen = TRUE;
688	do {
689	if(++tryct > 200) return;
690	if(fakedoor) {
691	/* note: fakedoor maybe on actual door */
692	if(rn2(2)){
693	if(rn2(2))
694	mx = croom->hx+1;
695	else mx = croom->lx-1;
696	my = somey();
697	} else {
698	if(rn2(2))
699	my = croom->hy+1;
700	else my = croom->ly-1;
701	mx = somex();
702	}
703	} else if(mazeflag) {
704	extern coord mazexy();
705	coord mm;
706	mm = mazexy();
707	mx = mm.x;
708	my = mm.y;
709	} else {
710	mx = somex();
711	my = somey();
712	}
713	} while(m_at(mx,my) \|\| levl[mx][my].typ == STAIRS);
714	if(mtmp = makemon(PM_MIMIC,mx,my)) {
715	mtmp->mimic = 1;
716	mtmp->mappearance =
717	fakegold ? '$' : fakedoor ? '+' :
718	(mazeflag && rn2(2)) ? AMULET_SYM :
719	"=/)%?![<>" [ rn2(9) ];
720	}
721	return;
722	}
723
724	do {
725	if(++tryct > 200)
726	return;
727	if(mazeflag){
728	extern coord mazexy();
729	coord mm;
730	mm = mazexy();
731	mx = mm.x;
732	my = mm.y;
733	} else {
734	mx = somex();
735	my = somey();
736	}
737	} while(t_at(mx, my) \|\| levl[mx][my].typ == STAIRS);
738	ttmp = maketrap(mx, my, kind);
739	if(mazeflag && !rn2(10) && ttmp->ttyp < PIERC)
740	ttmp->tseen = 1;
741	}