games/hack/hack.mklev.c

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