games/hack/hack.mklev.c

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