src/rooms.c

   1 /*
   2  * File: rooms.c
   3  * Purpose: make rooms. Used by generate.c when creating dungeons.
   4  */
   5
   6 /*
   7  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   8  *
   9  * This software may be copied and distributed for educational, research,
  10  * and not for profit purposes provided that this copyright and statement
  11  * are included in all such copies.  Other copyrights may also apply.
  12  */
  13
  14 #include "angband.h"
  15 #include "generate.h"
  16 #include "grid.h"
  17 #include "rooms.h"
  18
  19
  20 /*
  21  * [from SAngband (originally from OAngband)]
  22  *
  23  * Table of values that control how many times each type of room will
  24  * appear.  Each type of room has its own row, and each column
  25  * corresponds to dungeon levels 0, 10, 20, and so on.  The final
  26  * value is the minimum depth the room can appear at.  -LM-
  27  *
  28  * Level 101 and below use the values for level 100.
  29  *
  30  * Rooms with lots of monsters or loot may not be generated if the
  31  * object or monster lists are already nearly full.  Rooms will not
  32  * appear above their minimum depth.  Tiny levels will not have space
  33  * for all the rooms you ask for.
  34  */
  35 static room_info_type room_info_normal[ROOM_T_MAX] =
  36 {
  37         /* Depth */
  38         /*  0  10  20  30  40  50  60  70  80  90 100  min limit */
  39
  40         {{999,900,800,700,600,500,400,300,200,100,  0},  0}, /*NORMAL   */
  41         {{  1, 10, 20, 30, 40, 50, 60, 70, 80, 90,100},  1}, /*OVERLAP  */
  42         {{  1, 10, 20, 30, 40, 50, 60, 70, 80, 90,100},  3}, /*CROSS    */
  43         {{  1, 10, 20, 30, 40, 50, 60, 70, 80, 90,100},  3}, /*INNER_F  */
  44         {{  0,  1,  1,  1,  2,  3,  5,  6,  8, 10, 13}, 10}, /*NEST     */
  45         {{  0,  1,  1,  2,  3,  4,  6,  8, 10, 13, 16}, 10}, /*PIT      */
  46         {{  0,  1,  1,  1,  2,  2,  3,  5,  6,  8, 10}, 10}, /*LESSER_V */
  47         {{  0,  0,  1,  1,  1,  2,  2,  2,  3,  3,  4}, 20}, /*GREATER_V*/
  48         {{  0,100,200,300,400,500,600,700,800,900,999}, 10}, /*FRACAVE  */
  49         {{  0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2}, 10}, /*RANDOM_V */
  50         {{  0,  4,  8, 12, 16, 20, 24, 28, 32, 36, 40},  3}, /*OVAL     */
  51         {{  1,  6, 12, 18, 24, 30, 36, 42, 48, 54, 60}, 10}, /*CRYPT    */
  52         {{  0,  0,  1,  1,  1,  2,  3,  4,  5,  6,  8}, 20}, /*TRAP_PIT */
  53         {{  0,  0,  1,  1,  1,  2,  3,  4,  5,  6,  8}, 20}, /*TRAP     */
  54 };
  55
  56
  57 /* Build rooms in descending order of difficulty. */
  58 static byte room_build_order[ROOM_T_MAX] = {
  59         ROOM_T_GREATER_VAULT,
  60         ROOM_T_RANDOM_VAULT,
  61         ROOM_T_LESSER_VAULT,
  62         ROOM_T_TRAP_PIT,
  63         ROOM_T_PIT,
  64         ROOM_T_NEST,
  65         ROOM_T_TRAP,
  66         ROOM_T_INNER_FEAT,
  67         ROOM_T_OVAL,
  68         ROOM_T_CRYPT,
  69         ROOM_T_OVERLAP,
  70         ROOM_T_CROSS,
  71         ROOM_T_FRACAVE,
  72         ROOM_T_NORMAL,
  73 };
  74
  75
  76 static void place_locked_door(int y, int x)
  77 {
  78         if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
  79         {
  80                 place_floor_bold(y, x);
  81         }
  82         else
  83         {
  84                 set_cave_feat(y, x, FEAT_DOOR_HEAD+randint1(7));
  85                 cave[y][x].info &= ~(CAVE_FLOOR);
  86         }
  87 }
  88
  89 static void place_secret_door(int y, int x)
  90 {
  91         if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
  92         {
  93                 place_floor_bold(y, x);
  94         }
  95         else
  96         {
  97                 cave_type *c_ptr = &cave[y][x];
  98
  99                 /* Create secret door */
 100                 place_closed_door(y, x);
 101
 102                 /* Hide by inner wall because this is used in rooms only */
 103                 c_ptr->mimic = feat_wall_inner;
 104
 105                 /* Floor type terrain cannot hide a door */
 106                 if (feat_supports_los(c_ptr->mimic) && !feat_supports_los(c_ptr->feat))
 107                 {
 108                         if (have_flag(f_info[c_ptr->mimic].flags, FF_MOVE)) c_ptr->feat = c_ptr->mimic;
 109                         c_ptr->mimic = 0;
 110                 }
 111
 112                 c_ptr->info &= ~(CAVE_FLOOR);
 113         }
 114 }
 115
 116 /*
 117  * This funtion makes a very small room centred at (x0, y0)
 118  * This is used in crypts, and random elemental vaults.
 119  *
 120  * Note - this should be used only on allocated regions
 121  * within another room.
 122  */
 123 static void build_small_room(int x0, int y0)
 124 {
 125         int x, y;
 126
 127         for (y = y0 - 1; y <= y0 + 1; y++)
 128         {
 129                 place_inner_bold(y, x0 - 1);
 130                 place_inner_bold(y, x0 + 1);
 131         }
 132
 133         for (x = x0 - 1; x <= x0 + 1; x++)
 134         {
 135                 place_inner_bold(y0 - 1, x);
 136                 place_inner_bold(y0 + 1, x);
 137         }
 138
 139         /* Place a secret door on one side */
 140         switch (randint0(4))
 141         {
 142                 case 0: place_secret_door(y0, x0 - 1); break;
 143                 case 1: place_secret_door(y0, x0 + 1); break;
 144                 case 2: place_secret_door(y0 - 1, x0); break;
 145                 case 3: place_secret_door(y0 + 1, x0); break;
 146         }
 147
 148         /* Clear mimic type */
 149         cave[y0][x0].mimic = 0;
 150
 151         /* Add inner open space */
 152         place_floor_bold(y0, x0);
 153 }
 154
 155
 156 /*
 157  * This function tunnels around a room if
 158  * it will cut off part of a cave system.
 159  */
 160 static void check_room_boundary(int x1, int y1, int x2, int y2)
 161 {
 162         int count, x, y;
 163         bool old_is_floor, new_is_floor;
 164
 165
 166         /* Initialize */
 167         count = 0;
 168
 169         old_is_floor = get_is_floor(x1 - 1, y1);
 170
 171         /*
 172          * Count the number of floor-wall boundaries around the room
 173          * Note: diagonal squares are ignored since the player can move diagonally
 174          * to bypass these if needed.
 175          */
 176
 177         /* Above the top boundary */
 178         for (x = x1; x <= x2; x++)
 179         {
 180                 new_is_floor = get_is_floor(x, y1 - 1);
 181
 182                 /* Increment counter if they are different */
 183                 if (new_is_floor != old_is_floor) count++;
 184
 185                 old_is_floor = new_is_floor;
 186         }
 187
 188         /* Right boundary */
 189         for (y = y1; y <= y2; y++)
 190         {
 191                 new_is_floor = get_is_floor(x2 + 1, y);
 192
 193                 /* increment counter if they are different */
 194                 if (new_is_floor != old_is_floor) count++;
 195
 196                 old_is_floor = new_is_floor;
 197         }
 198
 199         /* Bottom boundary */
 200         for (x = x2; x >= x1; x--)
 201         {
 202                 new_is_floor = get_is_floor(x, y2 + 1);
 203
 204                 /* increment counter if they are different */
 205                 if (new_is_floor != old_is_floor) count++;
 206
 207                 old_is_floor = new_is_floor;
 208         }
 209
 210         /* Left boundary */
 211         for (y = y2; y >= y1; y--)
 212         {
 213                 new_is_floor = get_is_floor(x1 - 1, y);
 214
 215                 /* increment counter if they are different */
 216                 if (new_is_floor != old_is_floor) count++;
 217
 218                 old_is_floor = new_is_floor;
 219         }
 220
 221         /* If all the same, or only one connection exit. */
 222         if (count <= 2) return;
 223
 224
 225         /* Tunnel around the room so to prevent problems with caves */
 226         for (y = y1; y <= y2; y++)
 227         {
 228                 for (x = x1; x <= x2; x++)
 229                 {
 230                         set_floor(x, y);
 231                 }
 232         }
 233 }
 234
 235
 236 /*
 237  *  Helper function for find_space().
 238  *
 239  *  Is this a good location?
 240  */
 241 static bool find_space_aux(int blocks_high, int blocks_wide, int block_y, int block_x)
 242 {
 243         int by1, bx1, by2, bx2, by, bx;
 244
 245         /* Itty-bitty rooms must shift about within their rectangle */
 246         if (blocks_wide < 3)
 247         {
 248                 if ((blocks_wide == 2) && (block_x % 3) == 2)
 249                         return FALSE;
 250         }
 251
 252         /* Rooms with width divisible by 3 must be fitted to a rectangle. */
 253         else if ((blocks_wide % 3) == 0)
 254         {
 255                 /* Must be aligned to the left edge of a 11x33 rectangle. */
 256                 if ((block_x % 3) != 0)
 257                         return FALSE;
 258         }
 259
 260         /*
 261          * Big rooms that do not have a width divisible by 3 must be
 262          * aligned towards the edge of the dungeon closest to them.
 263          */
 264         else
 265         {
 266                 /* Shift towards left edge of dungeon. */
 267                 if (block_x + (blocks_wide / 2) <= dun->col_rooms / 2)
 268                 {
 269                         if (((block_x % 3) == 2) && ((blocks_wide % 3) == 2))
 270                                 return FALSE;
 271                         if ((block_x % 3) == 1)
 272                                 return FALSE;
 273                 }
 274
 275                 /* Shift toward right edge of dungeon. */
 276                 else
 277                 {
 278                         if (((block_x % 3) == 2) && ((blocks_wide % 3) == 2))
 279                                 return FALSE;
 280                         if ((block_x % 3) == 1)
 281                                 return FALSE;
 282                 }
 283         }
 284
 285         /* Extract blocks */
 286         by1 = block_y + 0;
 287         bx1 = block_x + 0;
 288         by2 = block_y + blocks_high;
 289         bx2 = block_x + blocks_wide;
 290
 291         /* Never run off the screen */
 292         if ((by1 < 0) || (by2 > dun->row_rooms)) return FALSE;
 293         if ((bx1 < 0) || (bx2 > dun->col_rooms)) return FALSE;
 294
 295         /* Verify available space */
 296         for (by = by1; by < by2; by++)
 297         {
 298                 for (bx = bx1; bx < bx2; bx++)
 299                 {
 300                         if (dun->room_map[by][bx])
 301                         {
 302                                 return FALSE;
 303                         }
 304                 }
 305         }
 306
 307         /* This location is okay */
 308         return TRUE;
 309 }
 310
 311
 312 /*
 313  * Find a good spot for the next room.  -LM-
 314  *
 315  * Find and allocate a free space in the dungeon large enough to hold
 316  * the room calling this function.
 317  *
 318  * We allocate space in 11x11 blocks, but want to make sure that rooms
 319  * align neatly on the standard screen.  Therefore, we make them use
 320  * blocks in few 11x33 rectangles as possible.
 321  *
 322  * Be careful to include the edges of the room in height and width!
 323  *
 324  * Return TRUE and values for the center of the room if all went well.
 325  * Otherwise, return FALSE.
 326  */
 327 static bool find_space(int *y, int *x, int height, int width)
 328 {
 329         int candidates, pick;
 330         int by, bx, by1, bx1, by2, bx2;
 331         int block_y = 0, block_x = 0;
 332
 333
 334         /* Find out how many blocks we need. */
 335         int blocks_high = 1 + ((height - 1) / BLOCK_HGT);
 336         int blocks_wide = 1 + ((width - 1) / BLOCK_WID);
 337
 338         /* There are no way to allocate such huge space */
 339         if (dun->row_rooms < blocks_high) return FALSE;
 340         if (dun->col_rooms < blocks_wide) return FALSE;
 341
 342 #if 0
 343         /* Sometimes, little rooms like to have more space. */
 344         if (blocks_wide == 2)
 345         {
 346                 if (one_in_(3)) blocks_wide = 3;
 347         }
 348         else if (blocks_wide == 1)
 349         {
 350                 if (one_in_(2)) blocks_wide = rand_range(2, 3);
 351         }
 352 #endif
 353
 354         /* Initiallize */
 355         candidates = 0;
 356
 357         /* Count the number of varid places */
 358         for (block_y = dun->row_rooms - blocks_high; block_y >= 0; block_y--)
 359         {
 360                 for (block_x = dun->col_rooms - blocks_wide; block_x >= 0; block_x--)
 361                 {
 362                         if (find_space_aux(blocks_high, blocks_wide, block_y, block_x))
 363                         {
 364                                 /* Find a varid place */
 365                                 candidates++;
 366                         }
 367                 }
 368         }
 369
 370         /* No place! */
 371         if (!candidates)
 372         {
 373                 return FALSE;
 374         }
 375
 376         /* Normal dungeon */
 377         if (!(d_info[dungeon_type].flags1 & DF1_NO_CAVE))
 378         {
 379                 /* Choose a random one */
 380                 pick = randint1(candidates);
 381         }
 382
 383         /* NO_CAVE dungeon (Castle) */
 384         else
 385         {
 386                 /* Always choose the center one */
 387                 pick = candidates/2 + 1;
 388         }
 389
 390         /* Pick up the choosen location */
 391         for (block_y = dun->row_rooms - blocks_high; block_y >= 0; block_y--)
 392         {
 393                 for (block_x = dun->col_rooms - blocks_wide; block_x >= 0; block_x--)
 394                 {
 395                         if (find_space_aux(blocks_high, blocks_wide, block_y, block_x))
 396                         {
 397                                 pick--;
 398
 399                                 /* This one is picked? */
 400                                 if (!pick) break;
 401                         }
 402                 }
 403
 404                 if (!pick) break;
 405         }
 406
 407         /* Extract blocks */
 408         by1 = block_y + 0;
 409         bx1 = block_x + 0;
 410         by2 = block_y + blocks_high;
 411         bx2 = block_x + blocks_wide;
 412
 413         /*
 414          * It is *extremely* important that the following calculation
 415          * be *exactly* correct to prevent memory errors
 416          */
 417
 418         /* Acquire the location of the room */
 419         (*y) = ((by1 + by2) * BLOCK_HGT) / 2;
 420         (*x) = ((bx1 + bx2) * BLOCK_WID) / 2;
 421
 422         /* Save the room location */
 423         if (dun->cent_n < CENT_MAX)
 424         {
 425                 dun->cent[dun->cent_n].y = *y;
 426                 dun->cent[dun->cent_n].x = *x;
 427                 dun->cent_n++;
 428         }
 429
 430         /* Reserve some blocks. */
 431         for (by = by1; by < by2; by++)
 432         {
 433                 for (bx = bx1; bx < bx2; bx++)
 434                 {
 435                         dun->room_map[by][bx] = TRUE;
 436                 }
 437         }
 438
 439
 440         /*
 441          * Hack- See if room will cut off a cavern.
 442          *
 443          * If so, fix by tunneling outside the room in such a
 444          * way as to connect the caves.
 445          */
 446         check_room_boundary(*x - width / 2 - 1, *y - height / 2 - 1, *x + (width - 1) / 2 + 1, *y + (height - 1) / 2 + 1);
 447
 448
 449         /* Success. */
 450         return TRUE;
 451 }
 452
 453
 454
 455 /*
 456  * Room building routines.
 457  *
 458  * Room types:
 459  *   1 -- normal
 460  *   2 -- overlapping
 461  *   3 -- cross shaped
 462  *   4 -- large room with features
 463  *   5 -- monster nests
 464  *   6 -- monster pits
 465  *   7 -- simple vaults
 466  *   8 -- greater vaults
 467  *   9 -- fractal caves
 468  *  10 -- random vaults
 469  *  11 -- circular rooms
 470  *  12 -- crypts
 471  *  13 -- trapped monster pits
 472  *  14 -- trapped room
 473  */
 474
 475
 476 /*
 477  * Type 1 -- normal rectangular rooms
 478  */
 479 static bool build_type1(void)
 480 {
 481         int y, x, y2, x2, yval, xval;
 482         int y1, x1, xsize, ysize;
 483
 484         bool light;
 485
 486         cave_type *c_ptr;
 487
 488         /* Pick a room size */
 489         y1 = randint1(4);
 490         x1 = randint1(11);
 491         y2 = randint1(3);
 492         x2 = randint1(11);
 493
 494         xsize = x1 + x2 + 1;
 495         ysize = y1 + y2 + 1;
 496
 497         /* Find and reserve some space in the dungeon.  Get center of room. */
 498         if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE;
 499
 500         /* Choose lite or dark */
 501         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
 502
 503
 504         /* Get corner values */
 505         y1 = yval - ysize / 2;
 506         x1 = xval - xsize / 2;
 507         y2 = yval + (ysize - 1) / 2;
 508         x2 = xval + (xsize - 1) / 2;
 509
 510
 511         /* Place a full floor under the room */
 512         for (y = y1 - 1; y <= y2 + 1; y++)
 513         {
 514                 for (x = x1 - 1; x <= x2 + 1; x++)
 515                 {
 516                         c_ptr = &cave[y][x];
 517                         place_floor_grid(c_ptr);
 518                         c_ptr->info |= (CAVE_ROOM);
 519                         if (light) c_ptr->info |= (CAVE_GLOW);
 520                 }
 521         }
 522
 523         /* Walls around the room */
 524         for (y = y1 - 1; y <= y2 + 1; y++)
 525         {
 526                 c_ptr = &cave[y][x1 - 1];
 527                 place_outer_grid(c_ptr);
 528                 c_ptr = &cave[y][x2 + 1];
 529                 place_outer_grid(c_ptr);
 530         }
 531         for (x = x1 - 1; x <= x2 + 1; x++)
 532         {
 533                 c_ptr = &cave[y1 - 1][x];
 534                 place_outer_grid(c_ptr);
 535                 c_ptr = &cave[y2 + 1][x];
 536                 place_outer_grid(c_ptr);
 537         }
 538
 539
 540         /* Hack -- Occasional pillar room */
 541         if (one_in_(20))
 542         {
 543                 for (y = y1; y <= y2; y += 2)
 544                 {
 545                         for (x = x1; x <= x2; x += 2)
 546                         {
 547                                 c_ptr = &cave[y][x];
 548                                 place_inner_grid(c_ptr);
 549                         }
 550                 }
 551         }
 552
 553         /* Hack -- Occasional room with four pillars */
 554         else if (one_in_(20))
 555         {
 556                 if ((y1 + 4 < y2) && (x1 + 4 < x2))
 557                 {
 558                         c_ptr = &cave[y1 + 1][x1 + 1];
 559                         place_inner_grid(c_ptr);
 560
 561                         c_ptr = &cave[y1 + 1][x2 - 1];
 562                         place_inner_grid(c_ptr);
 563
 564                         c_ptr = &cave[y2 - 1][x1 + 1];
 565                         place_inner_grid(c_ptr);
 566
 567                         c_ptr = &cave[y2 - 1][x2 - 1];
 568                         place_inner_grid(c_ptr);
 569                 }
 570         }
 571
 572         /* Hack -- Occasional ragged-edge room */
 573         else if (one_in_(50))
 574         {
 575                 for (y = y1 + 2; y <= y2 - 2; y += 2)
 576                 {
 577                         c_ptr = &cave[y][x1];
 578                         place_inner_grid(c_ptr);
 579                         c_ptr = &cave[y][x2];
 580                         place_inner_grid(c_ptr);
 581                 }
 582                 for (x = x1 + 2; x <= x2 - 2; x += 2)
 583                 {
 584                         c_ptr = &cave[y1][x];
 585                         place_inner_grid(c_ptr);
 586                         c_ptr = &cave[y2][x];
 587                         place_inner_grid(c_ptr);
 588                 }
 589         }
 590         /* Hack -- Occasional divided room */
 591         else if (one_in_(50))
 592         {
 593                 if (randint1(100) < 50)
 594                 {
 595                         /* Horizontal wall */
 596                         for (x = x1; x <= x2; x++)
 597                         {
 598                                 place_inner_bold(yval, x);
 599                         }
 600
 601                         /* Prevent edge of wall from being tunneled */
 602                         place_solid_bold(yval, x1 - 1);
 603                         place_solid_bold(yval, x2 + 1);
 604                 }
 605                 else
 606                 {
 607                         /* Vertical wall */
 608                         for (y = y1; y <= y2; y++)
 609                         {
 610                                 place_inner_bold(y, xval);
 611                         }
 612
 613                         /* Prevent edge of wall from being tunneled */
 614                         place_solid_bold(y1 - 1, xval);
 615                         place_solid_bold(y2 + 1, xval);
 616                 }
 617
 618                 place_random_door(yval, xval, TRUE);
 619         }
 620
 621         return TRUE;
 622 }
 623
 624
 625 /*
 626  * Type 2 -- Overlapping rectangular rooms
 627  */
 628 static bool build_type2(void)
 629 {
 630         int                     y, x, xval, yval;
 631         int                     y1a, x1a, y2a, x2a;
 632         int                     y1b, x1b, y2b, x2b;
 633         bool            light;
 634         cave_type   *c_ptr;
 635
 636         /* Find and reserve some space in the dungeon.  Get center of room. */
 637         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
 638
 639         /* Choose lite or dark */
 640         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
 641
 642         /* Determine extents of the first room */
 643         y1a = yval - randint1(4);
 644         y2a = yval + randint1(3);
 645         x1a = xval - randint1(11);
 646         x2a = xval + randint1(10);
 647
 648         /* Determine extents of the second room */
 649         y1b = yval - randint1(3);
 650         y2b = yval + randint1(4);
 651         x1b = xval - randint1(10);
 652         x2b = xval + randint1(11);
 653
 654
 655         /* Place a full floor for room "a" */
 656         for (y = y1a - 1; y <= y2a + 1; y++)
 657         {
 658                 for (x = x1a - 1; x <= x2a + 1; x++)
 659                 {
 660                         c_ptr = &cave[y][x];
 661                         place_floor_grid(c_ptr);
 662                         c_ptr->info |= (CAVE_ROOM);
 663                         if (light) c_ptr->info |= (CAVE_GLOW);
 664                 }
 665         }
 666
 667         /* Place a full floor for room "b" */
 668         for (y = y1b - 1; y <= y2b + 1; y++)
 669         {
 670                 for (x = x1b - 1; x <= x2b + 1; x++)
 671                 {
 672                         c_ptr = &cave[y][x];
 673                         place_floor_grid(c_ptr);
 674                         c_ptr->info |= (CAVE_ROOM);
 675                         if (light) c_ptr->info |= (CAVE_GLOW);
 676                 }
 677         }
 678
 679
 680         /* Place the walls around room "a" */
 681         for (y = y1a - 1; y <= y2a + 1; y++)
 682         {
 683                 c_ptr = &cave[y][x1a - 1];
 684                 place_outer_grid(c_ptr);
 685                 c_ptr = &cave[y][x2a + 1];
 686                 place_outer_grid(c_ptr);
 687         }
 688         for (x = x1a - 1; x <= x2a + 1; x++)
 689         {
 690                 c_ptr = &cave[y1a - 1][x];
 691                 place_outer_grid(c_ptr);
 692                 c_ptr = &cave[y2a + 1][x];
 693                 place_outer_grid(c_ptr);
 694         }
 695
 696         /* Place the walls around room "b" */
 697         for (y = y1b - 1; y <= y2b + 1; y++)
 698         {
 699                 c_ptr = &cave[y][x1b - 1];
 700                 place_outer_grid(c_ptr);
 701                 c_ptr = &cave[y][x2b + 1];
 702                 place_outer_grid(c_ptr);
 703         }
 704         for (x = x1b - 1; x <= x2b + 1; x++)
 705         {
 706                 c_ptr = &cave[y1b - 1][x];
 707                 place_outer_grid(c_ptr);
 708                 c_ptr = &cave[y2b + 1][x];
 709                 place_outer_grid(c_ptr);
 710         }
 711
 712
 713
 714         /* Replace the floor for room "a" */
 715         for (y = y1a; y <= y2a; y++)
 716         {
 717                 for (x = x1a; x <= x2a; x++)
 718                 {
 719                         c_ptr = &cave[y][x];
 720                         place_floor_grid(c_ptr);
 721                 }
 722         }
 723
 724         /* Replace the floor for room "b" */
 725         for (y = y1b; y <= y2b; y++)
 726         {
 727                 for (x = x1b; x <= x2b; x++)
 728                 {
 729                         c_ptr = &cave[y][x];
 730                         place_floor_grid(c_ptr);
 731                 }
 732         }
 733
 734         return TRUE;
 735 }
 736
 737
 738
 739 /*
 740  * Type 3 -- Cross shaped rooms
 741  *
 742  * Builds a room at a row, column coordinate
 743  *
 744  * Room "a" runs north/south, and Room "b" runs east/east
 745  * So the "central pillar" runs from x1a, y1b to x2a, y2b.
 746  *
 747  * Note that currently, the "center" is always 3x3, but I think that
 748  * the code below will work (with "bounds checking") for 5x5, or even
 749  * for unsymetric values like 4x3 or 5x3 or 3x4 or 3x5, or even larger.
 750  */
 751 static bool build_type3(void)
 752 {
 753         int                     y, x, dy, dx, wy, wx;
 754         int                     y1a, x1a, y2a, x2a;
 755         int                     y1b, x1b, y2b, x2b;
 756         int                     yval, xval;
 757         bool            light;
 758         cave_type   *c_ptr;
 759
 760
 761         /* Find and reserve some space in the dungeon.  Get center of room. */
 762         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
 763
 764
 765         /* Choose lite or dark */
 766         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
 767
 768         /* For now, always 3x3 */
 769         wx = wy = 1;
 770
 771         /* Pick max vertical size (at most 4) */
 772         dy = rand_range(3, 4);
 773
 774         /* Pick max horizontal size (at most 15) */
 775         dx = rand_range(3, 11);
 776
 777
 778         /* Determine extents of the north/south room */
 779         y1a = yval - dy;
 780         y2a = yval + dy;
 781         x1a = xval - wx;
 782         x2a = xval + wx;
 783
 784         /* Determine extents of the east/west room */
 785         y1b = yval - wy;
 786         y2b = yval + wy;
 787         x1b = xval - dx;
 788         x2b = xval + dx;
 789
 790
 791         /* Place a full floor for room "a" */
 792         for (y = y1a - 1; y <= y2a + 1; y++)
 793         {
 794                 for (x = x1a - 1; x <= x2a + 1; x++)
 795                 {
 796                         c_ptr = &cave[y][x];
 797                         place_floor_grid(c_ptr);
 798                         c_ptr->info |= (CAVE_ROOM);
 799                         if (light) c_ptr->info |= (CAVE_GLOW);
 800                 }
 801         }
 802
 803         /* Place a full floor for room "b" */
 804         for (y = y1b - 1; y <= y2b + 1; y++)
 805         {
 806                 for (x = x1b - 1; x <= x2b + 1; x++)
 807                 {
 808                         c_ptr = &cave[y][x];
 809                         place_floor_grid(c_ptr);
 810                         c_ptr->info |= (CAVE_ROOM);
 811                         if (light) c_ptr->info |= (CAVE_GLOW);
 812                 }
 813         }
 814
 815
 816         /* Place the walls around room "a" */
 817         for (y = y1a - 1; y <= y2a + 1; y++)
 818         {
 819                 c_ptr = &cave[y][x1a - 1];
 820                 place_outer_grid(c_ptr);
 821                 c_ptr = &cave[y][x2a + 1];
 822                 place_outer_grid(c_ptr);
 823         }
 824         for (x = x1a - 1; x <= x2a + 1; x++)
 825         {
 826                 c_ptr = &cave[y1a - 1][x];
 827                 place_outer_grid(c_ptr);
 828                 c_ptr = &cave[y2a + 1][x];
 829                 place_outer_grid(c_ptr);
 830         }
 831
 832         /* Place the walls around room "b" */
 833         for (y = y1b - 1; y <= y2b + 1; y++)
 834         {
 835                 c_ptr = &cave[y][x1b - 1];
 836                 place_outer_grid(c_ptr);
 837                 c_ptr = &cave[y][x2b + 1];
 838                 place_outer_grid(c_ptr);
 839         }
 840         for (x = x1b - 1; x <= x2b + 1; x++)
 841         {
 842                 c_ptr = &cave[y1b - 1][x];
 843                 place_outer_grid(c_ptr);
 844                 c_ptr = &cave[y2b + 1][x];
 845                 place_outer_grid(c_ptr);
 846         }
 847
 848
 849         /* Replace the floor for room "a" */
 850         for (y = y1a; y <= y2a; y++)
 851         {
 852                 for (x = x1a; x <= x2a; x++)
 853                 {
 854                         c_ptr = &cave[y][x];
 855                         place_floor_grid(c_ptr);
 856                 }
 857         }
 858
 859         /* Replace the floor for room "b" */
 860         for (y = y1b; y <= y2b; y++)
 861         {
 862                 for (x = x1b; x <= x2b; x++)
 863                 {
 864                         c_ptr = &cave[y][x];
 865                         place_floor_grid(c_ptr);
 866                 }
 867         }
 868
 869
 870
 871         /* Special features (3/4) */
 872         switch (randint0(4))
 873         {
 874                 /* Large solid middle pillar */
 875                 case 1:
 876                 {
 877                         for (y = y1b; y <= y2b; y++)
 878                         {
 879                                 for (x = x1a; x <= x2a; x++)
 880                                 {
 881                                         c_ptr = &cave[y][x];
 882                                         place_inner_grid(c_ptr);
 883                                 }
 884                         }
 885                         break;
 886                 }
 887
 888                 /* Inner treasure vault */
 889                 case 2:
 890                 {
 891                         /* Build the vault */
 892                         for (y = y1b; y <= y2b; y++)
 893                         {
 894                                 c_ptr = &cave[y][x1a];
 895                                 place_inner_grid(c_ptr);
 896                                 c_ptr = &cave[y][x2a];
 897                                 place_inner_grid(c_ptr);
 898                         }
 899                         for (x = x1a; x <= x2a; x++)
 900                         {
 901                                 c_ptr = &cave[y1b][x];
 902                                 place_inner_grid(c_ptr);
 903                                 c_ptr = &cave[y2b][x];
 904                                 place_inner_grid(c_ptr);
 905                         }
 906
 907                         /* Place a secret door on the inner room */
 908                         switch (randint0(4))
 909                         {
 910                                 case 0: place_secret_door(y1b, xval); break;
 911                                 case 1: place_secret_door(y2b, xval); break;
 912                                 case 2: place_secret_door(yval, x1a); break;
 913                                 case 3: place_secret_door(yval, x2a); break;
 914                         }
 915
 916                         /* Place a treasure in the vault */
 917                         place_object(yval, xval, 0L);
 918
 919                         /* Let's guard the treasure well */
 920                         vault_monsters(yval, xval, randint0(2) + 3);
 921
 922                         /* Traps naturally */
 923                         vault_traps(yval, xval, 4, 4, randint0(3) + 2);
 924
 925                         break;
 926                 }
 927
 928                 /* Something else */
 929                 case 3:
 930                 {
 931                         /* Occasionally pinch the center shut */
 932                         if (one_in_(3))
 933                         {
 934                                 /* Pinch the east/west sides */
 935                                 for (y = y1b; y <= y2b; y++)
 936                                 {
 937                                         if (y == yval) continue;
 938                                         c_ptr = &cave[y][x1a - 1];
 939                                         place_inner_grid(c_ptr);
 940                                         c_ptr = &cave[y][x2a + 1];
 941                                         place_inner_grid(c_ptr);
 942                                 }
 943
 944                                 /* Pinch the north/south sides */
 945                                 for (x = x1a; x <= x2a; x++)
 946                                 {
 947                                         if (x == xval) continue;
 948                                         c_ptr = &cave[y1b - 1][x];
 949                                         place_inner_grid(c_ptr);
 950                                         c_ptr = &cave[y2b + 1][x];
 951                                         place_inner_grid(c_ptr);
 952                                 }
 953
 954                                 /* Sometimes shut using secret doors */
 955                                 if (one_in_(3))
 956                                 {
 957                                         place_secret_door(yval, x1a - 1);
 958                                         place_secret_door(yval, x2a + 1);
 959                                         place_secret_door(y1b - 1, xval);
 960                                         place_secret_door(y2b + 1, xval);
 961                                 }
 962                         }
 963
 964                         /* Occasionally put a "plus" in the center */
 965                         else if (one_in_(3))
 966                         {
 967                                 c_ptr = &cave[yval][xval];
 968                                 place_inner_grid(c_ptr);
 969                                 c_ptr = &cave[y1b][xval];
 970                                 place_inner_grid(c_ptr);
 971                                 c_ptr = &cave[y2b][xval];
 972                                 place_inner_grid(c_ptr);
 973                                 c_ptr = &cave[yval][x1a];
 974                                 place_inner_grid(c_ptr);
 975                                 c_ptr = &cave[yval][x2a];
 976                                 place_inner_grid(c_ptr);
 977                         }
 978
 979                         /* Occasionally put a pillar in the center */
 980                         else if (one_in_(3))
 981                         {
 982                                 c_ptr = &cave[yval][xval];
 983                                 place_inner_grid(c_ptr);
 984                         }
 985
 986                         break;
 987                 }
 988         }
 989
 990         return TRUE;
 991 }
 992
 993
 994 /*
 995  * Type 4 -- Large room with inner features
 996  *
 997  * Possible sub-types:
 998  *      1 - Just an inner room with one door
 999  *      2 - An inner room within an inner room
1000  *      3 - An inner room with pillar(s)
1001  *      4 - Inner room has a maze
1002  *      5 - A set of four inner rooms
1003  */
1004 static bool build_type4(void)
1005 {
1006         int         y, x, y1, x1;
1007         int         y2, x2, tmp, yval, xval;
1008         bool        light;
1009         cave_type   *c_ptr;
1010
1011
1012         /* Find and reserve some space in the dungeon.  Get center of room. */
1013         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
1014
1015         /* Choose lite or dark */
1016         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
1017
1018         /* Large room */
1019         y1 = yval - 4;
1020         y2 = yval + 4;
1021         x1 = xval - 11;
1022         x2 = xval + 11;
1023
1024         /* Place a full floor under the room */
1025         for (y = y1 - 1; y <= y2 + 1; y++)
1026         {
1027                 for (x = x1 - 1; x <= x2 + 1; x++)
1028                 {
1029                         c_ptr = &cave[y][x];
1030                         place_floor_grid(c_ptr);
1031                         c_ptr->info |= (CAVE_ROOM);
1032                         if (light) c_ptr->info |= (CAVE_GLOW);
1033                 }
1034         }
1035
1036         /* Outer Walls */
1037         for (y = y1 - 1; y <= y2 + 1; y++)
1038         {
1039                 c_ptr = &cave[y][x1 - 1];
1040                 place_outer_grid(c_ptr);
1041                 c_ptr = &cave[y][x2 + 1];
1042                 place_outer_grid(c_ptr);
1043         }
1044         for (x = x1 - 1; x <= x2 + 1; x++)
1045         {
1046                 c_ptr = &cave[y1 - 1][x];
1047                 place_outer_grid(c_ptr);
1048                 c_ptr = &cave[y2 + 1][x];
1049                 place_outer_grid(c_ptr);
1050         }
1051
1052
1053         /* The inner room */
1054         y1 = y1 + 2;
1055         y2 = y2 - 2;
1056         x1 = x1 + 2;
1057         x2 = x2 - 2;
1058
1059         /* The inner walls */
1060         for (y = y1 - 1; y <= y2 + 1; y++)
1061         {
1062                 c_ptr = &cave[y][x1 - 1];
1063                 place_inner_grid(c_ptr);
1064                 c_ptr = &cave[y][x2 + 1];
1065                 place_inner_grid(c_ptr);
1066         }
1067         for (x = x1 - 1; x <= x2 + 1; x++)
1068         {
1069                 c_ptr = &cave[y1 - 1][x];
1070                 place_inner_grid(c_ptr);
1071                 c_ptr = &cave[y2 + 1][x];
1072                 place_inner_grid(c_ptr);
1073         }
1074
1075
1076         /* Inner room variations */
1077         switch (randint1(5))
1078         {
1079                 /* Just an inner room with a monster */
1080                 case 1:
1081                 {
1082                         /* Place a secret door */
1083                         switch (randint1(4))
1084                         {
1085                                 case 1: place_secret_door(y1 - 1, xval); break;
1086                                 case 2: place_secret_door(y2 + 1, xval); break;
1087                                 case 3: place_secret_door(yval, x1 - 1); break;
1088                                 case 4: place_secret_door(yval, x2 + 1); break;
1089                         }
1090
1091                         /* Place a monster in the room */
1092                         vault_monsters(yval, xval, 1);
1093
1094                         break;
1095                 }
1096
1097                 /* Treasure Vault (with a door) */
1098                 case 2:
1099                 {
1100                         /* Place a secret door */
1101                         switch (randint1(4))
1102                         {
1103                                 case 1: place_secret_door(y1 - 1, xval); break;
1104                                 case 2: place_secret_door(y2 + 1, xval); break;
1105                                 case 3: place_secret_door(yval, x1 - 1); break;
1106                                 case 4: place_secret_door(yval, x2 + 1); break;
1107                         }
1108
1109                         /* Place another inner room */
1110                         for (y = yval - 1; y <= yval + 1; y++)
1111                         {
1112                                 for (x = xval -  1; x <= xval + 1; x++)
1113                                 {
1114                                         if ((x == xval) && (y == yval)) continue;
1115                                         c_ptr = &cave[y][x];
1116                                         place_inner_grid(c_ptr);
1117                                 }
1118                         }
1119
1120                         /* Place a locked door on the inner room */
1121                         switch (randint1(4))
1122                         {
1123                                 case 1: place_locked_door(yval - 1, xval); break;
1124                                 case 2: place_locked_door(yval + 1, xval); break;
1125                                 case 3: place_locked_door(yval, xval - 1); break;
1126                                 case 4: place_locked_door(yval, xval + 1); break;
1127                         }
1128
1129                         /* Monsters to guard the "treasure" */
1130                         vault_monsters(yval, xval, randint1(3) + 2);
1131
1132                         /* Object (80%) */
1133                         if (randint0(100) < 80)
1134                         {
1135                                 place_object(yval, xval, 0L);
1136                         }
1137
1138                         /* Stairs (20%) */
1139                         else
1140                         {
1141                                 place_random_stairs(yval, xval);
1142                         }
1143
1144                         /* Traps to protect the treasure */
1145                         vault_traps(yval, xval, 4, 10, 2 + randint1(3));
1146
1147                         break;
1148                 }
1149
1150                 /* Inner pillar(s). */
1151                 case 3:
1152                 {
1153                         /* Place a secret door */
1154                         switch (randint1(4))
1155                         {
1156                                 case 1: place_secret_door(y1 - 1, xval); break;
1157                                 case 2: place_secret_door(y2 + 1, xval); break;
1158                                 case 3: place_secret_door(yval, x1 - 1); break;
1159                                 case 4: place_secret_door(yval, x2 + 1); break;
1160                         }
1161
1162                         /* Large Inner Pillar */
1163                         for (y = yval - 1; y <= yval + 1; y++)
1164                         {
1165                                 for (x = xval - 1; x <= xval + 1; x++)
1166                                 {
1167                                 c_ptr = &cave[y][x];
1168                                 place_inner_grid(c_ptr);
1169                                 }
1170                         }
1171
1172                         /* Occasionally, two more Large Inner Pillars */
1173                         if (one_in_(2))
1174                         {
1175                                 tmp = randint1(2);
1176                                 for (y = yval - 1; y <= yval + 1; y++)
1177                                 {
1178                                         for (x = xval - 5 - tmp; x <= xval - 3 - tmp; x++)
1179                                         {
1180                                         c_ptr = &cave[y][x];
1181                                         place_inner_grid(c_ptr);
1182                                         }
1183                                         for (x = xval + 3 + tmp; x <= xval + 5 + tmp; x++)
1184                                         {
1185                                         c_ptr = &cave[y][x];
1186                                         place_inner_grid(c_ptr);
1187                                         }
1188                                 }
1189                         }
1190
1191                         /* Occasionally, some Inner rooms */
1192                         if (one_in_(3))
1193                         {
1194                                 /* Long horizontal walls */
1195                                 for (x = xval - 5; x <= xval + 5; x++)
1196                                 {
1197                                 c_ptr = &cave[yval - 1][x];
1198                                 place_inner_grid(c_ptr);
1199                                 c_ptr = &cave[yval + 1][x];
1200                                 place_inner_grid(c_ptr);
1201                                 }
1202
1203                                 /* Close off the left/right edges */
1204                                 c_ptr = &cave[yval][xval - 5];
1205                                 place_inner_grid(c_ptr);
1206                                 c_ptr = &cave[yval][xval + 5];
1207                                 place_inner_grid(c_ptr);
1208
1209                                 /* Secret doors (random top/bottom) */
1210                                 place_secret_door(yval - 3 + (randint1(2) * 2), xval - 3);
1211                                 place_secret_door(yval - 3 + (randint1(2) * 2), xval + 3);
1212
1213                                 /* Monsters */
1214                                 vault_monsters(yval, xval - 2, randint1(2));
1215                                 vault_monsters(yval, xval + 2, randint1(2));
1216
1217                                 /* Objects */
1218                                 if (one_in_(3)) place_object(yval, xval - 2, 0L);
1219                                 if (one_in_(3)) place_object(yval, xval + 2, 0L);
1220                         }
1221
1222                         break;
1223                 }
1224
1225                 /* Maze inside. */
1226                 case 4:
1227                 {
1228                         /* Place a secret door */
1229                         switch (randint1(4))
1230                         {
1231                                 case 1: place_secret_door(y1 - 1, xval); break;
1232                                 case 2: place_secret_door(y2 + 1, xval); break;
1233                                 case 3: place_secret_door(yval, x1 - 1); break;
1234                                 case 4: place_secret_door(yval, x2 + 1); break;
1235                         }
1236
1237                         /* Maze (really a checkerboard) */
1238                         for (y = y1; y <= y2; y++)
1239                         {
1240                                 for (x = x1; x <= x2; x++)
1241                                 {
1242                                         if (0x1 & (x + y))
1243                                         {
1244                                                 c_ptr = &cave[y][x];
1245                                                 place_inner_grid(c_ptr);
1246                                         }
1247                                 }
1248                         }
1249
1250                         /* Monsters just love mazes. */
1251                         vault_monsters(yval, xval - 5, randint1(3));
1252                         vault_monsters(yval, xval + 5, randint1(3));
1253
1254                         /* Traps make them entertaining. */
1255                         vault_traps(yval, xval - 3, 2, 8, randint1(3));
1256                         vault_traps(yval, xval + 3, 2, 8, randint1(3));
1257
1258                         /* Mazes should have some treasure too. */
1259                         vault_objects(yval, xval, 3);
1260
1261                         break;
1262                 }
1263
1264                 /* Four small rooms. */
1265                 case 5:
1266                 {
1267                         /* Inner "cross" */
1268                         for (y = y1; y <= y2; y++)
1269                         {
1270                                 c_ptr = &cave[y][xval];
1271                                 place_inner_grid(c_ptr);
1272                         }
1273                         for (x = x1; x <= x2; x++)
1274                         {
1275                                 c_ptr = &cave[yval][x];
1276                                 place_inner_grid(c_ptr);
1277                         }
1278
1279                         /* Doors into the rooms */
1280                         if (randint0(100) < 50)
1281                         {
1282                                 int i = randint1(10);
1283                                 place_secret_door(y1 - 1, xval - i);
1284                                 place_secret_door(y1 - 1, xval + i);
1285                                 place_secret_door(y2 + 1, xval - i);
1286                                 place_secret_door(y2 + 1, xval + i);
1287                         }
1288                         else
1289                         {
1290                                 int i = randint1(3);
1291                                 place_secret_door(yval + i, x1 - 1);
1292                                 place_secret_door(yval - i, x1 - 1);
1293                                 place_secret_door(yval + i, x2 + 1);
1294                                 place_secret_door(yval - i, x2 + 1);
1295                         }
1296
1297                         /* Treasure, centered at the center of the cross */
1298                         vault_objects(yval, xval, 2 + randint1(2));
1299
1300                         /* Gotta have some monsters. */
1301                         vault_monsters(yval + 1, xval - 4, randint1(4));
1302                         vault_monsters(yval + 1, xval + 4, randint1(4));
1303                         vault_monsters(yval - 1, xval - 4, randint1(4));
1304                         vault_monsters(yval - 1, xval + 4, randint1(4));
1305
1306                         break;
1307                 }
1308         }
1309
1310         return TRUE;
1311 }
1312
1313
1314 /*
1315  * The following functions are used to determine if the given monster
1316  * is appropriate for inclusion in a monster nest or monster pit or
1317  * the given type.
1318  *
1319  * None of the pits/nests are allowed to include "unique" monsters.
1320  */
1321
1322
1323 /*
1324  * Monster validation macro
1325  *
1326  * Line 1 -- forbid town monsters
1327  * Line 2 -- forbid uniques
1328  * Line 3 -- forbid aquatic monsters
1329  */
1330 #define vault_monster_okay(I) \
1331         (mon_hook_dungeon(I) && \
1332          !(r_info[I].flags1 & RF1_UNIQUE) && \
1333          !(r_info[I].flags7 & RF7_UNIQUE2) && \
1334          !(r_info[I].flagsr & RFR_RES_ALL) && \
1335          !(r_info[I].flags7 & RF7_AQUATIC))
1336
1337
1338 /* Race index for "monster pit (clone)" */
1339 static int vault_aux_race;
1340
1341 /* Race index for "monster pit (symbol clone)" */
1342 static char vault_aux_char;
1343
1344 /* Breath mask for "monster pit (dragon)" */
1345 static u32b vault_aux_dragon_mask4;
1346
1347
1348 /*
1349  * Helper monster selection function
1350  */
1351 static bool vault_aux_simple(int r_idx)
1352 {
1353         /* Okay */
1354         return (vault_monster_okay(r_idx));
1355 }
1356
1357
1358 /*
1359  * Helper function for "monster nest (jelly)"
1360  */
1361 static bool vault_aux_jelly(int r_idx)
1362 {
1363         monster_race *r_ptr = &r_info[r_idx];
1364
1365         /* Validate the monster */
1366         if (!vault_monster_okay(r_idx)) return (FALSE);
1367
1368         if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE);
1369
1370         /* Also decline evil jellies (like death molds and shoggoths) */
1371         if (r_ptr->flags3 & (RF3_EVIL)) return (FALSE);
1372
1373         /* Require icky thing, jelly, mold, or mushroom */
1374         if (!my_strchr("ijm,", r_ptr->d_char)) return (FALSE);
1375
1376         /* Okay */
1377         return (TRUE);
1378 }
1379
1380
1381 /*
1382  * Helper function for "monster nest (animal)"
1383  */
1384 static bool vault_aux_animal(int r_idx)
1385 {
1386         monster_race *r_ptr = &r_info[r_idx];
1387
1388         /* Validate the monster */
1389         if (!vault_monster_okay(r_idx)) return (FALSE);
1390
1391         /* Require "animal" flag */
1392         if (!(r_ptr->flags3 & (RF3_ANIMAL))) return (FALSE);
1393
1394         /* Okay */
1395         return (TRUE);
1396 }
1397
1398
1399 /*
1400  * Helper function for "monster nest (undead)"
1401  */
1402 static bool vault_aux_undead(int r_idx)
1403 {
1404         monster_race *r_ptr = &r_info[r_idx];
1405
1406         /* Validate the monster */
1407         if (!vault_monster_okay(r_idx)) return (FALSE);
1408
1409         /* Require Undead */
1410         if (!(r_ptr->flags3 & (RF3_UNDEAD))) return (FALSE);
1411
1412         /* Okay */
1413         return (TRUE);
1414 }
1415
1416
1417 /*
1418  * Helper function for "monster nest (chapel)"
1419  */
1420 static bool vault_aux_chapel_g(int r_idx)
1421 {
1422         static int chapel_list[] = {
1423                 MON_NOV_PRIEST, MON_NOV_PALADIN, MON_NOV_PRIEST_G, MON_NOV_PALADIN_G,
1424                 MON_PRIEST, MON_JADE_MONK, MON_IVORY_MONK, MON_ULTRA_PALADIN,
1425                 MON_EBONY_MONK, MON_W_KNIGHT, MON_KNI_TEMPLAR, MON_PALADIN,
1426                 MON_TOPAZ_MONK, 0};
1427
1428         int i;
1429
1430         monster_race *r_ptr = &r_info[r_idx];
1431
1432         /* Validate the monster */
1433         if (!vault_monster_okay(r_idx)) return (FALSE);
1434
1435         if (r_ptr->flags3 & (RF3_EVIL)) return (FALSE);
1436         if ((r_idx == MON_A_GOLD) || (r_idx == MON_A_SILVER)) return (FALSE);
1437
1438         /* Require "priest" or Angel */
1439
1440         if (r_ptr->d_char == 'A') return TRUE;
1441
1442         for (i = 0; chapel_list[i]; i++)
1443                 if (r_idx == chapel_list[i]) return TRUE;
1444
1445         return FALSE;
1446 }
1447
1448
1449 /*
1450  * Helper function for "monster nest (kennel)"
1451  */
1452 static bool vault_aux_kennel(int r_idx)
1453 {
1454         monster_race *r_ptr = &r_info[r_idx];
1455
1456         /* Validate the monster */
1457         if (!vault_monster_okay(r_idx)) return (FALSE);
1458
1459         /* Require a Zephyr Hound or a dog */
1460         if (!my_strchr("CZ", r_ptr->d_char)) return (FALSE);
1461
1462         /* Okay */
1463         return (TRUE);
1464 }
1465
1466
1467 /*
1468  * Helper function for "monster nest (mimic)"
1469  */
1470 static bool vault_aux_mimic(int r_idx)
1471 {
1472         monster_race *r_ptr = &r_info[r_idx];
1473
1474         /* Validate the monster */
1475         if (!vault_monster_okay(r_idx)) return (FALSE);
1476
1477         /* Require mimic */
1478         if (!my_strchr("!$&(/=?[\\|", r_ptr->d_char)) return (FALSE);
1479
1480         /* Okay */
1481         return (TRUE);
1482 }
1483
1484 /*
1485  * Helper function for "monster nest (clone)"
1486  */
1487 static bool vault_aux_clone(int r_idx)
1488 {
1489         /* Validate the monster */
1490         if (!vault_monster_okay(r_idx)) return (FALSE);
1491
1492         return (r_idx == vault_aux_race);
1493 }
1494
1495
1496 /*
1497  * Helper function for "monster nest (symbol clone)"
1498  */
1499 static bool vault_aux_symbol_e(int r_idx)
1500 {
1501         monster_race *r_ptr = &r_info[r_idx];
1502
1503         /* Validate the monster */
1504         if (!vault_monster_okay(r_idx)) return (FALSE);
1505
1506         if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE);
1507
1508         if (r_ptr->flags3 & (RF3_GOOD)) return (FALSE);
1509
1510         /* Decline incorrect symbol */
1511         if (r_ptr->d_char != vault_aux_char) return (FALSE);
1512
1513         /* Okay */
1514         return (TRUE);
1515 }
1516
1517
1518 /*
1519  * Helper function for "monster nest (symbol clone)"
1520  */
1521 static bool vault_aux_symbol_g(int r_idx)
1522 {
1523         monster_race *r_ptr = &r_info[r_idx];
1524
1525         /* Validate the monster */
1526         if (!vault_monster_okay(r_idx)) return (FALSE);
1527
1528         if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE);
1529
1530         if (r_ptr->flags3 & (RF3_EVIL)) return (FALSE);
1531
1532         /* Decline incorrect symbol */
1533         if (r_ptr->d_char != vault_aux_char) return (FALSE);
1534
1535         /* Okay */
1536         return (TRUE);
1537 }
1538
1539
1540 /*
1541  * Helper function for "monster pit (orc)"
1542  */
1543 static bool vault_aux_orc(int r_idx)
1544 {
1545         monster_race *r_ptr = &r_info[r_idx];
1546
1547         /* Validate the monster */
1548         if (!vault_monster_okay(r_idx)) return (FALSE);
1549
1550         /* Require orc */
1551         if (!(r_ptr->flags3 & RF3_ORC)) return (FALSE);
1552
1553         /* Decline undead */
1554         if (r_ptr->flags3 & RF3_UNDEAD) return (FALSE);
1555
1556         /* Okay */
1557         return (TRUE);
1558 }
1559
1560
1561 /*
1562  * Helper function for "monster pit (troll)"
1563  */
1564 static bool vault_aux_troll(int r_idx)
1565 {
1566         monster_race *r_ptr = &r_info[r_idx];
1567
1568         /* Validate the monster */
1569         if (!vault_monster_okay(r_idx)) return (FALSE);
1570
1571         /* Require troll */
1572         if (!(r_ptr->flags3 & RF3_TROLL)) return (FALSE);
1573
1574         /* Decline undead */
1575         if (r_ptr->flags3 & RF3_UNDEAD) return (FALSE);
1576
1577         /* Okay */
1578         return (TRUE);
1579 }
1580
1581
1582 /*
1583  * Helper function for "monster pit (giant)"
1584  */
1585 static bool vault_aux_giant(int r_idx)
1586 {
1587         monster_race *r_ptr = &r_info[r_idx];
1588
1589         /* Validate the monster */
1590         if (!vault_monster_okay(r_idx)) return (FALSE);
1591
1592         /* Require giant */
1593         if (!(r_ptr->flags3 & RF3_GIANT)) return (FALSE);
1594
1595         if (r_ptr->flags3 & RF3_GOOD) return (FALSE);
1596
1597         /* Decline undead */
1598         if (r_ptr->flags3 & RF3_UNDEAD) return (FALSE);
1599
1600         /* Okay */
1601         return (TRUE);
1602 }
1603
1604
1605 /*
1606  * Helper function for "monster pit (dragon)"
1607  */
1608 static bool vault_aux_dragon(int r_idx)
1609 {
1610         monster_race *r_ptr = &r_info[r_idx];
1611
1612         /* Validate the monster */
1613         if (!vault_monster_okay(r_idx)) return (FALSE);
1614
1615         /* Require dragon */
1616         if (!(r_ptr->flags3 & RF3_DRAGON)) return (FALSE);
1617
1618         /* Hack -- Require correct "breath attack" */
1619         if (r_ptr->flags4 != vault_aux_dragon_mask4) return (FALSE);
1620
1621         /* Decline undead */
1622         if (r_ptr->flags3 & RF3_UNDEAD) return (FALSE);
1623
1624         /* Okay */
1625         return (TRUE);
1626 }
1627
1628
1629 /*
1630  * Helper function for "monster pit (demon)"
1631  */
1632 static bool vault_aux_demon(int r_idx)
1633 {
1634         monster_race *r_ptr = &r_info[r_idx];
1635
1636         /* Validate the monster */
1637         if (!vault_monster_okay(r_idx)) return (FALSE);
1638
1639         if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE);
1640
1641         /* Require demon */
1642         if (!(r_ptr->flags3 & RF3_DEMON)) return (FALSE);
1643
1644         /* Okay */
1645         return (TRUE);
1646 }
1647
1648
1649 /*
1650  * Helper function for "monster pit (lovecraftian)"
1651  */
1652 static bool vault_aux_cthulhu(int r_idx)
1653 {
1654         monster_race *r_ptr = &r_info[r_idx];
1655
1656         /* Validate the monster */
1657         if (!vault_monster_okay(r_idx)) return (FALSE);
1658
1659         if ((r_ptr->flags2 & RF2_KILL_BODY) && !(r_ptr->flags1 & RF1_NEVER_BLOW)) return (FALSE);
1660
1661         /* Require eldritch horror */
1662         if (!(r_ptr->flags2 & (RF2_ELDRITCH_HORROR))) return (FALSE);
1663
1664         /* Okay */
1665         return (TRUE);
1666 }
1667
1668
1669 /*
1670  * Helper function for "monster pit (clone)"
1671  */
1672 static void vault_prep_clone(void)
1673 {
1674         /* Apply the monster restriction */
1675         get_mon_num_prep(vault_aux_simple, NULL);
1676
1677         /* Pick a race to clone */
1678         vault_aux_race = get_mon_num(dun_level + 10);
1679
1680         /* Remove the monster restriction */
1681         get_mon_num_prep(NULL, NULL);
1682 }
1683
1684
1685 /*
1686  * Helper function for "monster pit (symbol clone)"
1687  */
1688 static void vault_prep_symbol(void)
1689 {
1690         int r_idx;
1691
1692         /* Apply the monster restriction */
1693         get_mon_num_prep(vault_aux_simple, NULL);
1694
1695         /* Pick a race to clone */
1696         r_idx = get_mon_num(dun_level + 10);
1697
1698         /* Remove the monster restriction */
1699         get_mon_num_prep(NULL, NULL);
1700
1701         /* Extract the symbol */
1702         vault_aux_char = r_info[r_idx].d_char;
1703 }
1704
1705
1706 /*
1707  * Helper function for "monster pit (dragon)"
1708  */
1709 static void vault_prep_dragon(void)
1710 {
1711         /* Pick dragon type */
1712         switch (randint0(6))
1713         {
1714                 /* Black */
1715                 case 0:
1716                 {
1717                         /* Restrict dragon breath type */
1718                         vault_aux_dragon_mask4 = RF4_BR_ACID;
1719
1720                         /* Done */
1721                         break;
1722                 }
1723
1724                 /* Blue */
1725                 case 1:
1726                 {
1727                         /* Restrict dragon breath type */
1728                         vault_aux_dragon_mask4 = RF4_BR_ELEC;
1729
1730                         /* Done */
1731                         break;
1732                 }
1733
1734                 /* Red */
1735                 case 2:
1736                 {
1737                         /* Restrict dragon breath type */
1738                         vault_aux_dragon_mask4 = RF4_BR_FIRE;
1739
1740                         /* Done */
1741                         break;
1742                 }
1743
1744                 /* White */
1745                 case 3:
1746                 {
1747                         /* Restrict dragon breath type */
1748                         vault_aux_dragon_mask4 = RF4_BR_COLD;
1749
1750                         /* Done */
1751                         break;
1752                 }
1753
1754                 /* Green */
1755                 case 4:
1756                 {
1757                         /* Restrict dragon breath type */
1758                         vault_aux_dragon_mask4 = RF4_BR_POIS;
1759
1760                         /* Done */
1761                         break;
1762                 }
1763
1764                 /* Multi-hued */
1765                 default:
1766                 {
1767                         /* Restrict dragon breath type */
1768                         vault_aux_dragon_mask4 = (RF4_BR_ACID | RF4_BR_ELEC |
1769                                                                                           RF4_BR_FIRE | RF4_BR_COLD |
1770                                                                                           RF4_BR_POIS);
1771
1772                         /* Done */
1773                         break;
1774                 }
1775         }
1776 }
1777
1778
1779 /*
1780  * Helper function for "monster pit (dark elf)"
1781  */
1782 static bool vault_aux_dark_elf(int r_idx)
1783 {
1784         int i;
1785         static int dark_elf_list[] =
1786         {
1787                 MON_D_ELF, MON_D_ELF_MAGE, MON_D_ELF_WARRIOR, MON_D_ELF_PRIEST,
1788                 MON_D_ELF_LORD, MON_D_ELF_WARLOCK, MON_D_ELF_DRUID, MON_NIGHTBLADE,
1789                 MON_D_ELF_SORC, MON_D_ELF_SHADE, 0,
1790         };
1791
1792         /* Validate the monster */
1793         if (!vault_monster_okay(r_idx)) return FALSE;
1794
1795         /* Require dark elves */
1796         for (i = 0; dark_elf_list[i]; i++)
1797                 if (r_idx == dark_elf_list[i]) return TRUE;
1798
1799         /* Assume not */
1800         return FALSE;
1801 }
1802
1803
1804 typedef struct vault_aux_type vault_aux_type;
1805
1806
1807 struct vault_aux_type
1808 {
1809         cptr name;
1810         bool (*hook_func)(int r_idx);
1811         void (*prep_func)(void);
1812         int level;
1813         int chance;
1814 };
1815
1816
1817 static int pick_vault_type(vault_aux_type *l_ptr, s16b allow_flag_mask)
1818 {
1819         int tmp, total, count;
1820
1821         vault_aux_type *n_ptr;
1822
1823         /* Calculate the total possibilities */
1824         for (n_ptr = l_ptr, total = 0, count = 0; TRUE; n_ptr++, count++)
1825         {
1826                 /* Note end */
1827                 if (!n_ptr->name) break;
1828
1829                 /* Ignore excessive depth */
1830                 if (n_ptr->level > dun_level) continue;
1831
1832                 /* Not matched with pit/nest flag */
1833                 if (!(allow_flag_mask & (1L << count))) continue;
1834
1835                 /* Count this possibility */
1836                 total += n_ptr->chance * MAX_DEPTH / (MIN(dun_level, MAX_DEPTH - 1) - n_ptr->level + 5);
1837         }
1838
1839         /* Pick a random type */
1840         tmp = randint0(total);
1841
1842         /* Find this type */
1843         for (n_ptr = l_ptr, total = 0, count = 0; TRUE; n_ptr++, count++)
1844         {
1845                 /* Note end */
1846                 if (!n_ptr->name) break;
1847
1848                 /* Ignore excessive depth */
1849                 if (n_ptr->level > dun_level) continue;
1850
1851                 /* Not matched with pit/nest flag */
1852                 if (!(allow_flag_mask & (1L << count))) continue;
1853
1854                 /* Count this possibility */
1855                 total += n_ptr->chance * MAX_DEPTH / (MIN(dun_level, MAX_DEPTH - 1) - n_ptr->level + 5);
1856
1857                 /* Found the type */
1858                 if (tmp < total) break;
1859         }
1860
1861         return n_ptr->name ? count : -1;
1862 }
1863
1864 static vault_aux_type nest_types[] =
1865 {
1866 #ifdef JP
1867         {"¥¯¥í¡¼¥ó",     vault_aux_clone,    vault_prep_clone,   5, 3},
1868         {"¥¼¥ê¡¼",       vault_aux_jelly,    NULL,               5, 6},
1869         {"¥·¥ó¥Ü¥ë(Á±)", vault_aux_symbol_g, vault_prep_symbol, 25, 2},
1870         {"¥·¥ó¥Ü¥ë(°)", vault_aux_symbol_e, vault_prep_symbol, 25, 2},
1871         {"¥ß¥ß¥Ã¥¯",     vault_aux_mimic,    NULL,              30, 4},
1872         {"¶¸µ¤",         vault_aux_cthulhu,  NULL,              70, 2},
1873         {"¸¤¾®²°",       vault_aux_kennel,   NULL,              45, 4},
1874         {"Æ°Êª±à",       vault_aux_animal,   NULL,              35, 5},
1875         {"¶µ²ñ",         vault_aux_chapel_g, NULL,              75, 4},
1876         {"¥¢¥ó¥Ç¥Ã¥É",   vault_aux_undead,   NULL,              75, 5},
1877         {NULL,           NULL,               NULL,               0, 0},
1878 #else
1879         {"clone",        vault_aux_clone,    vault_prep_clone,   5, 3},
1880         {"jelly",        vault_aux_jelly,    NULL,               5, 6},
1881         {"symbol good",  vault_aux_symbol_g, vault_prep_symbol, 25, 2},
1882         {"symbol evil",  vault_aux_symbol_e, vault_prep_symbol, 25, 2},
1883         {"mimic",        vault_aux_mimic,    NULL,              30, 4},
1884         {"lovecraftian", vault_aux_cthulhu,  NULL,              70, 2},
1885         {"kennel",       vault_aux_kennel,   NULL,              45, 4},
1886         {"animal",       vault_aux_animal,   NULL,              35, 5},
1887         {"chapel",       vault_aux_chapel_g, NULL,              75, 4},
1888         {"undead",       vault_aux_undead,   NULL,              75, 5},
1889         {NULL,           NULL,               NULL,               0, 0},
1890 #endif
1891 };
1892
1893 static vault_aux_type pit_types[] =
1894 {
1895 #ifdef JP
1896         {"¥ª¡¼¥¯",       vault_aux_orc,      NULL,               5, 6},
1897         {"¥È¥í¥ë",       vault_aux_troll,    NULL,              20, 6},
1898         {"¥¸¥ã¥¤¥¢¥ó¥È", vault_aux_giant,    NULL,              50, 6},
1899         {"¶¸µ¤",         vault_aux_cthulhu,  NULL,              80, 2},
1900         {"¥·¥ó¥Ü¥ë(Á±)", vault_aux_symbol_g, vault_prep_symbol, 70, 1},
1901         {"¥·¥ó¥Ü¥ë(°)", vault_aux_symbol_e, vault_prep_symbol, 70, 1},
1902         {"¶µ²ñ",         vault_aux_chapel_g, NULL,              65, 2},
1903         {"¥É¥é¥´¥ó",     vault_aux_dragon,   vault_prep_dragon, 70, 6},
1904         {"¥Ç¡¼¥â¥ó",     vault_aux_demon,    NULL,              80, 6},
1905         {"¥À¡¼¥¯¥¨¥ë¥Õ", vault_aux_dark_elf, NULL,              45, 4},
1906         {NULL,           NULL,               NULL,               0, 0},
1907 #else
1908         {"orc",          vault_aux_orc,      NULL,               5, 6},
1909         {"troll",        vault_aux_troll,    NULL,              20, 6},
1910         {"giant",        vault_aux_giant,    NULL,              50, 6},
1911         {"lovecraftian", vault_aux_cthulhu,  NULL,              80, 2},
1912         {"symbol good",  vault_aux_symbol_g, vault_prep_symbol, 70, 1},
1913         {"symbol evil",  vault_aux_symbol_e, vault_prep_symbol, 70, 1},
1914         {"chapel",       vault_aux_chapel_g, NULL,              65, 2},
1915         {"dragon",       vault_aux_dragon,   vault_prep_dragon, 70, 6},
1916         {"demon",        vault_aux_demon,    NULL,              80, 6},
1917         {"dark elf",     vault_aux_dark_elf, NULL,              45, 4},
1918         {NULL,           NULL,               NULL,               0, 0},
1919 #endif
1920 };
1921
1922
1923 /* Nest types code */
1924 #define NEST_TYPE_CLONE        0
1925 #define NEST_TYPE_JELLY        1
1926 #define NEST_TYPE_SYMBOL_GOOD  2
1927 #define NEST_TYPE_SYMBOL_EVIL  3
1928 #define NEST_TYPE_MIMIC        4
1929 #define NEST_TYPE_LOVECRAFTIAN 5
1930 #define NEST_TYPE_KENNEL       6
1931 #define NEST_TYPE_ANIMAL       7
1932 #define NEST_TYPE_CHAPEL       8
1933 #define NEST_TYPE_UNDEAD       9
1934
1935 /* Pit types code */
1936 #define PIT_TYPE_ORC           0
1937 #define PIT_TYPE_TROLL         1
1938 #define PIT_TYPE_GIANT         2
1939 #define PIT_TYPE_LOVECRAFTIAN  3
1940 #define PIT_TYPE_SYMBOL_GOOD   4
1941 #define PIT_TYPE_SYMBOL_EVIL   5
1942 #define PIT_TYPE_CHAPEL        6
1943 #define PIT_TYPE_DRAGON        7
1944 #define PIT_TYPE_DEMON         8
1945 #define PIT_TYPE_DARK_ELF      9
1946
1947
1948 /*
1949  * Hack -- Get the string describing subtype of pit/nest
1950  * Determined in prepare function (some pit/nest only)
1951  */
1952 static cptr pit_subtype_string(int type, bool nest)
1953 {
1954         static char inner_buf[256] = "";
1955
1956         inner_buf[0] = '\0'; /* Init string */
1957
1958         if (nest) /* Nests */
1959         {
1960                 switch (type)
1961                 {
1962                 case NEST_TYPE_CLONE:
1963                         sprintf(inner_buf, "(%s)", r_name + r_info[vault_aux_race].name);
1964                         break;
1965                 case NEST_TYPE_SYMBOL_GOOD:
1966                 case NEST_TYPE_SYMBOL_EVIL:
1967                         sprintf(inner_buf, "(%c)", vault_aux_char);
1968                         break;
1969                 }
1970         }
1971         else /* Pits */
1972         {
1973                 switch (type)
1974                 {
1975                 case PIT_TYPE_SYMBOL_GOOD:
1976                 case PIT_TYPE_SYMBOL_EVIL:
1977                         sprintf(inner_buf, "(%c)", vault_aux_char);
1978                         break;
1979                 case PIT_TYPE_DRAGON:
1980                         switch (vault_aux_dragon_mask4)
1981                         {
1982 #ifdef JP
1983                         case RF4_BR_ACID: strcpy(inner_buf, "(»À)");   break;
1984                         case RF4_BR_ELEC: strcpy(inner_buf, "(°ðºÊ)"); break;
1985                         case RF4_BR_FIRE: strcpy(inner_buf, "(²Ð±ê)"); break;
1986                         case RF4_BR_COLD: strcpy(inner_buf, "(Îäµ¤)"); break;
1987                         case RF4_BR_POIS: strcpy(inner_buf, "(ÆÇ)");   break;
1988                         case (RF4_BR_ACID | RF4_BR_ELEC | RF4_BR_FIRE | RF4_BR_COLD | RF4_BR_POIS):
1989                                 strcpy(inner_buf, "(Ëü¿§)"); break;
1990                         default: strcpy(inner_buf, "(Ì¤ÄêµÁ)"); break;
1991 #else
1992                         case RF4_BR_ACID: strcpy(inner_buf, "(acid)");      break;
1993                         case RF4_BR_ELEC: strcpy(inner_buf, "(lightning)"); break;
1994                         case RF4_BR_FIRE: strcpy(inner_buf, "(fire)");      break;
1995                         case RF4_BR_COLD: strcpy(inner_buf, "(frost)");     break;
1996                         case RF4_BR_POIS: strcpy(inner_buf, "(poison)");    break;
1997                         case (RF4_BR_ACID | RF4_BR_ELEC | RF4_BR_FIRE | RF4_BR_COLD | RF4_BR_POIS):
1998                                 strcpy(inner_buf, "(multi-hued)"); break;
1999                         default: strcpy(inner_buf, "(undefined)"); break;
2000 #endif
2001                         }
2002                         break;
2003                 }
2004         }
2005
2006         return inner_buf;
2007 }
2008
2009
2010 /* A struct for nest monster information with cheat_hear */
2011 typedef struct
2012 {
2013         s16b r_idx;
2014         bool used;
2015 }
2016 nest_mon_info_type;
2017
2018
2019 /*
2020  * Comp function for sorting nest monster information
2021  */
2022 static bool ang_sort_comp_nest_mon_info(vptr u, vptr v, int a, int b)
2023 {
2024         nest_mon_info_type *nest_mon_info = (nest_mon_info_type *)u;
2025         int w1 = nest_mon_info[a].r_idx;
2026         int w2 = nest_mon_info[b].r_idx;
2027         monster_race *r1_ptr = &r_info[w1];
2028         monster_race *r2_ptr = &r_info[w2];
2029         int z1, z2;
2030
2031         /* Unused */
2032         (void)v;
2033
2034         /* Extract used info */
2035         z1 = nest_mon_info[a].used;
2036         z2 = nest_mon_info[b].used;
2037
2038         /* Compare used status */
2039         if (z1 < z2) return FALSE;
2040         if (z1 > z2) return TRUE;
2041
2042         /* Compare levels */
2043         if (r1_ptr->level < r2_ptr->level) return TRUE;
2044         if (r1_ptr->level > r2_ptr->level) return FALSE;
2045
2046         /* Compare experience */
2047         if (r1_ptr->mexp < r2_ptr->mexp) return TRUE;
2048         if (r1_ptr->mexp > r2_ptr->mexp) return FALSE;
2049
2050         /* Compare indexes */
2051         return w1 <= w2;
2052 }
2053
2054
2055 /*
2056  * Swap function for sorting nest monster information
2057  */
2058 static void ang_sort_swap_nest_mon_info(vptr u, vptr v, int a, int b)
2059 {
2060         nest_mon_info_type *nest_mon_info = (nest_mon_info_type *)u;
2061         nest_mon_info_type holder;
2062
2063         /* Unused */
2064         (void)v;
2065
2066         /* Swap */
2067         holder = nest_mon_info[a];
2068         nest_mon_info[a] = nest_mon_info[b];
2069         nest_mon_info[b] = holder;
2070 }
2071
2072
2073 #define NUM_NEST_MON_TYPE 64
2074
2075 /*
2076  * Type 5 -- Monster nests
2077  *
2078  * A monster nest is a "big" room, with an "inner" room, containing
2079  * a "collection" of monsters of a given type strewn about the room.
2080  *
2081  * The monsters are chosen from a set of 64 randomly selected monster
2082  * races, to allow the nest creation to fail instead of having "holes".
2083  *
2084  * Note the use of the "get_mon_num_prep()" function, and the special
2085  * "get_mon_num_hook()" restriction function, to prepare the "monster
2086  * allocation table" in such a way as to optimize the selection of
2087  * "appropriate" non-unique monsters for the nest.
2088  *
2089  * Note that the "get_mon_num()" function may (rarely) fail, in which
2090  * case the nest will be empty, and will not affect the level rating.
2091  *
2092  * Note that "monster nests" will never contain "unique" monsters.
2093  */
2094 static bool build_type5(void)
2095 {
2096         int y, x, y1, x1, y2, x2, xval, yval;
2097         int i;
2098         nest_mon_info_type nest_mon_info[NUM_NEST_MON_TYPE];
2099
2100         monster_type align;
2101
2102         cave_type *c_ptr;
2103
2104         int cur_nest_type = pick_vault_type(nest_types, d_info[dungeon_type].nest);
2105         vault_aux_type *n_ptr;
2106
2107         /* No type available */
2108         if (cur_nest_type < 0) return FALSE;
2109
2110         n_ptr = &nest_types[cur_nest_type];
2111
2112         /* Process a preparation function if necessary */
2113         if (n_ptr->prep_func) (*(n_ptr->prep_func))();
2114
2115         /* Prepare allocation table */
2116         get_mon_num_prep(n_ptr->hook_func, NULL);
2117
2118         align.sub_align = SUB_ALIGN_NEUTRAL;
2119
2120         /* Pick some monster types */
2121         for (i = 0; i < NUM_NEST_MON_TYPE; i++)
2122         {
2123                 int r_idx = 0, attempts = 100;
2124                 monster_race *r_ptr = NULL;
2125
2126                 while (attempts--)
2127                 {
2128                         /* Get a (hard) monster type */
2129                         r_idx = get_mon_num(dun_level + 11);
2130                         r_ptr = &r_info[r_idx];
2131
2132                         /* Decline incorrect alignment */
2133                         if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue;
2134
2135                         /* Accept this monster */
2136                         break;
2137                 }
2138
2139                 /* Notice failure */
2140                 if (!r_idx || !attempts) return FALSE;
2141
2142                 /* Note the alignment */
2143                 if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL;
2144                 if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD;
2145
2146                 nest_mon_info[i].r_idx = r_idx;
2147                 nest_mon_info[i].used = FALSE;
2148         }
2149
2150         /* Find and reserve some space in the dungeon.  Get center of room. */
2151         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
2152
2153         /* Large room */
2154         y1 = yval - 4;
2155         y2 = yval + 4;
2156         x1 = xval - 11;
2157         x2 = xval + 11;
2158
2159         /* Place the floor area */
2160         for (y = y1 - 1; y <= y2 + 1; y++)
2161         {
2162                 for (x = x1 - 1; x <= x2 + 1; x++)
2163                 {
2164                         c_ptr = &cave[y][x];
2165                         place_floor_grid(c_ptr);
2166                         c_ptr->info |= (CAVE_ROOM);
2167                 }
2168         }
2169
2170         /* Place the outer walls */
2171         for (y = y1 - 1; y <= y2 + 1; y++)
2172         {
2173                 c_ptr = &cave[y][x1 - 1];
2174                 place_outer_grid(c_ptr);
2175                 c_ptr = &cave[y][x2 + 1];
2176                 place_outer_grid(c_ptr);
2177         }
2178         for (x = x1 - 1; x <= x2 + 1; x++)
2179         {
2180                 c_ptr = &cave[y1 - 1][x];
2181                 place_outer_grid(c_ptr);
2182                 c_ptr = &cave[y2 + 1][x];
2183                 place_outer_grid(c_ptr);
2184         }
2185
2186
2187         /* Advance to the center room */
2188         y1 = y1 + 2;
2189         y2 = y2 - 2;
2190         x1 = x1 + 2;
2191         x2 = x2 - 2;
2192
2193         /* The inner walls */
2194         for (y = y1 - 1; y <= y2 + 1; y++)
2195         {
2196                 c_ptr = &cave[y][x1 - 1];
2197                 place_inner_grid(c_ptr);
2198                 c_ptr = &cave[y][x2 + 1];
2199                 place_inner_grid(c_ptr);
2200         }
2201
2202         for (x = x1 - 1; x <= x2 + 1; x++)
2203         {
2204                 c_ptr = &cave[y1 - 1][x];
2205                 place_inner_grid(c_ptr);
2206                 c_ptr = &cave[y2 + 1][x];
2207                 place_inner_grid(c_ptr);
2208         }
2209         for (y = y1; y <= y2; y++)
2210         {
2211                 for (x = x1; x <= x2; x++)
2212                 {
2213                         add_cave_info(y, x, CAVE_ICKY);
2214                 }
2215         }
2216
2217         /* Place a secret door */
2218         switch (randint1(4))
2219         {
2220                 case 1: place_secret_door(y1 - 1, xval); break;
2221                 case 2: place_secret_door(y2 + 1, xval); break;
2222                 case 3: place_secret_door(yval, x1 - 1); break;
2223                 case 4: place_secret_door(yval, x2 + 1); break;
2224         }
2225
2226         /* Describe */
2227         if (cheat_room)
2228         {
2229                 /* Room type */
2230 #ifdef JP
2231                 msg_format("¥â¥ó¥¹¥¿¡¼Éô²°(nest)(%s%s)", n_ptr->name, pit_subtype_string(cur_nest_type, TRUE));
2232 #else
2233                 msg_format("Monster nest (%s%s)", n_ptr->name, pit_subtype_string(cur_nest_type, TRUE));
2234 #endif
2235         }
2236
2237         /* Increase the level rating */
2238         rating += 10;
2239
2240         /* (Sometimes) Cause a "special feeling" (for "Monster Nests") */
2241         if ((dun_level <= 40) && (randint1(dun_level * dun_level + 50) < 300))
2242         {
2243                 good_item_flag = TRUE;
2244         }
2245
2246         /* Place some monsters */
2247         for (y = yval - 2; y <= yval + 2; y++)
2248         {
2249                 for (x = xval - 9; x <= xval + 9; x++)
2250                 {
2251                         int r_idx;
2252
2253                         i = randint0(NUM_NEST_MON_TYPE);
2254                         r_idx = nest_mon_info[i].r_idx;
2255
2256                         /* Place that "random" monster (no groups) */
2257                         (void)place_monster_aux(0, y, x, r_idx, 0L);
2258
2259                         nest_mon_info[i].used = TRUE;
2260                 }
2261         }
2262
2263         if (cheat_room && cheat_hear)
2264         {
2265                 ang_sort_comp = ang_sort_comp_nest_mon_info;
2266                 ang_sort_swap = ang_sort_swap_nest_mon_info;
2267                 ang_sort(nest_mon_info, NULL, NUM_NEST_MON_TYPE);
2268
2269                 /* Dump the entries (prevent multi-printing) */
2270                 for (i = 0; i < NUM_NEST_MON_TYPE; i++)
2271                 {
2272                         if (!nest_mon_info[i].used) break;
2273                         for (; i < NUM_NEST_MON_TYPE - 1; i++)
2274                         {
2275                                 if (nest_mon_info[i].r_idx != nest_mon_info[i + 1].r_idx) break;
2276                                 if (!nest_mon_info[i + 1].used) break;
2277                         }
2278                         msg_print(r_name + r_info[nest_mon_info[i].r_idx].name);
2279                 }
2280         }
2281
2282         return TRUE;
2283 }
2284
2285
2286 /*
2287  * Type 6 -- Monster pits
2288  *
2289  * A monster pit is a "big" room, with an "inner" room, containing
2290  * a "collection" of monsters of a given type organized in the room.
2291  *
2292  * The inside room in a monster pit appears as shown below, where the
2293  * actual monsters in each location depend on the type of the pit
2294  *
2295  *   #####################
2296  *   #0000000000000000000#
2297  *   #0112233455543322110#
2298  *   #0112233467643322110#
2299  *   #0112233455543322110#
2300  *   #0000000000000000000#
2301  *   #####################
2302  *
2303  * Note that the monsters in the pit are now chosen by using "get_mon_num()"
2304  * to request 16 "appropriate" monsters, sorting them by level, and using
2305  * the "even" entries in this sorted list for the contents of the pit.
2306  *
2307  * Hack -- all of the "dragons" in a "dragon" pit must be the same "color",
2308  * which is handled by requiring a specific "breath" attack for all of the
2309  * dragons.  This may include "multi-hued" breath.  Note that "wyrms" may
2310  * be present in many of the dragon pits, if they have the proper breath.
2311  *
2312  * Note the use of the "get_mon_num_prep()" function, and the special
2313  * "get_mon_num_hook()" restriction function, to prepare the "monster
2314  * allocation table" in such a way as to optimize the selection of
2315  * "appropriate" non-unique monsters for the pit.
2316  *
2317  * Note that the "get_mon_num()" function may (rarely) fail, in which case
2318  * the pit will be empty, and will not effect the level rating.
2319  *
2320  * Note that "monster pits" will never contain "unique" monsters.
2321  */
2322 static bool build_type6(void)
2323 {
2324         int y, x, y1, x1, y2, x2, xval, yval;
2325         int i, j;
2326
2327         int what[16];
2328
2329         monster_type align;
2330
2331         cave_type *c_ptr;
2332
2333         int cur_pit_type = pick_vault_type(pit_types, d_info[dungeon_type].pit);
2334         vault_aux_type *n_ptr;
2335
2336         /* No type available */
2337         if (cur_pit_type < 0) return FALSE;
2338
2339         n_ptr = &pit_types[cur_pit_type];
2340
2341         /* Process a preparation function if necessary */
2342         if (n_ptr->prep_func) (*(n_ptr->prep_func))();
2343
2344         /* Prepare allocation table */
2345         get_mon_num_prep(n_ptr->hook_func, NULL);
2346
2347         align.sub_align = SUB_ALIGN_NEUTRAL;
2348
2349         /* Pick some monster types */
2350         for (i = 0; i < 16; i++)
2351         {
2352                 int r_idx = 0, attempts = 100;
2353                 monster_race *r_ptr = NULL;
2354
2355                 while (attempts--)
2356                 {
2357                         /* Get a (hard) monster type */
2358                         r_idx = get_mon_num(dun_level + 11);
2359                         r_ptr = &r_info[r_idx];
2360
2361                         /* Decline incorrect alignment */
2362                         if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue;
2363
2364                         /* Accept this monster */
2365                         break;
2366                 }
2367
2368                 /* Notice failure */
2369                 if (!r_idx || !attempts) return FALSE;
2370
2371                 /* Note the alignment */
2372                 if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL;
2373                 if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD;
2374
2375                 what[i] = r_idx;
2376         }
2377
2378         /* Find and reserve some space in the dungeon.  Get center of room. */
2379         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
2380
2381         /* Large room */
2382         y1 = yval - 4;
2383         y2 = yval + 4;
2384         x1 = xval - 11;
2385         x2 = xval + 11;
2386
2387         /* Place the floor area */
2388         for (y = y1 - 1; y <= y2 + 1; y++)
2389         {
2390                 for (x = x1 - 1; x <= x2 + 1; x++)
2391                 {
2392                         c_ptr = &cave[y][x];
2393                         place_floor_grid(c_ptr);
2394                         c_ptr->info |= (CAVE_ROOM);
2395                 }
2396         }
2397
2398         /* Place the outer walls */
2399         for (y = y1 - 1; y <= y2 + 1; y++)
2400         {
2401                 c_ptr = &cave[y][x1 - 1];
2402                 place_outer_grid(c_ptr);
2403                 c_ptr = &cave[y][x2 + 1];
2404                 place_outer_grid(c_ptr);
2405         }
2406         for (x = x1 - 1; x <= x2 + 1; x++)
2407         {
2408                 c_ptr = &cave[y1 - 1][x];
2409                 place_outer_grid(c_ptr);
2410                 c_ptr = &cave[y2 + 1][x];
2411                 place_outer_grid(c_ptr);
2412         }
2413
2414         /* Advance to the center room */
2415         y1 = y1 + 2;
2416         y2 = y2 - 2;
2417         x1 = x1 + 2;
2418         x2 = x2 - 2;
2419
2420         /* The inner walls */
2421         for (y = y1 - 1; y <= y2 + 1; y++)
2422         {
2423                 c_ptr = &cave[y][x1 - 1];
2424                 place_inner_grid(c_ptr);
2425                 c_ptr = &cave[y][x2 + 1];
2426                 place_inner_grid(c_ptr);
2427         }
2428         for (x = x1 - 1; x <= x2 + 1; x++)
2429         {
2430                 c_ptr = &cave[y1 - 1][x];
2431                 place_inner_grid(c_ptr);
2432                 c_ptr = &cave[y2 + 1][x];
2433                 place_inner_grid(c_ptr);
2434         }
2435         for (y = y1; y <= y2; y++)
2436         {
2437                 for (x = x1; x <= x2; x++)
2438                 {
2439                         add_cave_info(y, x, CAVE_ICKY);
2440                 }
2441         }
2442
2443         /* Place a secret door */
2444         switch (randint1(4))
2445         {
2446                 case 1: place_secret_door(y1 - 1, xval); break;
2447                 case 2: place_secret_door(y2 + 1, xval); break;
2448                 case 3: place_secret_door(yval, x1 - 1); break;
2449                 case 4: place_secret_door(yval, x2 + 1); break;
2450         }
2451
2452         /* Sort the entries */
2453         for (i = 0; i < 16 - 1; i++)
2454         {
2455                 /* Sort the entries */
2456                 for (j = 0; j < 16 - 1; j++)
2457                 {
2458                         int i1 = j;
2459                         int i2 = j + 1;
2460
2461                         int p1 = r_info[what[i1]].level;
2462                         int p2 = r_info[what[i2]].level;
2463
2464                         /* Bubble */
2465                         if (p1 > p2)
2466                         {
2467                                 int tmp = what[i1];
2468                                 what[i1] = what[i2];
2469                                 what[i2] = tmp;
2470                         }
2471                 }
2472         }
2473
2474         /* Message */
2475         if (cheat_room)
2476         {
2477                 /* Room type */
2478 #ifdef JP
2479                 msg_format("¥â¥ó¥¹¥¿¡¼Éô²°(pit)(%s%s)", n_ptr->name, pit_subtype_string(cur_pit_type, FALSE));
2480 #else
2481                 msg_format("Monster pit (%s%s)", n_ptr->name, pit_subtype_string(cur_pit_type, FALSE));
2482 #endif
2483         }
2484
2485         /* Select the entries */
2486         for (i = 0; i < 8; i++)
2487         {
2488                 /* Every other entry */
2489                 what[i] = what[i * 2];
2490
2491                 if (cheat_hear)
2492                 {
2493                         /* Message */
2494                         msg_print(r_name + r_info[what[i]].name);
2495                 }
2496         }
2497
2498         /* Increase the level rating */
2499         rating += 10;
2500
2501         /* (Sometimes) Cause a "special feeling" (for "Monster Pits") */
2502         if ((dun_level <= 40) && (randint1(dun_level * dun_level + 50) < 300))
2503         {
2504                 good_item_flag = TRUE;
2505         }
2506
2507         /* Top and bottom rows */
2508         for (x = xval - 9; x <= xval + 9; x++)
2509         {
2510                 place_monster_aux(0, yval - 2, x, what[0], PM_NO_KAGE);
2511                 place_monster_aux(0, yval + 2, x, what[0], PM_NO_KAGE);
2512         }
2513
2514         /* Middle columns */
2515         for (y = yval - 1; y <= yval + 1; y++)
2516         {
2517                 place_monster_aux(0, y, xval - 9, what[0], PM_NO_KAGE);
2518                 place_monster_aux(0, y, xval + 9, what[0], PM_NO_KAGE);
2519
2520                 place_monster_aux(0, y, xval - 8, what[1], PM_NO_KAGE);
2521                 place_monster_aux(0, y, xval + 8, what[1], PM_NO_KAGE);
2522
2523                 place_monster_aux(0, y, xval - 7, what[1], PM_NO_KAGE);
2524                 place_monster_aux(0, y, xval + 7, what[1], PM_NO_KAGE);
2525
2526                 place_monster_aux(0, y, xval - 6, what[2], PM_NO_KAGE);
2527                 place_monster_aux(0, y, xval + 6, what[2], PM_NO_KAGE);
2528
2529                 place_monster_aux(0, y, xval - 5, what[2], PM_NO_KAGE);
2530                 place_monster_aux(0, y, xval + 5, what[2], PM_NO_KAGE);
2531
2532                 place_monster_aux(0, y, xval - 4, what[3], PM_NO_KAGE);
2533                 place_monster_aux(0, y, xval + 4, what[3], PM_NO_KAGE);
2534
2535                 place_monster_aux(0, y, xval - 3, what[3], PM_NO_KAGE);
2536                 place_monster_aux(0, y, xval + 3, what[3], PM_NO_KAGE);
2537
2538                 place_monster_aux(0, y, xval - 2, what[4], PM_NO_KAGE);
2539                 place_monster_aux(0, y, xval + 2, what[4], PM_NO_KAGE);
2540         }
2541
2542         /* Above/Below the center monster */
2543         for (x = xval - 1; x <= xval + 1; x++)
2544         {
2545                 place_monster_aux(0, yval + 1, x, what[5], PM_NO_KAGE);
2546                 place_monster_aux(0, yval - 1, x, what[5], PM_NO_KAGE);
2547         }
2548
2549         /* Next to the center monster */
2550         place_monster_aux(0, yval, xval + 1, what[6], PM_NO_KAGE);
2551         place_monster_aux(0, yval, xval - 1, what[6], PM_NO_KAGE);
2552
2553         /* Center monster */
2554         place_monster_aux(0, yval, xval, what[7], PM_NO_KAGE);
2555
2556         return TRUE;
2557 }
2558
2559
2560 /* coordinate translation code */
2561 static void coord_trans(int *x, int *y, int xoffset, int yoffset, int transno)
2562 {
2563         int i;
2564         int temp;
2565
2566         /*
2567          * transno specifies what transformation is required. (0-7)
2568          * The lower two bits indicate by how much the vault is rotated,
2569          * and the upper bit indicates a reflection.
2570          * This is done by using rotation matrices... however since
2571          * these are mostly zeros for rotations by 90 degrees this can
2572          * be expressed simply in terms of swapping and inverting the
2573          * x and y coordinates.
2574          */
2575         for (i = 0; i < transno % 4; i++)
2576         {
2577                 /* rotate by 90 degrees */
2578                 temp = *x;
2579                 *x = -(*y);
2580                 *y = temp;
2581         }
2582
2583         if (transno / 4)
2584         {
2585                 /* Reflect depending on status of 3rd bit. */
2586                 *x = -(*x);
2587         }
2588
2589         /* Add offsets so vault stays in the first quadrant */
2590         *x += xoffset;
2591         *y += yoffset;
2592 }
2593
2594
2595 /*
2596  * Hack -- fill in "vault" rooms
2597  */
2598 static void build_vault(int yval, int xval, int ymax, int xmax, cptr data,
2599                 int xoffset, int yoffset, int transno)
2600 {
2601         int dx, dy, x, y, i, j;
2602
2603         cptr t;
2604
2605         cave_type *c_ptr;
2606
2607
2608         /* Place dungeon features and objects */
2609         for (t = data, dy = 0; dy < ymax; dy++)
2610         {
2611                 for (dx = 0; dx < xmax; dx++, t++)
2612                 {
2613                         /* prevent loop counter from being overwritten */
2614                         i = dx;
2615                         j = dy;
2616
2617                         /* Flip / rotate */
2618                         coord_trans(&i, &j, xoffset, yoffset, transno);
2619
2620                         /* Extract the location */
2621                         if (transno % 2 == 0)
2622                         {
2623                                 /* no swap of x/y */
2624                                 x = xval - (xmax / 2) + i;
2625                                 y = yval - (ymax / 2) + j;
2626                         }
2627                         else
2628                         {
2629                                 /* swap of x/y */
2630                                 x = xval - (ymax / 2) + i;
2631                                 y = yval - (xmax / 2) + j;
2632                         }
2633
2634                         /* Hack -- skip "non-grids" */
2635                         if (*t == ' ') continue;
2636
2637                         /* Access the grid */
2638                         c_ptr = &cave[y][x];
2639
2640                         /* Lay down a floor */
2641                         place_floor_grid(c_ptr);
2642
2643                         /* Remove any mimic */
2644                         c_ptr->mimic = 0;
2645
2646                         /* Part of a vault */
2647                         c_ptr->info |= (CAVE_ROOM | CAVE_ICKY);
2648
2649                         /* Analyze the grid */
2650                         switch (*t)
2651                         {
2652                                 /* Granite wall (outer) */
2653                         case '%':
2654                                 place_outer_noperm_grid(c_ptr);
2655                                 break;
2656
2657                                 /* Granite wall (inner) */
2658                         case '#':
2659                                 place_inner_grid(c_ptr);
2660                                 break;
2661
2662                                 /* Permanent wall (inner) */
2663                         case 'X':
2664                                 place_inner_perm_grid(c_ptr);
2665                                 break;
2666
2667                                 /* Treasure/trap */
2668                         case '*':
2669                                 if (randint0(100) < 75)
2670                                 {
2671                                         place_object(y, x, 0L);
2672                                 }
2673                                 else
2674                                 {
2675                                         place_trap(y, x);
2676                                 }
2677                                 break;
2678
2679                                 /* Secret doors */
2680                         case '+':
2681                                 place_secret_door(y, x);
2682                                 break;
2683
2684                                 /* Trap */
2685                         case '^':
2686                                 place_trap(y, x);
2687                                 break;
2688
2689                                 /* Black market in a dungeon */
2690                         case 'S':
2691                                 set_cave_feat(y, x, FEAT_SHOP_HEAD + STORE_BLACK);
2692                                 store_init(NO_TOWN, STORE_BLACK);
2693                                 break;
2694
2695                                 /* The Pattern */
2696                         case 'p':
2697                                 set_cave_feat(y, x, FEAT_PATTERN_START);
2698                                 break;
2699
2700                         case 'a':
2701                                 set_cave_feat(y, x, FEAT_PATTERN_1);
2702                                 break;
2703
2704                         case 'b':
2705                                 set_cave_feat(y, x, FEAT_PATTERN_2);
2706                                 break;
2707
2708                         case 'c':
2709                                 set_cave_feat(y, x, FEAT_PATTERN_3);
2710                                 break;
2711
2712                         case 'd':
2713                                 set_cave_feat(y, x, FEAT_PATTERN_4);
2714                                 break;
2715
2716                         case 'P':
2717                                 set_cave_feat(y, x, FEAT_PATTERN_END);
2718                                 break;
2719
2720                         case 'B':
2721                                 set_cave_feat(y, x, FEAT_PATTERN_XTRA1);
2722                                 break;
2723
2724                         case 'A':
2725                                 /* Reward for Pattern walk */
2726                                 object_level = base_level + 12;
2727                                 place_object(y, x, AM_GOOD | AM_GREAT);
2728                                 object_level = base_level;
2729                                 break;
2730                         }
2731                 }
2732         }
2733
2734
2735         /* Place dungeon monsters and objects */
2736         for (t = data, dy = 0; dy < ymax; dy++)
2737         {
2738                 for (dx = 0; dx < xmax; dx++, t++)
2739                 {
2740                         /* prevent loop counter from being overwritten */
2741                         i = dx;
2742                         j = dy;
2743
2744                         /* Flip / rotate */
2745                         coord_trans(&i, &j, xoffset, yoffset, transno);
2746
2747                         /* Extract the location */
2748                         if (transno % 2 == 0)
2749                         {
2750                                 /* no swap of x/y */
2751                                 x = xval - (xmax / 2) + i;
2752                                 y = yval - (ymax / 2) + j;
2753                         }
2754                         else
2755                         {
2756                                 /* swap of x/y */
2757                                 x = xval - (ymax / 2) + i;
2758                                 y = yval - (xmax / 2) + j;
2759                         }
2760
2761                         /* Hack -- skip "non-grids" */
2762                         if (*t == ' ') continue;
2763
2764                         /* Analyze the symbol */
2765                         switch (*t)
2766                         {
2767                                 /* Monster */
2768                                 case '&':
2769                                 {
2770                                         monster_level = base_level + 5;
2771                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
2772                                         monster_level = base_level;
2773                                         break;
2774                                 }
2775
2776                                 /* Meaner monster */
2777                                 case '@':
2778                                 {
2779                                         monster_level = base_level + 11;
2780                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
2781                                         monster_level = base_level;
2782                                         break;
2783                                 }
2784
2785                                 /* Meaner monster, plus treasure */
2786                                 case '9':
2787                                 {
2788                                         monster_level = base_level + 9;
2789                                         place_monster(y, x, PM_ALLOW_SLEEP);
2790                                         monster_level = base_level;
2791                                         object_level = base_level + 7;
2792                                         place_object(y, x, AM_GOOD);
2793                                         object_level = base_level;
2794                                         break;
2795                                 }
2796
2797                                 /* Nasty monster and treasure */
2798                                 case '8':
2799                                 {
2800                                         monster_level = base_level + 40;
2801                                         place_monster(y, x, PM_ALLOW_SLEEP);
2802                                         monster_level = base_level;
2803                                         object_level = base_level + 20;
2804                                         place_object(y, x, AM_GOOD | AM_GREAT);
2805                                         object_level = base_level;
2806                                         break;
2807                                 }
2808
2809                                 /* Monster and/or object */
2810                                 case ',':
2811                                 {
2812                                         if (randint0(100) < 50)
2813                                         {
2814                                                 monster_level = base_level + 3;
2815                                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
2816                                                 monster_level = base_level;
2817                                         }
2818                                         if (randint0(100) < 50)
2819                                         {
2820                                                 object_level = base_level + 7;
2821                                                 place_object(y, x, 0L);
2822                                                 object_level = base_level;
2823                                         }
2824                                         break;
2825                                 }
2826
2827                         }
2828                 }
2829         }
2830 }
2831
2832
2833 /*
2834  * Type 7 -- simple vaults (see "v_info.txt")
2835  */
2836 static bool build_type7(void)
2837 {
2838         vault_type *v_ptr;
2839         int dummy;
2840         int x, y;
2841         int xval, yval;
2842         int xoffset, yoffset;
2843         int transno;
2844
2845         /* Pick a lesser vault */
2846         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)
2847         {
2848                 /* Access a random vault record */
2849                 v_ptr = &v_info[randint0(max_v_idx)];
2850
2851                 /* Accept the first lesser vault */
2852                 if (v_ptr->typ == 7) break;
2853         }
2854
2855         /* No lesser vault found */
2856         if (dummy >= SAFE_MAX_ATTEMPTS)
2857         {
2858                 if (cheat_room)
2859                 {
2860 #ifdef JP
2861                         msg_print("·Ù¹ð¡ª¾®¤µ¤ÊÃÏ²¼¼¼¤òÇÛÃÖ¤Ç¤¤Þ¤»¤ó¡ª");
2862 #else
2863                         msg_print("Warning! Could not place lesser vault!");
2864 #endif
2865                 }
2866                 return FALSE;
2867         }
2868
2869         /* pick type of transformation (0-7) */
2870         transno = randint0(8);
2871
2872         /* calculate offsets */
2873         x = v_ptr->wid;
2874         y = v_ptr->hgt;
2875
2876         /* Some huge vault cannot be ratated to fit in the dungeon */
2877         if (x+2 > cur_hgt-2)
2878         {
2879                 /* Forbid 90 or 270 degree ratation */
2880                 transno &= ~1;
2881         }
2882
2883         coord_trans(&x, &y, 0, 0, transno);
2884
2885         if (x < 0)
2886         {
2887                 xoffset = -x - 1;
2888         }
2889         else
2890         {
2891                 xoffset = 0;
2892         }
2893
2894         if (y < 0)
2895         {
2896                 yoffset = -y - 1;
2897         }
2898         else
2899         {
2900                 yoffset = 0;
2901         }
2902
2903         /* Find and reserve some space in the dungeon.  Get center of room. */
2904         if (!find_space(&yval, &xval, abs(y), abs(x))) return FALSE;
2905
2906 #ifdef FORCE_V_IDX
2907         v_ptr = &v_info[2];
2908 #endif
2909
2910         /* Message */
2911 #ifdef JP
2912         if (cheat_room) msg_format("¾®¤µ¤ÊÃÏ²¼¼¼(%s)", v_name + v_ptr->name);
2913 #else
2914         if (cheat_room) msg_format("Lesser vault (%s)", v_name + v_ptr->name);
2915 #endif
2916
2917         /* Boost the rating */
2918         rating += v_ptr->rat;
2919
2920         /* (Sometimes) Cause a special feeling */
2921         if ((dun_level <= 50) ||
2922                 (randint1((dun_level - 40) * (dun_level - 40) + 50) < 400))
2923         {
2924                 good_item_flag = TRUE;
2925         }
2926
2927         /* Hack -- Build the vault */
2928         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,
2929                     v_text + v_ptr->text, xoffset, yoffset, transno);
2930
2931         return TRUE;
2932 }
2933
2934
2935 /*
2936  * Type 8 -- greater vaults (see "v_info.txt")
2937  */
2938 static bool build_type8(void)
2939 {
2940         vault_type *v_ptr;
2941         int dummy;
2942         int xval, yval;
2943         int x, y;
2944         int transno;
2945         int xoffset, yoffset;
2946
2947         /* Pick a greater vault */
2948         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)
2949         {
2950                 /* Access a random vault record */
2951                 v_ptr = &v_info[randint0(max_v_idx)];
2952
2953                 /* Accept the first greater vault */
2954                 if (v_ptr->typ == 8) break;
2955         }
2956
2957         /* No greater vault found */
2958         if (dummy >= SAFE_MAX_ATTEMPTS)
2959         {
2960                 if (cheat_room)
2961                 {
2962 #ifdef JP
2963                         msg_print("·Ù¹ð¡ªµðÂç¤ÊÃÏ²¼¼¼¤òÇÛÃÖ¤Ç¤¤Þ¤»¤ó¡ª");
2964 #else
2965                         msg_print("Warning! Could not place greater vault!");
2966 #endif
2967                 }
2968                 return FALSE;
2969         }
2970
2971         /* pick type of transformation (0-7) */
2972         transno = randint0(8);
2973
2974         /* calculate offsets */
2975         x = v_ptr->wid;
2976         y = v_ptr->hgt;
2977
2978         /* Some huge vault cannot be ratated to fit in the dungeon */
2979         if (x+2 > cur_hgt-2)
2980         {
2981                 /* Forbid 90 or 270 degree ratation */
2982                 transno &= ~1;
2983         }
2984
2985         coord_trans(&x, &y, 0, 0, transno);
2986
2987         if (x < 0)
2988         {
2989                 xoffset = - x - 1;
2990         }
2991         else
2992         {
2993                 xoffset = 0;
2994         }
2995
2996         if (y < 0)
2997         {
2998                 yoffset = - y - 1;
2999         }
3000         else
3001         {
3002                 yoffset = 0;
3003         }
3004
3005         /*
3006          * Try to allocate space for room.  If fails, exit
3007          *
3008          * Hack -- Prepare a bit larger space (+2, +2) to
3009          * prevent generation of vaults with no-entrance.
3010          */
3011         /* Find and reserve some space in the dungeon.  Get center of room. */
3012         if (!find_space(&yval, &xval, abs(y) + 2, abs(x) + 2)) return FALSE;
3013
3014 #ifdef FORCE_V_IDX
3015         v_ptr = &v_info[76 + randint1(3)];
3016 #endif
3017
3018         /* Message */
3019 #ifdef JP
3020         if (cheat_room) msg_format("µðÂç¤ÊÃÏ²¼¼¼(%s)", v_name + v_ptr->name);
3021 #else
3022         if (cheat_room) msg_format("Greater vault (%s)", v_name + v_ptr->name);
3023 #endif
3024
3025         /* Boost the rating */
3026         rating += v_ptr->rat;
3027
3028         /* (Sometimes) Cause a special feeling */
3029         if ((dun_level <= 50) ||
3030             (randint1((dun_level - 40) * (dun_level - 40) + 50) < 400))
3031         {
3032                 good_item_flag = TRUE;
3033         }
3034
3035         /* Hack -- Build the vault */
3036         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,
3037                     v_text + v_ptr->text, xoffset, yoffset, transno);
3038
3039         return TRUE;
3040 }
3041
3042 /*
3043  * Structure to hold all "fill" data
3044  */
3045
3046 typedef struct fill_data_type fill_data_type;
3047
3048 struct fill_data_type
3049 {
3050         /* area size */
3051         int xmin;
3052         int ymin;
3053         int xmax;
3054         int ymax;
3055
3056         /* cutoffs */
3057         int c1;
3058         int c2;
3059         int c3;
3060
3061         /* features to fill with */
3062         int feat1;
3063         int feat2;
3064         int feat3;
3065
3066         int info1;
3067         int info2;
3068         int info3;
3069
3070         /* number of filled squares */
3071         int amount;
3072 };
3073
3074 static fill_data_type fill_data;
3075
3076
3077 /* Store routine for the fractal cave generator */
3078 /* this routine probably should be an inline function or a macro. */
3079 static void store_height(int x, int y, int val)
3080 {
3081         /* if on boundary set val > cutoff so walls are not as square */
3082         if (((x == fill_data.xmin) || (y == fill_data.ymin) ||
3083              (x == fill_data.xmax) || (y == fill_data.ymax)) &&
3084             (val <= fill_data.c1)) val = fill_data.c1 + 1;
3085
3086         /* store the value in height-map format */
3087         cave[y][x].feat = val;
3088
3089         return;
3090 }
3091
3092
3093 /*
3094 * Explanation of the plasma fractal algorithm:
3095 *
3096 * A grid of points is created with the properties of a 'height-map'
3097 * This is done by making the corners of the grid have a random value.
3098 * The grid is then subdivided into one with twice the resolution.
3099 * The new points midway between two 'known' points can be calculated
3100 * by taking the average value of the 'known' ones and randomly adding
3101 * or subtracting an amount proportional to the distance between those
3102 * points.  The final 'middle' points of the grid are then calculated
3103 * by averaging all four of the originally 'known' corner points.  An
3104 * random amount is added or subtracted from this to get a value of the
3105 * height at that point.  The scaling factor here is adjusted to the
3106 * slightly larger distance diagonally as compared to orthogonally.
3107 *
3108 * This is then repeated recursively to fill an entire 'height-map'
3109 * A rectangular map is done the same way, except there are different
3110 * scaling factors along the x and y directions.
3111 *
3112 * A hack to change the amount of correlation between points is done using
3113 * the grd variable.  If the current step size is greater than grd then
3114 * the point will be random, otherwise it will be calculated by the
3115 * above algorithm.  This makes a maximum distance at which two points on
3116 * the height map can affect each other.
3117 *
3118 * How fractal caves are made:
3119 *
3120 * When the map is complete, a cut-off value is used to create a cave.
3121 * Heights below this value are "floor", and heights above are "wall".
3122 * This also can be used to create lakes, by adding more height levels
3123 * representing shallow and deep water/ lava etc.
3124 *
3125 * The grd variable affects the width of passages.
3126 * The roug variable affects the roughness of those passages
3127 *
3128 * The tricky part is making sure the created cave is connected.  This
3129 * is done by 'filling' from the inside and only keeping the 'filled'
3130 * floor.  Walls bounding the 'filled' floor are also kept.  Everything
3131 * else is converted to the normal _extra_.
3132  */
3133
3134
3135 /*
3136  *  Note that this uses the cave.feat array in a very hackish way
3137  *  the values are first set to zero, and then each array location
3138  *  is used as a "heightmap"
3139  *  The heightmap then needs to be converted back into the "feat" format.
3140  *
3141  *  grd=level at which fractal turns on.  smaller gives more mazelike caves
3142  *  roug=roughness level.  16=normal.  higher values make things more convoluted
3143  *    small values are good for smooth walls.
3144  *  size=length of the side of the square cave system.
3145  */
3146 static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, int cutoff)
3147 {
3148         int xhsize, yhsize, xsize, ysize, maxsize;
3149
3150         /*
3151          * fixed point variables- these are stored as 256 x normal value
3152          * this gives 8 binary places of fractional part + 8 places of normal part
3153          */
3154
3155         u16b xstep, xhstep, ystep, yhstep;
3156         u16b xstep2, xhstep2, ystep2, yhstep2;
3157         u16b i, j, ii, jj, diagsize, xxsize, yysize;
3158
3159         /* Cache for speed */
3160         u16b xm, xp, ym, yp;
3161
3162         /* redefine size so can change the value if out of range */
3163         xsize = xsiz;
3164         ysize = ysiz;
3165
3166         /* Paranoia about size of the system of caves */
3167         if (xsize > 254) xsize = 254;
3168         if (xsize < 4) xsize = 4;
3169         if (ysize > 254) ysize = 254;
3170         if (ysize < 4) ysize = 4;
3171
3172         /* get offsets to middle of array */
3173         xhsize = xsize / 2;
3174         yhsize = ysize / 2;
3175
3176         /* fix rounding problem */
3177         xsize = xhsize * 2;
3178         ysize = yhsize * 2;
3179
3180         /* get limits of region */
3181         fill_data.xmin = x0 - xhsize;
3182         fill_data.ymin = y0 - yhsize;
3183         fill_data.xmax = x0 + xhsize;
3184         fill_data.ymax = y0 + yhsize;
3185
3186         /* Store cutoff in global for quick access */
3187         fill_data.c1 = cutoff;
3188
3189         /*
3190         * Scale factor for middle points:
3191         * About sqrt(2) * 256 - correct for a square lattice
3192         * approximately correct for everything else.
3193          */
3194         diagsize = 362;
3195
3196         /* maximum of xsize and ysize */
3197         maxsize = (xsize > ysize) ? xsize : ysize;
3198
3199         /* Clear the section */
3200         for (i = 0; i <= xsize; i++)
3201         {
3202                 for (j = 0; j <= ysize; j++)
3203                 {
3204                         /* -1 is a flag for "not done yet" */
3205                         cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].feat = -1;
3206                         /* Clear icky flag because may be redoing the cave */
3207                         cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].info &= ~(CAVE_ICKY);
3208                 }
3209         }
3210
3211         /* Boundaries are walls */
3212         cave[fill_data.ymin][fill_data.xmin].feat = maxsize;
3213         cave[fill_data.ymax][fill_data.xmin].feat = maxsize;
3214         cave[fill_data.ymin][fill_data.xmax].feat = maxsize;
3215         cave[fill_data.ymax][fill_data.xmax].feat = maxsize;
3216
3217         /* Set the middle square to be an open area. */
3218         cave[y0][x0].feat = 0;
3219
3220         /* Initialize the step sizes */
3221         xstep = xhstep = xsize * 256;
3222         ystep = yhstep = ysize * 256;
3223         xxsize = xsize * 256;
3224         yysize = ysize * 256;
3225
3226         /*
3227          * Fill in the rectangle with fractal height data -
3228          * like the 'plasma fractal' in fractint.
3229          */
3230         while ((xhstep > 256) || (yhstep > 256))
3231         {
3232                 /* Halve the step sizes */
3233                 xstep = xhstep;
3234                 xhstep /= 2;
3235                 ystep = yhstep;
3236                 yhstep /= 2;
3237
3238                 /* cache well used values */
3239                 xstep2 = xstep / 256;
3240                 ystep2 = ystep / 256;
3241
3242                 xhstep2 = xhstep / 256;
3243                 yhstep2 = yhstep / 256;
3244
3245                 /* middle top to bottom. */
3246                 for (i = xhstep; i <= xxsize - xhstep; i += xstep)
3247                 {
3248                         for (j = 0; j <= yysize; j += ystep)
3249                         {
3250                                 /* cache often used values */
3251                                 ii = i / 256 + fill_data.xmin;
3252                                 jj = j / 256 + fill_data.ymin;
3253
3254                                 /* Test square */
3255                                 if (cave[jj][ii].feat == -1)
3256                                 {
3257                                         if (xhstep2 > grd)
3258                                         {
3259                                                 /* If greater than 'grid' level then is random */
3260                                                 store_height(ii, jj, randint1(maxsize));
3261                                         }
3262                                         else
3263                                         {
3264                                                 /* Average of left and right points +random bit */
3265                                                 store_height(ii, jj,
3266                                                         (cave[jj][fill_data.xmin + (i - xhstep) / 256].feat
3267                                                          + cave[jj][fill_data.xmin + (i + xhstep) / 256].feat) / 2
3268                                                          + (randint1(xstep2) - xhstep2) * roug / 16);
3269                                         }
3270                                 }
3271                         }
3272                 }
3273
3274
3275                 /* middle left to right. */
3276                 for (j = yhstep; j <= yysize - yhstep; j += ystep)
3277                 {
3278                         for (i = 0; i <= xxsize; i += xstep)
3279                         {
3280                                 /* cache often used values */
3281                                 ii = i / 256 + fill_data.xmin;
3282                                 jj = j / 256 + fill_data.ymin;
3283
3284                                 /* Test square */
3285                                 if (cave[jj][ii].feat == -1)
3286                                 {
3287                                         if (xhstep2 > grd)
3288                                         {
3289                                                 /* If greater than 'grid' level then is random */
3290                                                 store_height(ii, jj, randint1(maxsize));
3291                                         }
3292                                         else
3293                                         {
3294                                                 /* Average of up and down points +random bit */
3295                                                 store_height(ii, jj,
3296                                                         (cave[fill_data.ymin + (j - yhstep) / 256][ii].feat
3297                                                         + cave[fill_data.ymin + (j + yhstep) / 256][ii].feat) / 2
3298                                                         + (randint1(ystep2) - yhstep2) * roug / 16);
3299                                         }
3300                                 }
3301                         }
3302                 }
3303
3304                 /* center. */
3305                 for (i = xhstep; i <= xxsize - xhstep; i += xstep)
3306                 {
3307                         for (j = yhstep; j <= yysize - yhstep; j += ystep)
3308                         {
3309                                 /* cache often used values */
3310                                 ii = i / 256 + fill_data.xmin;
3311                                 jj = j / 256 + fill_data.ymin;
3312
3313                                 /* Test square */
3314                                 if (cave[jj][ii].feat == -1)
3315                                 {
3316                                         if (xhstep2 > grd)
3317                                         {
3318                                                 /* If greater than 'grid' level then is random */
3319                                                 store_height(ii, jj, randint1(maxsize));
3320                                         }
3321                                         else
3322                                         {
3323                                                 /* Cache reused values. */
3324                                                 xm = fill_data.xmin + (i - xhstep) / 256;
3325                                                 xp = fill_data.xmin + (i + xhstep) / 256;
3326                                                 ym = fill_data.ymin + (j - yhstep) / 256;
3327                                                 yp = fill_data.ymin + (j + yhstep) / 256;
3328
3329                                                 /*
3330                                                  * Average over all four corners + scale by diagsize to
3331                                                  * reduce the effect of the square grid on the shape of the fractal
3332                                                  */
3333                                                 store_height(ii, jj,
3334                                                         (cave[ym][xm].feat + cave[yp][xm].feat
3335                                                         + cave[ym][xp].feat + cave[yp][xp].feat) / 4
3336                                                         + (randint1(xstep2) - xhstep2) * (diagsize / 16) / 256 * roug);
3337                                         }
3338                                 }
3339                         }
3340                 }
3341         }
3342 }
3343
3344
3345 static bool hack_isnt_wall(int y, int x, int c1, int c2, int c3, int feat1, int feat2, int feat3, int info1, int info2, int info3)
3346 {
3347         /*
3348          * function used to convert from height-map back to the
3349          *  normal angband cave format
3350          */
3351         if (cave[y][x].info & CAVE_ICKY)
3352         {
3353                 /* already done */
3354                 return FALSE;
3355         }
3356         else
3357         {
3358                 /* Show that have looked at this square */
3359                 cave[y][x].info|= (CAVE_ICKY);
3360
3361                 /* Use cutoffs c1-c3 to allocate regions of floor /water/ lava etc. */
3362                 if (cave[y][x].feat <= c1)
3363                 {
3364                         /* 25% of the time use the other tile : it looks better this way */
3365                         if (randint1(100) < 75)
3366                         {
3367                                 cave[y][x].feat = feat1;
3368                                 cave[y][x].info &= ~(CAVE_MASK);
3369                                 cave[y][x].info |= info1;
3370                                 return TRUE;
3371                         }
3372                         else
3373                         {
3374                                 cave[y][x].feat = feat2;
3375                                 cave[y][x].info &= ~(CAVE_MASK);
3376                                 cave[y][x].info |= info2;
3377                                 return TRUE;
3378                         }
3379                 }
3380                 else if (cave[y][x].feat <= c2)
3381                 {
3382                         /* 25% of the time use the other tile : it looks better this way */
3383                         if (randint1(100) < 75)
3384                         {
3385                                 cave[y][x].feat = feat2;
3386                                 cave[y][x].info &= ~(CAVE_MASK);
3387                                 cave[y][x].info |= info2;
3388                                 return TRUE;
3389                         }
3390                         else
3391                         {
3392                                 cave[y][x].feat = feat1;
3393                                 cave[y][x].info &= ~(CAVE_MASK);
3394                                 cave[y][x].info |= info1;
3395                                 return TRUE;
3396                         }
3397                 }
3398                 else if (cave[y][x].feat <= c3)
3399                 {
3400                         cave[y][x].feat = feat3;
3401                         cave[y][x].info |= info3;
3402                         return TRUE;
3403                 }
3404                 /* if greater than cutoff then is a wall */
3405                 else
3406                 {
3407                         place_outer_bold(y, x);
3408                         return FALSE;
3409                 }
3410         }
3411 }
3412
3413
3414
3415
3416 /*
3417  * Quick and nasty fill routine used to find the connected region
3418  * of floor in the middle of the cave
3419  */
3420 static void cave_fill(byte y, byte x)
3421 {
3422         int i, j, d;
3423         int ty, tx;
3424
3425         int flow_tail = 1;
3426         int flow_head = 0;
3427
3428
3429         /*** Start Grid ***/
3430
3431         /* Enqueue that entry */
3432         temp_y[0] = y;
3433         temp_x[0] = x;
3434
3435
3436         /* Now process the queue */
3437         while (flow_head != flow_tail)
3438         {
3439                 /* Extract the next entry */
3440                 ty = temp_y[flow_head];
3441                 tx = temp_x[flow_head];
3442
3443                 /* Forget that entry */
3444                 if (++flow_head == TEMP_MAX) flow_head = 0;
3445
3446                 /* Add the "children" */
3447                 for (d = 0; d < 8; d++)
3448                 {
3449                         int old_head = flow_tail;
3450
3451                         /* Child location */
3452                         j = ty + ddy_ddd[d];
3453                         i = tx + ddx_ddd[d];
3454
3455                         /* Paranoia Don't leave the cave */
3456                         if (!in_bounds(j, i))
3457                         {
3458                                 /* affect boundary */
3459                                 cave[j][i].info |= CAVE_ICKY;
3460 /*                              return; */
3461                         }
3462
3463                         /* If within bounds */
3464                         else if ((i > fill_data.xmin) && (i < fill_data.xmax)
3465                                 && (j > fill_data.ymin) && (j < fill_data.ymax))
3466                         {
3467                                 /* If not a wall or floor done before */
3468                                 if (hack_isnt_wall(j, i,
3469                                         fill_data.c1, fill_data.c2, fill_data.c3,
3470                                         fill_data.feat1, fill_data.feat2, fill_data.feat3,
3471                                         fill_data.info1, fill_data.info2, fill_data.info3))
3472                                 {
3473                                         /* Enqueue that entry */
3474                                         temp_y[flow_tail] = j;
3475                                         temp_x[flow_tail] = i;
3476
3477                                         /* Advance the queue */
3478                                         if (++flow_tail == TEMP_MAX) flow_tail = 0;
3479
3480                                         /* Hack -- Overflow by forgetting new entry */
3481                                         if (flow_tail == flow_head)
3482                                         {
3483                                                 flow_tail = old_head;
3484                                         }
3485                                         else
3486                                         {
3487                                                 /* keep tally of size of cave system */
3488                                                 (fill_data.amount)++;
3489                                         }
3490                                 }
3491                         }
3492                         else
3493                         {
3494                                 /* affect boundary */
3495                                 cave[j][i].info |= CAVE_ICKY;
3496                         }
3497                 }
3498         }
3499 }
3500
3501
3502 static bool generate_fracave(int y0, int x0, int xsize, int ysize, int cutoff, bool light, bool room)
3503 {
3504         int x, y, i, xhsize, yhsize;
3505
3506         /* offsets to middle from corner */
3507         xhsize = xsize / 2;
3508         yhsize = ysize / 2;
3509
3510
3511         /*
3512          * select region connected to center of cave system
3513          * this gets rid of alot of isolated one-sqaures that
3514          * can make teleport traps instadeaths...
3515          */
3516
3517         /* cutoffs */
3518         fill_data.c1 = cutoff;
3519         fill_data.c2 = 0;
3520         fill_data.c3 = 0;
3521
3522         /* features to fill with */
3523         fill_data.feat1 = floor_type[randint0(100)];
3524         fill_data.feat2 = floor_type[randint0(100)];
3525         fill_data.feat3 = floor_type[randint0(100)];
3526
3527         fill_data.info1 = CAVE_FLOOR;
3528         fill_data.info2 = CAVE_FLOOR;
3529         fill_data.info3 = CAVE_FLOOR;
3530
3531         /* number of filled squares */
3532         fill_data.amount = 0;
3533
3534         cave_fill((byte)y0, (byte)x0);
3535
3536         /* if tally too small, try again */
3537         if (fill_data.amount < 10)
3538         {
3539                 /* too small - clear area and try again later */
3540                 for (x = 0; x <= xsize; ++x)
3541                 {
3542                         for (y = 0; y <= ysize; ++y)
3543                         {
3544                                 place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3545                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
3546                         }
3547                 }
3548                 return FALSE;
3549         }
3550
3551         /*
3552          * Do boundarys-check to see if they are next to a filled region
3553          * If not then they are set to normal granite
3554          * If so then they are marked as room walls.
3555          */
3556         for (i = 0; i <= xsize; ++i)
3557         {
3558                 /* top boundary */
3559                 if ((cave[0 + y0 - yhsize][i + x0 - xhsize].info & CAVE_ICKY) && (room))
3560                 {
3561                         /* Next to a 'filled' region? - set to be room walls */
3562                         place_outer_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3563                         if (light) cave[y0 + 0 - yhsize][x0 + i - xhsize].info |= (CAVE_GLOW);
3564                         cave[y0 + 0 - yhsize][x0 + i - xhsize].info |= (CAVE_ROOM);
3565                         place_outer_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3566                 }
3567                 else
3568                 {
3569                         /* set to be normal granite */
3570                         place_extra_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3571                 }
3572
3573                 /* bottom boundary */
3574                 if ((cave[ysize + y0 - yhsize][i + x0 - xhsize].info & CAVE_ICKY) && (room))
3575                 {
3576                         /* Next to a 'filled' region? - set to be room walls */
3577                         place_outer_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3578                         if (light) cave[y0 + ysize - yhsize][x0 + i - xhsize].info|=(CAVE_GLOW);
3579                         cave[y0 + ysize - yhsize][x0 + i - xhsize].info|=(CAVE_ROOM);
3580                         place_outer_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3581                 }
3582                 else
3583                 {
3584                         /* set to be normal granite */
3585                         place_extra_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3586                 }
3587
3588                 /* clear the icky flag-don't need it any more */
3589                 cave[y0 + 0 - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
3590                 cave[y0 + ysize - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
3591         }
3592
3593         /* Do the left and right boundaries minus the corners (done above) */
3594         for (i = 1; i < ysize; ++i)
3595         {
3596                 /* left boundary */
3597                 if ((cave[i + y0 - yhsize][0 + x0 - xhsize].info & CAVE_ICKY) && room)
3598                 {
3599                         /* room boundary */
3600                         place_outer_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3601                         if (light) cave[y0 + i - yhsize][x0 + 0 - xhsize].info |= (CAVE_GLOW);
3602                         cave[y0 + i - yhsize][x0 + 0 - xhsize].info |= (CAVE_ROOM);
3603                         place_outer_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3604                 }
3605                 else
3606                 {
3607                         /* outside room */
3608                         place_extra_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3609                 }
3610                 /* right boundary */
3611                 if ((cave[i + y0 - yhsize][xsize + x0 - xhsize].info & CAVE_ICKY) && room)
3612                 {
3613                         /* room boundary */
3614                         place_outer_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3615                         if (light) cave[y0 + i - yhsize][x0 + xsize - xhsize].info |= (CAVE_GLOW);
3616                         cave[y0 + i - yhsize][x0 + xsize - xhsize].info |= (CAVE_ROOM);
3617                         place_outer_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3618                 }
3619                 else
3620                 {
3621                         /* outside room */
3622                         place_extra_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3623                 }
3624
3625                 /* clear icky flag -done with it */
3626                 cave[y0 + i - yhsize][x0 + 0 - xhsize].info &= ~(CAVE_ICKY);
3627                 cave[y0 + i - yhsize][x0 + xsize - xhsize].info &= ~(CAVE_ICKY);
3628         }
3629
3630
3631         /* Do the rest: convert back to the normal format */
3632         for (x = 1; x < xsize; ++x)
3633         {
3634                 for (y = 1; y < ysize; ++y)
3635                 {
3636                         if (is_floor_bold(y0 + y - yhsize, x0 + x - xhsize) &&
3637                             (cave[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY))
3638                         {
3639                                 /* Clear the icky flag in the filled region */
3640                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~CAVE_ICKY;
3641
3642                                 /* Set appropriate flags */
3643                                 if (light) cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_GLOW);
3644                                 if (room) cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_ROOM);
3645                         }
3646                         else if (is_outer_bold(y0 + y - yhsize, x0 + x - xhsize) &&
3647                                  (cave[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY))
3648                         {
3649                                 /* Walls */
3650                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY);
3651                                 if (light) cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_GLOW);
3652                                 if (room)
3653                                 {
3654                                         cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_ROOM);
3655                                 }
3656                                 else
3657                                 {
3658
3659                                         place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3660                                         cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ROOM);
3661                                 }
3662                         }
3663                         else
3664                         {
3665                                 /* Clear the unconnected regions */
3666                                 place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3667                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
3668                         }
3669                 }
3670         }
3671
3672         /*
3673          * XXX XXX XXX There is a slight problem when tunnels pierce the caves:
3674          * Extra doors appear inside the system.  (Its not very noticeable though.)
3675          * This can be removed by "filling" from the outside in.  This allows a separation
3676          * from _outer_ with _inner_.  (Internal walls are  _outer_ instead.)
3677          * The extra effort for what seems to be only a minor thing (even non-existant if you
3678          * think of the caves not as normal rooms, but as holes in the dungeon), doesn't seem
3679          * worth it.
3680          */
3681
3682         return TRUE;
3683 }
3684
3685
3686 /*
3687  * Driver routine to create fractal cave system
3688  */
3689 static bool build_type9(void)
3690 {
3691         int grd, roug, cutoff, xsize, ysize, y0, x0;
3692
3693         bool done, light, room;
3694
3695         /* get size: note 'Evenness'*/
3696         xsize = randint1(22) * 2 + 6;
3697         ysize = randint1(15) * 2 + 6;
3698
3699         /* Find and reserve some space in the dungeon.  Get center of room. */
3700         if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) return FALSE;
3701
3702         light = done = FALSE;
3703         room = TRUE;
3704
3705         if ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
3706
3707         while (!done)
3708         {
3709                 /* Note: size must be even or there are rounding problems
3710                 * This causes the tunnels not to connect properly to the room */
3711
3712                 /* testing values for these parameters feel free to adjust */
3713                 grd = 1 << (randint0(4));
3714
3715                 /* want average of about 16 */
3716                 roug = randint1(8) * randint1(4);
3717
3718                 /* about size/2 */
3719                 cutoff = randint1(xsize / 4) + randint1(ysize / 4) +
3720                          randint1(xsize / 4) + randint1(ysize / 4);
3721
3722                 /* make it */
3723                 generate_hmap(y0, x0, xsize, ysize, grd, roug, cutoff);
3724
3725                 /* Convert to normal format + clean up */
3726                 done = generate_fracave(y0, x0, xsize, ysize, cutoff, light, room);
3727         }
3728
3729         return TRUE;
3730 }
3731
3732 #ifdef ALLOW_CAVERNS_AND_LAKES
3733 /*
3734  * Builds a cave system in the center of the dungeon.
3735  */
3736 void build_cavern(void)
3737 {
3738         int grd, roug, cutoff, xsize, ysize, x0, y0;
3739         bool done, light;
3740
3741         light = done = FALSE;
3742         if ((dun_level <= randint1(50)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
3743
3744         /* Make a cave the size of the dungeon */
3745         xsize = cur_wid - 1;
3746         ysize = cur_hgt - 1;
3747         x0 = xsize / 2;
3748         y0 = ysize / 2;
3749
3750         /* Paranoia: make size even */
3751         xsize = x0 * 2;
3752         ysize = y0 * 2;
3753
3754         while (!done)
3755         {
3756                 /* testing values for these parameters: feel free to adjust */
3757                 grd = randint1(4) + 4;
3758
3759                 /* want average of about 16 */
3760                 roug = randint1(8) * randint1(4);
3761
3762                 /* about size/2 */
3763                 cutoff = xsize / 2;
3764
3765                  /* make it */
3766                 generate_hmap(y0 + 1, x0 + 1, xsize, ysize, grd, roug, cutoff);
3767
3768                 /* Convert to normal format+ clean up */
3769                 done = generate_fracave(y0 + 1, x0 + 1, xsize, ysize, cutoff, light, FALSE);
3770         }
3771 }
3772
3773 static bool generate_lake(int y0, int x0, int xsize, int ysize, int c1, int c2, int c3, int type)
3774 {
3775         int x, y, i, xhsize, yhsize;
3776         int feat1, feat2, feat3;
3777
3778         /* offsets to middle from corner */
3779         xhsize = xsize / 2;
3780         yhsize = ysize / 2;
3781
3782         /* Get features based on type */
3783         switch (type)
3784         {
3785         case LAKE_T_LAVA: /* Lava */
3786                 feat1 = FEAT_DEEP_LAVA;
3787                 feat2 = FEAT_SHAL_LAVA;
3788                 feat3 = floor_type[randint0(100)];
3789                 break;
3790         case LAKE_T_WATER: /* Water */
3791                 feat1 = FEAT_DEEP_WATER;
3792                 feat2 = FEAT_SHAL_WATER;
3793                 feat3 = floor_type[randint0(100)];
3794                 break;
3795         case LAKE_T_CAVE: /* Collapsed cave */
3796                 feat1 = floor_type[randint0(100)];
3797                 feat2 = floor_type[randint0(100)];
3798                 feat3 = FEAT_RUBBLE;
3799                 break;
3800         case LAKE_T_EARTH_VAULT: /* Earth vault */
3801                 feat1 = FEAT_RUBBLE;
3802                 feat2 = floor_type[randint0(100)];
3803                 feat3 = FEAT_RUBBLE;
3804                 break;
3805         case LAKE_T_AIR_VAULT: /* Air vault */
3806                 feat1 = FEAT_GRASS;
3807                 feat2 = FEAT_TREES;
3808                 feat3 = FEAT_GRASS;
3809                 break;
3810         case LAKE_T_WATER_VAULT: /* Water vault */
3811                 feat1 = FEAT_SHAL_WATER;
3812                 feat2 = FEAT_DEEP_WATER;
3813                 feat3 = FEAT_SHAL_WATER;
3814                 break;
3815         case LAKE_T_FIRE_VAULT: /* Fire Vault */
3816                 feat1 = FEAT_SHAL_LAVA;
3817                 feat2 = FEAT_DEEP_LAVA;
3818                 feat3 = FEAT_SHAL_LAVA;
3819                 break;
3820
3821         /* Paranoia */
3822         default: return FALSE;
3823         }
3824
3825         /*
3826          * select region connected to center of cave system
3827          * this gets rid of alot of isolated one-sqaures that
3828          * can make teleport traps instadeaths...
3829          */
3830
3831         /* cutoffs */
3832         fill_data.c1 = c1;
3833         fill_data.c2 = c2;
3834         fill_data.c3 = c3;
3835
3836         /* features to fill with */
3837         fill_data.feat1 = feat1;
3838         fill_data.feat2 = feat2;
3839         fill_data.feat3 = feat3;
3840
3841         fill_data.info1 = 0;
3842         fill_data.info2 = 0;
3843         fill_data.info3 = 0;
3844
3845         /* number of filled squares */
3846         fill_data.amount = 0;
3847
3848         /* select region connected to center of cave system
3849         * this gets rid of alot of isolated one-sqaures that
3850         * can make teleport traps instadeaths... */
3851         cave_fill((byte)y0, (byte)x0);
3852
3853         /* if tally too small, try again */
3854         if (fill_data.amount < 10)
3855         {
3856                 /* too small -clear area and try again later */
3857                 for (x = 0; x <= xsize; ++x)
3858                 {
3859                         for (y = 0; y <= ysize; ++y)
3860                         {
3861                                 place_floor_bold(y0 + y - yhsize, x0 + x - xhsize);
3862                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY);
3863                         }
3864                 }
3865                 return FALSE;
3866         }
3867
3868         /* Do boundarys- set to normal granite */
3869         for (i = 0; i <= xsize; ++i)
3870         {
3871                 place_extra_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3872                 place_extra_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3873
3874                 /* clear the icky flag-don't need it any more */
3875                 cave[y0 + 0 - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
3876                 cave[y0 + ysize - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
3877         }
3878
3879         /* Do the left and right boundaries minus the corners (done above) */
3880
3881         for (i = 1; i < ysize; ++i)
3882         {
3883                 place_extra_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3884                 place_extra_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3885
3886                 /* clear icky flag -done with it */
3887                 cave[y0 + i - yhsize][x0 + 0 - xhsize].info &= ~(CAVE_ICKY);
3888                 cave[y0 + i - yhsize][x0 + xsize - xhsize].info &= ~(CAVE_ICKY);
3889         }
3890
3891
3892         /* Do the rest: convert back to the normal format */
3893         for (x = 1; x < xsize; ++x)
3894         {
3895                 for (y = 1; y < ysize; ++y)
3896                 {
3897                         /* Fill unconnected regions with granite */
3898                         if ((!(cave[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY)) ||
3899                                 is_outer_bold(y0 + y - yhsize, x0 + x - xhsize))
3900                                 place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3901
3902                         /* turn off icky flag (no longer needed.) */
3903                         cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
3904
3905                         /* Light lava */
3906                         if (have_flag(f_flags_bold(y0 + y - yhsize, x0 + x - xhsize), FF_LAVA))
3907                         {
3908                                 if (!(d_info[dungeon_type].flags1 & DF1_DARKNESS)) cave[y0 + y - yhsize][x0 + x - xhsize].info |= CAVE_GLOW;
3909                         }
3910                 }
3911         }
3912
3913         return TRUE;
3914 }
3915
3916
3917 /*
3918  * makes a lake/collapsed cave system in the center of the dungeon
3919  */
3920 void build_lake(int type)
3921 {
3922         int grd, roug, xsize, ysize, x0, y0;
3923         bool done = FALSE;
3924         int c1, c2, c3;
3925
3926         /* paranoia - exit if lake type out of range. */
3927         if ((type < LAKE_T_LAVA) || (type > LAKE_T_FIRE_VAULT))
3928         {
3929                 msg_format("Invalid lake type (%d)", type);
3930                 return;
3931         }
3932
3933         /* Make the size of the dungeon */
3934         xsize = cur_wid - 1;
3935         ysize = cur_hgt - 1;
3936         x0 = xsize / 2;
3937         y0 = ysize / 2;
3938
3939         /* Paranoia: make size even */
3940         xsize = x0 * 2;
3941         ysize = y0 * 2;
3942
3943         while (!done)
3944         {
3945                 /* testing values for these parameters: feel free to adjust */
3946                 grd = randint1(3) + 4;
3947
3948                 /* want average of about 16 */
3949                 roug = randint1(8) * randint1(4);
3950
3951                 /* Make up size of various componants */
3952                 /* Floor */
3953                 c3 = 3 * xsize / 4;
3954
3955                 /* Deep water/lava */
3956                 c1 = randint0(c3 / 2) + randint0(c3 / 2) - 5;
3957
3958                 /* Shallow boundary */
3959                 c2 = (c1 + c3) / 2;
3960
3961                 /* make it */
3962                 generate_hmap(y0 + 1, x0 + 1, xsize, ysize, grd, roug, c3);
3963
3964                 /* Convert to normal format+ clean up */
3965                 done = generate_lake(y0 + 1, x0 + 1, xsize, ysize, c1, c2, c3, type);
3966         }
3967 }
3968 #endif /* ALLOW_CAVERNS_AND_LAKES */
3969
3970
3971 /*
3972  * Routine used by the random vault creators to add a door to a location
3973  * Note that range checking has to be done in the calling routine.
3974  *
3975  * The doors must be INSIDE the allocated region.
3976  */
3977 static void add_door(int x, int y)
3978 {
3979         /* Need to have a wall in the center square */
3980         if (!is_outer_bold(y, x)) return;
3981
3982         /* look at:
3983          *  x#x
3984          *  .#.
3985          *  x#x
3986          *
3987          *  where x=don't care
3988          *  .=floor, #=wall
3989          */
3990
3991         if (is_floor_bold(y-1,x) && is_floor_bold(y+1,x) &&
3992             (is_outer_bold(y, x - 1) && is_outer_bold(y, x + 1)))
3993         {
3994                 /* secret door */
3995                 place_secret_door(y, x);
3996
3997                 /* set boundarys so don't get wide doors */
3998                 place_solid_bold(y, x - 1);
3999                 place_solid_bold(y, x + 1);
4000         }
4001
4002
4003         /* look at:
4004          *  x#x
4005          *  .#.
4006          *  x#x
4007          *
4008          *  where x = don't care
4009          *  .=floor, #=wall
4010          */
4011         if (is_outer_bold(y - 1, x) && is_outer_bold(y + 1, x) &&
4012             is_floor_bold(y,x-1) && is_floor_bold(y,x+1))
4013         {
4014                 /* secret door */
4015                 place_secret_door(y, x);
4016
4017                 /* set boundarys so don't get wide doors */
4018                 place_solid_bold(y - 1, x);
4019                 place_solid_bold(y + 1, x);
4020         }
4021 }
4022
4023
4024 /*
4025  * Routine that fills the empty areas of a room with treasure and monsters.
4026  */
4027 static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty)
4028 {
4029         int x, y, cx, cy, size;
4030         s32b value;
4031
4032         /* center of room:*/
4033         cx = (x1 + x2) / 2;
4034         cy = (y1 + y2) / 2;
4035
4036         /* Rough measure of size of vault= sum of lengths of sides */
4037         size = abs(x2 - x1) + abs(y2 - y1);
4038
4039         for (x = x1; x <= x2; x++)
4040         {
4041                 for (y = y1; y <= y2; y++)
4042                 {
4043                         /* Thing added based on distance to center of vault
4044                          * Difficulty is 1-easy to 10-hard */
4045                         value = ((((s32b)(distance(cx, cy, x, y))) * 100) / size) + randint1(10) - difficulty;
4046
4047                         /* hack- empty square part of the time */
4048                         if ((randint1(100) - difficulty * 3) > 50) value = 20;
4049
4050                          /* if floor, shallow water and lava */
4051                         if (is_floor_bold(y, x) ||
4052                             (have_flag(f_flags_bold(y, x), FF_PLACE) && have_flag(f_flags_bold(y, x), FF_DROP)))
4053                         {
4054                                 /* The smaller 'value' is, the better the stuff */
4055                                 if (value < 0)
4056                                 {
4057                                         /* Meanest monster + treasure */
4058                                         monster_level = base_level + 40;
4059                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4060                                         monster_level = base_level;
4061                                         object_level = base_level + 20;
4062                                         place_object(y, x, AM_GOOD);
4063                                         object_level = base_level;
4064                                 }
4065                                 else if (value < 5)
4066                                 {
4067                                         /* Mean monster +treasure */
4068                                         monster_level = base_level + 20;
4069                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4070                                         monster_level = base_level;
4071                                         object_level = base_level + 10;
4072                                         place_object(y, x, AM_GOOD);
4073                                         object_level = base_level;
4074                                 }
4075                                 else if (value < 10)
4076                                 {
4077                                         /* Monster */
4078                                         monster_level = base_level + 9;
4079                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4080                                         monster_level = base_level;
4081                                 }
4082                                 else if (value < 17)
4083                                 {
4084                                         /* Intentional Blank space */
4085
4086                                         /*
4087                                          * (Want some of the vault to be empty
4088                                          * so have room for group monsters.
4089                                          * This is used in the hack above to lower
4090                                          * the density of stuff in the vault.)
4091                                          */
4092                                 }
4093                                 else if (value < 23)
4094                                 {
4095                                         /* Object or trap */
4096                                         if (randint0(100) < 25)
4097                                         {
4098                                                 place_object(y, x, 0L);
4099                                         }
4100                                         else
4101                                         {
4102                                                 place_trap(y, x);
4103                                         }
4104                                 }
4105                                 else if (value < 30)
4106                                 {
4107                                         /* Monster and trap */
4108                                         monster_level = base_level + 5;
4109                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4110                                         monster_level = base_level;
4111                                         place_trap(y, x);
4112                                 }
4113                                 else if (value < 40)
4114                                 {
4115                                         /* Monster or object */
4116                                         if (randint0(100) < 50)
4117                                         {
4118                                                 monster_level = base_level + 3;
4119                                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4120                                                 monster_level = base_level;
4121                                         }
4122                                         if (randint0(100) < 50)
4123                                         {
4124                                                 object_level = base_level + 7;
4125                                                 place_object(y, x, 0L);
4126                                                 object_level = base_level;
4127                                         }
4128                                 }
4129                                 else if (value < 50)
4130                                 {
4131                                         /* Trap */
4132                                         place_trap(y, x);
4133                                 }
4134                                 else
4135                                 {
4136                                         /* Various Stuff */
4137
4138                                         /* 20% monster, 40% trap, 20% object, 20% blank space */
4139                                         if (randint0(100) < 20)
4140                                         {
4141                                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4142                                         }
4143                                         else if (randint0(100) < 50)
4144                                         {
4145                                                 place_trap(y, x);
4146                                         }
4147                                         else if (randint0(100) < 50)
4148                                         {
4149                                                 place_object(y, x, 0L);
4150                                         }
4151                                 }
4152
4153                         }
4154                 }
4155         }
4156 }
4157
4158
4159 /*
4160  * This function creates a random vault that looks like a collection of bubbles.
4161  * It works by getting a set of coordinates that represent the center of each
4162  * bubble.  The entire room is made by seeing which bubble center is closest. If
4163  * two centers are equidistant then the square is a wall, otherwise it is a floor.
4164  * The only exception is for squares really near a center, these are always floor.
4165  * (It looks better than without this check.)
4166  *
4167  * Note: If two centers are on the same point then this algorithm will create a
4168  *       blank bubble filled with walls. - This is prevented from happening.
4169  */
4170 static void build_bubble_vault(int x0, int y0, int xsize, int ysize)
4171 {
4172         #define BUBBLENUM 10            /* number of bubbles */
4173
4174         /* array of center points of bubbles */
4175         coord center[BUBBLENUM];
4176
4177         int i, j, x, y;
4178         u16b min1, min2, temp;
4179         bool done;
4180
4181         /* Offset from center to top left hand corner */
4182         int xhsize = xsize / 2;
4183         int yhsize = ysize / 2;
4184
4185
4186         if (cheat_room) msg_print("Bubble Vault");
4187
4188         /* Allocate center of bubbles */
4189         center[0].x = randint1(xsize - 3) + 1;
4190         center[0].y = randint1(ysize - 3) + 1;
4191
4192         for (i = 1; i < BUBBLENUM; i++)
4193         {
4194                 done = FALSE;
4195
4196                 /* get center and check to see if it is unique */
4197                 while (!done)
4198                 {
4199                         done = TRUE;
4200
4201                         x = randint1(xsize - 3) + 1;
4202                         y = randint1(ysize - 3) + 1;
4203
4204                         for (j = 0; j < i; j++)
4205                         {
4206                                 /* rough test to see if there is an overlap */
4207                                 if ((x == center[j].x) && (y == center[j].y)) done = FALSE;
4208                         }
4209                 }
4210
4211                 center[i].x = x;
4212                 center[i].y = y;
4213         }
4214
4215
4216         /* Top and bottom boundaries */
4217         for (i = 0; i < xsize; i++)
4218         {
4219                 int x = x0 - xhsize + i;
4220
4221                 place_outer_noperm_bold(y0 - yhsize + 0, x);
4222                 cave[y0 - yhsize + 0][x].info |= (CAVE_ROOM | CAVE_ICKY);
4223                 place_outer_noperm_bold(y0 - yhsize + ysize - 1, x);
4224                 cave[y0 - yhsize + ysize - 1][x].info |= (CAVE_ROOM | CAVE_ICKY);
4225         }
4226
4227         /* Left and right boundaries */
4228         for (i = 1; i < ysize - 1; i++)
4229         {
4230                 int y = y0 - yhsize + i;
4231
4232                 place_outer_noperm_bold(y, x0 - xhsize + 0);
4233                 cave[y][x0 - xhsize + 0].info |= (CAVE_ROOM | CAVE_ICKY);
4234                 place_outer_noperm_bold(y, x0 - xhsize + xsize - 1);
4235                 cave[y][x0 - xhsize + xsize - 1].info |= (CAVE_ROOM | CAVE_ICKY);
4236         }
4237
4238         /* Fill in middle with bubbles */
4239         for (x = 1; x < xsize - 1; x++)
4240         {
4241                 for (y = 1; y < ysize - 1; y++)
4242                 {
4243                         /* Get distances to two closest centers */
4244
4245                         /* initialize */
4246                         min1 = distance(x, y, center[0].x, center[0].y);
4247                         min2 = distance(x, y, center[1].x, center[1].y);
4248
4249                         if (min1 > min2)
4250                         {
4251                                 /* swap if in wrong order */
4252                                 temp = min1;
4253                                 min1 = min2;
4254                                 min2 = temp;
4255                         }
4256
4257                         /* Scan the rest */
4258                         for (i = 2; i < BUBBLENUM; i++)
4259                         {
4260                                 temp = distance(x, y, center[i].x, center[i].y);
4261
4262                                 if (temp < min1)
4263                                 {
4264                                         /* smallest */
4265                                         min2 = min1;
4266                                         min1 = temp;
4267                                 }
4268                                 else if (temp < min2)
4269                                 {
4270                                         /* second smallest */
4271                                         min2 = temp;
4272                                 }
4273                         }
4274                         if (((min2 - min1) <= 2) && (!(min1 < 3)))
4275                         {
4276                                 /* Boundary at midpoint+ not at inner region of bubble */
4277                                 place_outer_noperm_bold(y0 - yhsize + y, x0 - xhsize + x);
4278                         }
4279                         else
4280                         {
4281                                 /* middle of a bubble */
4282                                 place_floor_bold(y0 - yhsize + y, x0 - xhsize + x);
4283                         }
4284
4285                         /* clean up rest of flags */
4286                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= (CAVE_ROOM | CAVE_ICKY);
4287                 }
4288         }
4289
4290         /* Try to add some random doors */
4291         for (i = 0; i < 500; i++)
4292         {
4293                 x = randint1(xsize - 3) - xhsize + x0 + 1;
4294                 y = randint1(ysize - 3) - yhsize + y0 + 1;
4295                 add_door(x, y);
4296         }
4297
4298         /* Fill with monsters and treasure, low difficulty */
4299         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 2, y0 - yhsize + 1, y0 - yhsize + ysize - 2, randint1(5));
4300 }
4301
4302
4303 /*
4304  * Overlay a rectangular room given its bounds
4305  * This routine is used by build_room_vault
4306  * The area inside the walls is not touched:
4307  * only granite is removed- normal walls stay
4308  */
4309 static void build_room(int x1, int x2, int y1, int y2)
4310 {
4311         int x, y, i, xsize, ysize, temp;
4312
4313         /* Check if rectangle has no width */
4314         if ((x1 == x2) || (y1 == y2)) return;
4315
4316         /* initialize */
4317         if (x1 > x2)
4318         {
4319                 /* Swap boundaries if in wrong order */
4320                 temp = x1;
4321                 x1 = x2;
4322                 x2 = temp;
4323         }
4324
4325         if (y1 > y2)
4326         {
4327                 /* Swap boundaries if in wrong order */
4328                 temp = y1;
4329                 y1 = y2;
4330                 y2 = temp;
4331         }
4332
4333         /* get total widths */
4334         xsize = x2 - x1;
4335         ysize = y2 - y1;
4336
4337
4338         /* Top and bottom boundaries */
4339         for (i = 0; i <= xsize; i++)
4340         {
4341                 place_outer_noperm_bold(y1, x1 + i);
4342                 cave[y1][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
4343                 place_outer_noperm_bold(y2, x1 + i);
4344                 cave[y2][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
4345         }
4346
4347         /* Left and right boundaries */
4348         for (i = 1; i < ysize; i++)
4349         {
4350                 place_outer_noperm_bold(y1 + i, x1);
4351                 cave[y1 + i][x1].info|=(CAVE_ROOM | CAVE_ICKY);
4352                 place_outer_noperm_bold(y1 + i, x2);
4353                 cave[y1 + i][x2].info|=(CAVE_ROOM | CAVE_ICKY);
4354         }
4355
4356         /* Middle */
4357         for (x = 1; x < xsize; x++)
4358         {
4359                 for (y = 1; y < ysize; y++)
4360                 {
4361                         if (is_extra_bold(y1+y, x1+x))
4362                         {
4363                                 /* clear the untouched region */
4364                                 place_floor_bold(y1 + y, x1 + x);
4365                                 cave[y1 + y][x1 + x].info |= (CAVE_ROOM | CAVE_ICKY);
4366                         }
4367                         else
4368                         {
4369                                 /* make it a room- but don't touch */
4370                                 cave[y1 + y][x1 + x].info |= (CAVE_ROOM | CAVE_ICKY);
4371                         }
4372                 }
4373         }
4374 }
4375
4376
4377 /* Create a random vault that looks like a collection of overlapping rooms */
4378
4379 static void build_room_vault(int x0, int y0, int xsize, int ysize)
4380 {
4381         int i, x1, x2, y1, y2, xhsize, yhsize;
4382
4383         /* get offset from center */
4384         xhsize = xsize / 2;
4385         yhsize = ysize / 2;
4386
4387         if (cheat_room) msg_print("Room Vault");
4388
4389         /* fill area so don't get problems with arena levels */
4390         for (x1 = 0; x1 < xsize; x1++)
4391         {
4392                 int x = x0 - xhsize + x1;
4393
4394                 for (y1 = 0; y1 < ysize; y1++)
4395                 {
4396                         int y = y0 - yhsize + y1;
4397
4398                         place_extra_bold(y, x);
4399                         cave[y][x].info &= (~CAVE_ICKY);
4400                 }
4401         }
4402
4403         /* add ten random rooms */
4404         for (i = 0; i < 10; i++)
4405         {
4406                 x1 = randint1(xhsize) * 2 + x0 - xhsize;
4407                 x2 = randint1(xhsize) * 2 + x0 - xhsize;
4408                 y1 = randint1(yhsize) * 2 + y0 - yhsize;
4409                 y2 = randint1(yhsize) * 2 + y0 - yhsize;
4410                 build_room(x1, x2, y1, y2);
4411         }
4412
4413         /* Add some random doors */
4414         for (i = 0; i < 500; i++)
4415         {
4416                 x1 = randint1(xsize - 3) - xhsize + x0 + 1;
4417                 y1 = randint1(ysize - 3) - yhsize + y0 + 1;
4418                 add_door(x1, y1);
4419         }
4420
4421         /* Fill with monsters and treasure, high difficulty */
4422         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 2, y0 - yhsize + 1, y0 - yhsize + ysize - 2, randint1(5) + 5);
4423 }
4424
4425
4426 /* Create a random vault out of a fractal cave */
4427 static void build_cave_vault(int x0, int y0, int xsiz, int ysiz)
4428 {
4429         int grd, roug, cutoff, xhsize, yhsize, xsize, ysize, x, y;
4430         bool done, light, room;
4431
4432         /* round to make sizes even */
4433         xhsize = xsiz / 2;
4434         yhsize = ysiz / 2;
4435         xsize = xhsize * 2;
4436         ysize = yhsize * 2;
4437
4438         if (cheat_room) msg_print("Cave Vault");
4439
4440         light = done = FALSE;
4441         room = TRUE;
4442
4443         while (!done)
4444         {
4445                 /* testing values for these parameters feel free to adjust */
4446                 grd = 1 << randint0(4);
4447
4448                 /* want average of about 16 */
4449                 roug = randint1(8) * randint1(4);
4450
4451                 /* about size/2 */
4452                 cutoff = randint1(xsize / 4) + randint1(ysize / 4) +
4453                          randint1(xsize / 4) + randint1(ysize / 4);
4454
4455                 /* make it */
4456                 generate_hmap(y0, x0, xsize, ysize, grd, roug, cutoff);
4457
4458                 /* Convert to normal format+ clean up */
4459                 done = generate_fracave(y0, x0, xsize, ysize, cutoff, light, room);
4460         }
4461
4462         /* Set icky flag because is a vault */
4463         for (x = 0; x <= xsize; x++)
4464         {
4465                 for (y = 0; y <= ysize; y++)
4466                 {
4467                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= CAVE_ICKY;
4468                 }
4469         }
4470
4471         /* Fill with monsters and treasure, low difficulty */
4472         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 1, y0 - yhsize + 1, y0 - yhsize + ysize - 1, randint1(5));
4473 }
4474
4475 /*
4476  * maze vault -- rectangular labyrinthine rooms
4477  *
4478  * maze vault uses two routines:
4479  *    r_visit - a recursive routine that builds the labyrinth
4480  *    build_maze_vault - a driver routine that calls r_visit and adds
4481  *                   monsters, traps and treasure
4482  *
4483  * The labyrinth is built by creating a spanning tree of a graph.
4484  * The graph vertices are at
4485  *    (x, y) = (2j + x1, 2k + y1)   j = 0,...,m-1    k = 0,...,n-1
4486  * and the edges are the vertical and horizontal nearest neighbors.
4487  *
4488  * The spanning tree is created by performing a suitably randomized
4489  * depth-first traversal of the graph. The only adjustable parameter
4490  * is the randint0(3) below; it governs the relative density of
4491  * twists and turns in the labyrinth: smaller number, more twists.
4492  */
4493 static void r_visit(int y1, int x1, int y2, int x2,
4494                     int node, int dir, int *visited)
4495 {
4496         int i, j, m, n, temp, x, y, adj[4];
4497
4498         /* dimensions of vertex array */
4499         m = (x2 - x1) / 2 + 1;
4500         n = (y2 - y1) / 2 + 1;
4501
4502         /* mark node visited and set it to a floor */
4503         visited[node] = 1;
4504         x = 2 * (node % m) + x1;
4505         y = 2 * (node / m) + y1;
4506         place_floor_bold(y, x);
4507
4508         /* setup order of adjacent node visits */
4509         if (one_in_(3))
4510         {
4511                 /* pick a random ordering */
4512                 for (i = 0; i < 4; i++)
4513                         adj[i] = i;
4514                 for (i = 0; i < 4; i++)
4515                 {
4516                         j = randint0(4);
4517                         temp = adj[i];
4518                         adj[i] = adj[j];
4519                         adj[j] = temp;
4520                 }
4521                 dir = adj[0];
4522         }
4523         else
4524         {
4525                 /* pick a random ordering with dir first */
4526                 adj[0] = dir;
4527                 for (i = 1; i < 4; i++)
4528                         adj[i] = i;
4529                 for (i = 1; i < 4; i++)
4530                 {
4531                         j = 1 + randint0(3);
4532                         temp = adj[i];
4533                         adj[i] = adj[j];
4534                         adj[j] = temp;
4535                 }
4536         }
4537
4538         for (i = 0; i < 4; i++)
4539         {
4540                 switch (adj[i])
4541                 {
4542                         case 0:
4543                                 /* (0,+) - check for bottom boundary */
4544                                 if ((node / m < n - 1) && (visited[node + m] == 0))
4545                                 {
4546                                         place_floor_bold(y + 1, x);
4547                                         r_visit(y1, x1, y2, x2, node + m, dir, visited);
4548                                 }
4549                                 break;
4550                         case 1:
4551                                 /* (0,-) - check for top boundary */
4552                                 if ((node / m > 0) && (visited[node - m] == 0))
4553                                 {
4554                                         place_floor_bold(y - 1, x);
4555                                         r_visit(y1, x1, y2, x2, node - m, dir, visited);
4556                                 }
4557                                 break;
4558                         case 2:
4559                                 /* (+,0) - check for right boundary */
4560                                 if ((node % m < m - 1) && (visited[node + 1] == 0))
4561                                 {
4562                                         place_floor_bold(y, x + 1);
4563                                         r_visit(y1, x1, y2, x2, node + 1, dir, visited);
4564                                 }
4565                                 break;
4566                         case 3:
4567                                 /* (-,0) - check for left boundary */
4568                                 if ((node % m > 0) && (visited[node - 1] == 0))
4569                                 {
4570                                         place_floor_bold(y, x - 1);
4571                                         r_visit(y1, x1, y2, x2, node - 1, dir, visited);
4572                                 }
4573                 } /* end switch */
4574         }
4575 }
4576
4577
4578 void build_maze_vault(int x0, int y0, int xsize, int ysize, bool is_vault)
4579 {
4580         int y, x, dy, dx;
4581         int y1, x1, y2, x2;
4582         int m, n, num_vertices, *visited;
4583         bool light;
4584         cave_type *c_ptr;
4585
4586
4587         if (cheat_room && is_vault) msg_print("Maze Vault");
4588
4589         /* Choose lite or dark */
4590         light = ((dun_level <= randint1(25)) && is_vault && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
4591
4592         /* Pick a random room size - randomized by calling routine */
4593         dy = ysize / 2 - 1;
4594         dx = xsize / 2 - 1;
4595
4596         y1 = y0 - dy;
4597         x1 = x0 - dx;
4598         y2 = y0 + dy;
4599         x2 = x0 + dx;
4600
4601         /* generate the room */
4602         for (y = y1 - 1; y <= y2 + 1; y++)
4603         {
4604                 for (x = x1 - 1; x <= x2 + 1; x++)
4605                 {
4606                         c_ptr = &cave[y][x];
4607                         c_ptr->info |= CAVE_ROOM;
4608                         if (is_vault) c_ptr->info |= CAVE_ICKY;
4609                         if ((x == x1 - 1) || (x == x2 + 1) || (y == y1 - 1) || (y == y2 + 1))
4610                         {
4611                                 place_outer_grid(c_ptr);
4612                         }
4613                         else if (!is_vault)
4614                         {
4615                                 place_extra_grid(c_ptr);
4616                         }
4617                         else
4618                         {
4619                                 place_inner_grid(c_ptr);
4620                         }
4621                         if (light) c_ptr->info |= (CAVE_GLOW);
4622                 }
4623         }
4624
4625         /* dimensions of vertex array */
4626         m = dx + 1;
4627         n = dy + 1;
4628         num_vertices = m * n;
4629
4630         /* initialize array of visited vertices */
4631         C_MAKE(visited, num_vertices, int);
4632
4633         /* traverse the graph to create a spaning tree, pick a random root */
4634         r_visit(y1, x1, y2, x2, randint0(num_vertices), 0, visited);
4635
4636         /* Fill with monsters and treasure, low difficulty */
4637         if (is_vault) fill_treasure(x1, x2, y1, y2, randint1(5));
4638
4639         C_KILL(visited, num_vertices, int);
4640 }
4641
4642
4643 /* Build a "mini" checkerboard vault
4644  *
4645  * This is done by making a permanent wall maze and setting
4646  * the diagonal sqaures of the checker board to be granite.
4647  * The vault has two entrances on opposite sides to guarantee
4648  * a way to get in even if the vault abuts a side of the dungeon.
4649  */
4650 static void build_mini_c_vault(int x0, int y0, int xsize, int ysize)
4651 {
4652         int dy, dx;
4653         int y1, x1, y2, x2, y, x, total;
4654         int m, n, num_vertices;
4655         int *visited;
4656
4657         if (cheat_room) msg_print("Mini Checker Board Vault");
4658
4659         /* Pick a random room size */
4660         dy = ysize / 2 - 1;
4661         dx = xsize / 2 - 1;
4662
4663         y1 = y0 - dy;
4664         x1 = x0 - dx;
4665         y2 = y0 + dy;
4666         x2 = x0 + dx;
4667
4668
4669         /* generate the room */
4670         for (x = x1 - 2; x <= x2 + 2; x++)
4671         {
4672                 if (!in_bounds(y1-2,x)) break;
4673
4674                 cave[y1-2][x].info |= (CAVE_ROOM | CAVE_ICKY);
4675
4676                 place_outer_noperm_bold(y1-2, x);
4677         }
4678
4679         for (x = x1 - 2; x <= x2 + 2; x++)
4680         {
4681                 if (!in_bounds(y2+2,x)) break;
4682
4683                 cave[y2+2][x].info |= (CAVE_ROOM | CAVE_ICKY);
4684
4685                 place_outer_noperm_bold(y2+2, x);
4686         }
4687
4688         for (y = y1 - 2; y <= y2 + 2; y++)
4689         {
4690                 if (!in_bounds(y,x1-2)) break;
4691
4692                 cave[y][x1-2].info |= (CAVE_ROOM | CAVE_ICKY);
4693
4694                 place_outer_noperm_bold(y, x1-2);
4695         }
4696
4697         for (y = y1 - 2; y <= y2 + 2; y++)
4698         {
4699                 if (!in_bounds(y,x2+2)) break;
4700
4701                 cave[y][x2+2].info |= (CAVE_ROOM | CAVE_ICKY);
4702
4703                 place_outer_noperm_bold(y, x2+2);
4704         }
4705
4706         for (y = y1 - 1; y <= y2 + 1; y++)
4707         {
4708                 for (x = x1 - 1; x <= x2 + 1; x++)
4709                 {
4710                         cave_type *c_ptr = &cave[y][x];
4711
4712                         c_ptr->info |= (CAVE_ROOM | CAVE_ICKY);
4713
4714                         /* Permanent walls */
4715                         place_inner_perm_grid(c_ptr);
4716                 }
4717         }
4718
4719
4720         /* dimensions of vertex array */
4721         m = dx + 1;
4722         n = dy + 1;
4723         num_vertices = m * n;
4724
4725         /* initialize array of visited vertices */
4726         C_MAKE(visited, num_vertices, int);
4727
4728         /* traverse the graph to create a spannng tree, pick a random root */
4729         r_visit(y1, x1, y2, x2, randint0(num_vertices), 0, visited);
4730
4731         /* Make it look like a checker board vault */
4732         for (x = x1; x <= x2; x++)
4733         {
4734                 for (y = y1; y <= y2; y++)
4735                 {
4736                         total = x - x1 + y - y1;
4737                         /* If total is odd- and is a floor then make a wall */
4738                         if ((total % 2 == 1) && is_floor_bold(y, x))
4739                         {
4740                                 place_inner_bold(y, x);
4741                         }
4742                 }
4743         }
4744
4745         /* Make a couple of entrances */
4746         if (one_in_(2))
4747         {
4748                 /* left and right */
4749                 y = randint1(dy) + dy / 2;
4750                 place_inner_bold(y1 + y, x1 - 1);
4751                 place_inner_bold(y1 + y, x2 + 1);
4752         }
4753         else
4754         {
4755                 /* top and bottom */
4756                 x = randint1(dx) + dx / 2;
4757                 place_inner_bold(y1 - 1, x1 + x);
4758                 place_inner_bold(y2 + 1, x1 + x);
4759         }
4760
4761         /* Fill with monsters and treasure, highest difficulty */
4762         fill_treasure(x1, x2, y1, y2, 10);
4763
4764         C_KILL(visited, num_vertices, int);
4765 }
4766
4767
4768 /* Build a town/ castle by using a recursive algorithm.
4769  * Basically divide each region in a probalistic way to create
4770  * smaller regions.  When the regions get too small stop.
4771  *
4772  * The power variable is a measure of how well defended a region is.
4773  * This alters the possible choices.
4774  */
4775 static void build_recursive_room(int x1, int y1, int x2, int y2, int power)
4776 {
4777         int xsize, ysize;
4778         int x, y;
4779         int choice;
4780
4781         /* Temp variables */
4782         int t1, t2, t3, t4;
4783
4784         xsize = x2 - x1;
4785         ysize = y2 - y1;
4786
4787         if ((power < 3) && (xsize > 12) && (ysize > 12))
4788         {
4789                 /* Need outside wall +keep */
4790                 choice = 1;
4791         }
4792         else
4793         {
4794                 if (power < 10)
4795                 {
4796                         /* Make rooms + subdivide */
4797                         if ((randint1(10) > 2) && (xsize < 8) && (ysize < 8))
4798                         {
4799                                 choice = 4;
4800                         }
4801                         else
4802                         {
4803                                 choice = randint1(2) + 1;
4804                         }
4805                 }
4806                 else
4807                 {
4808                         /* Mostly subdivide */
4809                         choice = randint1(3) + 1;
4810                 }
4811         }
4812
4813         /* Based on the choice made above, do something */
4814
4815         switch (choice)
4816         {
4817                 case 1:
4818                 {
4819                         /* Outer walls */
4820
4821                         /* top and bottom */
4822                         for (x = x1; x <= x2; x++)
4823                         {
4824                                 place_outer_bold(y1, x);
4825                                 place_outer_bold(y2, x);
4826                         }
4827
4828                         /* left and right */
4829                         for (y = y1 + 1; y < y2; y++)
4830                         {
4831                                 place_outer_bold(y, x1);
4832                                 place_outer_bold(y, x2);
4833                         }
4834
4835                         /* Make a couple of entrances */
4836                         if (one_in_(2))
4837                         {
4838                                 /* left and right */
4839                                 y = randint1(ysize) + y1;
4840                                 place_floor_bold(y, x1);
4841                                 place_floor_bold(y, x2);
4842                         }
4843                         else
4844                         {
4845                                 /* top and bottom */
4846                                 x = randint1(xsize) + x1;
4847                                 place_floor_bold(y1, x);
4848                                 place_floor_bold(y2, x);
4849                         }
4850
4851                         /* Select size of keep */
4852                         t1 = randint1(ysize / 3) + y1;
4853                         t2 = y2 - randint1(ysize / 3);
4854                         t3 = randint1(xsize / 3) + x1;
4855                         t4 = x2 - randint1(xsize / 3);
4856
4857                         /* Do outside areas */
4858
4859                         /* Above and below keep */
4860                         build_recursive_room(x1 + 1, y1 + 1, x2 - 1, t1, power + 1);
4861                         build_recursive_room(x1 + 1, t2, x2 - 1, y2, power + 1);
4862
4863                         /* Left and right of keep */
4864                         build_recursive_room(x1 + 1, t1 + 1, t3, t2 - 1, power + 3);
4865                         build_recursive_room(t4, t1 + 1, x2 - 1, t2 - 1, power + 3);
4866
4867                         /* Make the keep itself: */
4868                         x1 = t3;
4869                         x2 = t4;
4870                         y1 = t1;
4871                         y2 = t2;
4872                         xsize = x2 - x1;
4873                         ysize = y2 - y1;
4874                         power += 2;
4875
4876                         /* Fall through */
4877                 }
4878                 case 4:
4879                 {
4880                         /* Try to build a room */
4881                         if ((xsize < 3) || (ysize < 3))
4882                         {
4883                                 for (y = y1; y < y2; y++)
4884                                 {
4885                                         for (x = x1; x < x2; x++)
4886                                         {
4887                                                 place_inner_bold(y, x);
4888                                         }
4889                                 }
4890
4891                                 /* Too small */
4892                                 return;
4893                         }
4894
4895                         /* Make outside walls */
4896                         /* top and bottom */
4897                         for (x = x1 + 1; x <= x2 - 1; x++)
4898                         {
4899                                 place_inner_bold(y1 + 1, x);
4900                                 place_inner_bold(y2 - 1, x);
4901                         }
4902
4903                         /* left and right */
4904                         for (y = y1 + 1; y <= y2 - 1; y++)
4905                         {
4906                                 place_inner_bold(y, x1 + 1);
4907                                 place_inner_bold(y, x2 - 1);
4908                         }
4909
4910                         /* Make a door */
4911                         y = randint1(ysize - 3) + y1 + 1;
4912
4913                         if (one_in_(2))
4914                         {
4915                                 /* left */
4916                                 place_floor_bold(y, x1 + 1);
4917                         }
4918                         else
4919                         {
4920                                 /* right */
4921                                 place_floor_bold(y, x2 - 1);
4922                         }
4923
4924                         /* Build the room */
4925                         build_recursive_room(x1 + 2, y1 + 2, x2 - 2, y2 - 2, power + 3);
4926                         break;
4927                 }
4928                 case 2:
4929                 {
4930                         /* Try and divide vertically */
4931                         if (xsize < 3)
4932                         {
4933                                 /* Too small */
4934                                 for (y = y1; y < y2; y++)
4935                                 {
4936                                         for (x = x1; x < x2; x++)
4937                                         {
4938                                                 place_inner_bold(y, x);
4939                                         }
4940                                 }
4941                                 return;
4942                         }
4943
4944                         t1 = randint1(xsize - 2) + x1 + 1;
4945                         build_recursive_room(x1, y1, t1, y2, power - 2);
4946                         build_recursive_room(t1 + 1, y1, x2, y2, power - 2);
4947                         break;
4948                 }
4949                 case 3:
4950                 {
4951                         /* Try and divide horizontally */
4952                         if (ysize < 3)
4953                         {
4954                                 /* Too small */
4955                                 for (y = y1; y < y2; y++)
4956                                 {
4957                                         for (x = x1; x < x2; x++)
4958                                         {
4959                                                 place_inner_bold(y, x);
4960                                         }
4961                                 }
4962                                 return;
4963                         }
4964
4965                         t1 = randint1(ysize - 2) + y1 + 1;
4966                         build_recursive_room(x1, y1, x2, t1, power - 2);
4967                         build_recursive_room(x1, t1 + 1, x2, y2, power - 2);
4968                         break;
4969                 }
4970         }
4971 }
4972
4973
4974 /* Build a castle */
4975
4976 /* Driver routine: clear the region and call the recursive
4977 * room routine.
4978 *
4979 *This makes a vault that looks like a castle/ city in the dungeon.
4980 */
4981 static void build_castle_vault(int x0, int y0, int xsize, int ysize)
4982 {
4983         int dy, dx;
4984         int y1, x1, y2, x2;
4985         int y, x;
4986
4987         /* Pick a random room size */
4988         dy = ysize / 2 - 1;
4989         dx = xsize / 2 - 1;
4990
4991         y1 = y0 - dy;
4992         x1 = x0 - dx;
4993         y2 = y0 + dy;
4994         x2 = x0 + dx;
4995
4996         if (cheat_room) msg_print("Castle Vault");
4997
4998         /* generate the room */
4999         for (y = y1 - 1; y <= y2 + 1; y++)
5000         {
5001                 for (x = x1 - 1; x <= x2 + 1; x++)
5002                 {
5003                         cave[y][x].info |= (CAVE_ROOM | CAVE_ICKY);
5004                         /* Make everything a floor */
5005                         place_floor_bold(y, x);
5006                 }
5007         }
5008
5009         /* Make the castle */
5010         build_recursive_room(x1, y1, x2, y2, randint1(5));
5011
5012         /* Fill with monsters and treasure, low difficulty */
5013         fill_treasure(x1, x2, y1, y2, randint1(3));
5014 }
5015
5016
5017 /*
5018  * Add outer wall to a floored region
5019  * Note: no range checking is done so must be inside dungeon
5020  * This routine also stomps on doors
5021  */
5022 static void add_outer_wall(int x, int y, int light, int x1, int y1, int x2, int y2)
5023 {
5024         cave_type *c_ptr;
5025         feature_type *f_ptr;
5026         int i, j;
5027
5028         if (!in_bounds(y, x)) return;
5029
5030         c_ptr = &cave[y][x];
5031
5032         /* hack- check to see if square has been visited before
5033         * if so, then exit (use room flag to do this) */
5034         if (c_ptr->info & CAVE_ROOM) return;
5035
5036         /* set room flag */
5037         c_ptr->info |= CAVE_ROOM;
5038
5039         f_ptr = &f_info[c_ptr->feat];
5040
5041         if (is_floor_bold(y, x))
5042         {
5043                 for (i = -1; i <= 1; i++)
5044                 {
5045                         for (j = -1; j <= 1; j++)
5046                         {
5047                                 if ((x + i >= x1) && (x + i <= x2) &&
5048                                          (y + j >= y1) && (y + j <= y2))
5049                                 {
5050                                         add_outer_wall(x + i, y + j, light, x1, y1, x2, y2);
5051                                         if (light) c_ptr->info |= CAVE_GLOW;
5052                                 }
5053                         }
5054                 }
5055         }
5056         else if (is_extra_bold(y, x))
5057         {
5058                 /* Set bounding walls */
5059                 place_outer_bold(y, x);
5060                 if (light) c_ptr->info |= CAVE_GLOW;
5061         }
5062         else if (have_flag(f_ptr->flags, FF_WALL) && have_flag(f_ptr->flags, FF_PERMANENT))
5063         {
5064                 /* Set bounding walls */
5065                 if (light) c_ptr->info |= CAVE_GLOW;
5066         }
5067 }
5068
5069
5070 /*
5071  * Hacked distance formula - gives the 'wrong' answer.
5072  * Used to build crypts
5073  */
5074 static int dist2(int x1, int y1, int x2, int y2,
5075                  int h1, int h2, int h3, int h4)
5076 {
5077         int dx, dy;
5078         dx = abs(x2 - x1);
5079         dy = abs(y2 - y1);
5080
5081         /* Basically this works by taking the normal pythagorean formula
5082          * and using an expansion to express this in a way without the
5083          * square root.  This approximate formula is then perturbed to give
5084          * the distorted results.  (I found this by making a mistake when I was
5085          * trying to fix the circular rooms.)
5086          */
5087
5088         /* h1-h4 are constants that describe the metric */
5089         if (dx >= 2 * dy) return (dx + (dy * h1) / h2);
5090         if (dy >= 2 * dx) return (dy + (dx * h1) / h2);
5091         return (((dx + dy) * 128) / 181 +
5092                 (dx * dx / (dy * h3) + dy * dy / (dx * h3)) * h4);
5093         /* 128/181 is approx. 1/sqrt(2) */
5094 }
5095
5096
5097 /*
5098  * Build target vault.
5099  * This is made by two concentric "crypts" with perpendicular
5100  * walls creating the cross-hairs.
5101  */
5102 static void build_target_vault(int x0, int y0, int xsize, int ysize)
5103 {
5104         int rad, x, y;
5105
5106         /* Make a random metric */
5107         int h1, h2, h3, h4;
5108         h1 = randint1(32) - 16;
5109         h2 = randint1(16);
5110         h3 = randint1(32);
5111         h4 = randint1(32) - 16;
5112
5113         if (cheat_room) msg_print("Target Vault");
5114
5115         /* work out outer radius */
5116         if (xsize > ysize)
5117         {
5118                 rad = ysize / 2;
5119         }
5120         else
5121         {
5122                 rad = xsize / 2;
5123         }
5124
5125         /* Make floor */
5126         for (x = x0 - rad; x <= x0 + rad; x++)
5127         {
5128                 for (y = y0 - rad; y <= y0 + rad; y++)
5129                 {
5130                         /* clear room flag */
5131                         cave[y][x].info &= ~(CAVE_ROOM);
5132
5133                         /* Vault - so is "icky" */
5134                         cave[y][x].info |= CAVE_ICKY;
5135
5136                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)
5137                         {
5138                                 /* inside- so is floor */
5139                                 place_floor_bold(y, x);
5140                         }
5141                         else
5142                         {
5143                                 /* make granite outside so arena works */
5144                                 place_extra_bold(y, x);
5145                         }
5146
5147                         /* proper boundary for arena */
5148                         if (((y + rad) == y0) || ((y - rad) == y0) ||
5149                             ((x + rad) == x0) || ((x - rad) == x0))
5150                         {
5151                                 place_extra_bold(y, x);
5152                         }
5153                 }
5154         }
5155
5156         /* Find visible outer walls and set to be FEAT_OUTER */
5157         add_outer_wall(x0, y0, FALSE, x0 - rad - 1, y0 - rad - 1,
5158                        x0 + rad + 1, y0 + rad + 1);
5159
5160         /* Add inner wall */
5161         for (x = x0 - rad / 2; x <= x0 + rad / 2; x++)
5162         {
5163                 for (y = y0 - rad / 2; y <= y0 + rad / 2; y++)
5164                 {
5165                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) == rad / 2)
5166                         {
5167                                 /* Make an internal wall */
5168                                 place_inner_bold(y, x);
5169                         }
5170                 }
5171         }
5172
5173         /* Add perpendicular walls */
5174         for (x = x0 - rad; x <= x0 + rad; x++)
5175         {
5176                 place_inner_bold(y0, x);
5177         }
5178
5179         for (y = y0 - rad; y <= y0 + rad; y++)
5180         {
5181                 place_inner_bold(y, x0);
5182         }
5183
5184         /* Make inner vault */
5185         for (y = y0 - 1; y <= y0 + 1; y++)
5186         {
5187                 place_inner_bold(y, x0 - 1);
5188                 place_inner_bold(y, x0 + 1);
5189         }
5190         for (x = x0 - 1; x <= x0 + 1; x++)
5191         {
5192                 place_inner_bold(y0 - 1, x);
5193                 place_inner_bold(y0 + 1, x);
5194         }
5195
5196         place_floor_bold(y0, x0);
5197
5198
5199         /* Add doors to vault */
5200         /* get two distances so can place doors relative to centre */
5201         x = (rad - 2) / 4 + 1;
5202         y = rad / 2 + x;
5203
5204         add_door(x0 + x, y0);
5205         add_door(x0 + y, y0);
5206         add_door(x0 - x, y0);
5207         add_door(x0 - y, y0);
5208         add_door(x0, y0 + x);
5209         add_door(x0, y0 + y);
5210         add_door(x0, y0 - x);
5211         add_door(x0, y0 - y);
5212
5213         /* Fill with stuff - medium difficulty */
5214         fill_treasure(x0 - rad, x0 + rad, y0 - rad, y0 + rad, randint1(3) + 3);
5215 }
5216
5217
5218 #ifdef ALLOW_CAVERNS_AND_LAKES
5219 /*
5220  * This routine uses a modified version of the lake code to make a
5221  * distribution of some terrain type over the vault.  This type
5222  * depends on the dungeon depth.
5223  *
5224  * Miniture rooms are then scattered across the vault.
5225  */
5226 static void build_elemental_vault(int x0, int y0, int xsiz, int ysiz)
5227 {
5228         int grd, roug;
5229         int c1, c2, c3;
5230         bool done = FALSE;
5231         int xsize, ysize, xhsize, yhsize, x, y, i;
5232         int type;
5233
5234
5235         if (cheat_room) msg_print("Elemental Vault");
5236
5237         /* round to make sizes even */
5238         xhsize = xsiz / 2;
5239         yhsize = ysiz / 2;
5240         xsize = xhsize * 2;
5241         ysize = yhsize * 2;
5242
5243         if (dun_level < 25)
5244         {
5245                 /* Earth vault  (Rubble) */
5246                 type = LAKE_T_EARTH_VAULT;
5247         }
5248         else if (dun_level < 50)
5249         {
5250                 /* Air vault (Trees) */
5251                 type = LAKE_T_AIR_VAULT;
5252         }
5253         else if (dun_level < 75)
5254         {
5255                 /* Water vault (shallow water) */
5256                 type = LAKE_T_WATER_VAULT;
5257         }
5258         else
5259         {
5260                 /* Fire vault (shallow lava) */
5261                 type = LAKE_T_FIRE_VAULT;
5262         }
5263
5264         while (!done)
5265         {
5266                 /* testing values for these parameters: feel free to adjust */
5267                 grd = 1 << (randint0(3));
5268
5269                 /* want average of about 16 */
5270                 roug = randint1(8) * randint1(4);
5271
5272                 /* Make up size of various componants */
5273                 /* Floor */
5274                 c3 = 2 * xsize / 3;
5275
5276                 /* Deep water/lava */
5277                 c1 = randint0(c3 / 2) + randint0(c3 / 2) - 5;
5278
5279                 /* Shallow boundary */
5280                 c2 = (c1 + c3) / 2;
5281
5282                 /* make it */
5283                 generate_hmap(y0, x0, xsize, ysize, grd, roug, c3);
5284
5285                 /* Convert to normal format+ clean up */
5286                 done = generate_lake(y0, x0, xsize, ysize, c1, c2, c3, type);
5287         }
5288
5289         /* Set icky flag because is a vault */
5290         for (x = 0; x <= xsize; x++)
5291         {
5292                 for (y = 0; y <= ysize; y++)
5293                 {
5294                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= CAVE_ICKY;
5295                 }
5296         }
5297
5298         /* make a few rooms in the vault */
5299         for (i = 1; i <= (xsize * ysize) / 50; i++)
5300         {
5301                 build_small_room(x0 + randint0(xsize - 4) - xsize / 2 + 2,
5302                                  y0 + randint0(ysize - 4) - ysize / 2 + 2);
5303         }
5304
5305         /* Fill with monsters and treasure, low difficulty */
5306         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 1,
5307                       y0 - yhsize + 1, y0 - yhsize + ysize - 1, randint1(5));
5308 }
5309 #endif /* ALLOW_CAVERNS_AND_LAKES */
5310
5311
5312 /*
5313  * Random vaults
5314  */
5315 static bool build_type10(void)
5316 {
5317         int y0, x0, xsize, ysize, vtype;
5318
5319         /* Get size */
5320         /* big enough to look good, small enough to be fairly common. */
5321         xsize = randint1(22) + 22;
5322         ysize = randint1(11) + 11;
5323
5324         /* Find and reserve some space in the dungeon.  Get center of room. */
5325         if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) return FALSE;
5326
5327         /* Boost the rating- higher than lesser vaults and lower than greater vaults */
5328         rating += 10;
5329
5330         /* (Sometimes) Cause a special feeling */
5331         if ((dun_level <= 50) ||
5332             (randint1((dun_level - 40) * (dun_level - 40) + 1) < 400))
5333         {
5334                 good_item_flag = TRUE;
5335         }
5336
5337         /* Select type of vault */
5338 #ifdef ALLOW_CAVERNS_AND_LAKES
5339         vtype = randint1(15);
5340 #else /* ALLOW_CAVERNS_AND_LAKES */
5341         vtype = randint1(7);
5342 #endif /* ALLOW_CAVERNS_AND_LAKES */
5343
5344         switch (vtype)
5345         {
5346                 /* Build an appropriate room */
5347                 case 1: case  9: build_bubble_vault(x0, y0, xsize, ysize); break;
5348                 case 2: case 10: build_room_vault(x0, y0, xsize, ysize); break;
5349                 case 3: case 11: build_cave_vault(x0, y0, xsize, ysize); break;
5350                 case 4: case 12: build_maze_vault(x0, y0, xsize, ysize, TRUE); break;
5351                 case 5: case 13: build_mini_c_vault(x0, y0, xsize, ysize); break;
5352                 case 6: case 14: build_castle_vault(x0, y0, xsize, ysize); break;
5353                 case 7: case 15: build_target_vault(x0, y0, xsize, ysize); break;
5354 #ifdef ALLOW_CAVERNS_AND_LAKES
5355                 case 8: build_elemental_vault(x0, y0, xsize, ysize); break;
5356 #endif /* ALLOW_CAVERNS_AND_LAKES */
5357                 /* I know how to add a few more... give me some time. */
5358
5359                 /* Paranoia */
5360                 default: return FALSE;
5361         }
5362
5363         return TRUE;
5364 }
5365
5366
5367 /*
5368  * Build an vertical oval room.
5369  * For every grid in the possible square, check the distance.
5370  * If it's less than the radius, make it a room square.
5371  *
5372  * When done fill from the inside to find the walls,
5373  */
5374 static bool build_type11(void)
5375 {
5376         int rad, x, y, x0, y0;
5377         int light = FALSE;
5378
5379         /* Occasional light */
5380         if ((randint1(dun_level) <= 15) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
5381
5382         rad = randint0(9);
5383
5384         /* Find and reserve some space in the dungeon.  Get center of room. */
5385         if (!find_space(&y0, &x0, rad * 2 + 1, rad * 2 + 1)) return FALSE;
5386
5387         /* Make circular floor */
5388         for (x = x0 - rad; x <= x0 + rad; x++)
5389         {
5390                 for (y = y0 - rad; y <= y0 + rad; y++)
5391                 {
5392                         if (distance(y0, x0, y, x) <= rad - 1)
5393                         {
5394                                 /* inside- so is floor */
5395                                 place_floor_bold(y, x);
5396                         }
5397                         else if (distance(y0, x0, y, x) <= rad + 1)
5398                         {
5399                                 /* make granite outside so arena works */
5400                                 place_extra_bold(y, x);
5401                         }
5402                 }
5403         }
5404
5405         /* Find visible outer walls and set to be FEAT_OUTER */
5406         add_outer_wall(x0, y0, light, x0 - rad, y0 - rad, x0 + rad, y0 + rad);
5407
5408         return TRUE;
5409 }
5410
5411
5412 /*
5413  * Build crypt room.
5414  * For every grid in the possible square, check the (fake) distance.
5415  * If it's less than the radius, make it a room square.
5416  *
5417  * When done fill from the inside to find the walls,
5418  */
5419 static bool build_type12(void)
5420 {
5421         int rad, x, y, x0, y0;
5422         int light = FALSE;
5423         bool emptyflag = TRUE;
5424
5425         /* Make a random metric */
5426         int h1, h2, h3, h4;
5427         h1 = randint1(32) - 16;
5428         h2 = randint1(16);
5429         h3 = randint1(32);
5430         h4 = randint1(32) - 16;
5431
5432         /* Occasional light */
5433         if ((randint1(dun_level) <= 5) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
5434
5435         rad = randint1(9);
5436
5437         /* Find and reserve some space in the dungeon.  Get center of room. */
5438         if (!find_space(&y0, &x0, rad * 2 + 3, rad * 2 + 3)) return FALSE;
5439
5440         /* Make floor */
5441         for (x = x0 - rad; x <= x0 + rad; x++)
5442         {
5443                 for (y = y0 - rad; y <= y0 + rad; y++)
5444                 {
5445                         /* clear room flag */
5446                         cave[y][x].info &= ~(CAVE_ROOM);
5447
5448                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)
5449                         {
5450                                 /* inside - so is floor */
5451                                 place_floor_bold(y, x);
5452                         }
5453                         else if (distance(y0, x0, y, x) < 3)
5454                         {
5455                                 place_floor_bold(y, x);
5456                         }
5457                         else
5458                         {
5459                                 /* make granite outside so arena works */
5460                                 place_extra_bold(y, x);
5461                         }
5462
5463                         /* proper boundary for arena */
5464                         if (((y + rad) == y0) || ((y - rad) == y0) ||
5465                             ((x + rad) == x0) || ((x - rad) == x0))
5466                         {
5467                                 place_extra_bold(y, x);
5468                         }
5469                 }
5470         }
5471
5472         /* Find visible outer walls and set to be FEAT_OUTER */
5473         add_outer_wall(x0, y0, light, x0 - rad - 1, y0 - rad - 1,
5474                        x0 + rad + 1, y0 + rad + 1);
5475
5476         /* Check to see if there is room for an inner vault */
5477         for (x = x0 - 2; x <= x0 + 2; x++)
5478         {
5479                 for (y = y0 - 2; y <= y0 + 2; y++)
5480                 {
5481                         if (!is_floor_bold(y, x))
5482                         {
5483                                 /* Wall in the way */
5484                                 emptyflag = FALSE;
5485                         }
5486                 }
5487         }
5488
5489         if (emptyflag && one_in_(2))
5490         {
5491                 /* Build the vault */
5492                 build_small_room(x0, y0);
5493
5494                 /* Place a treasure in the vault */
5495                 place_object(y0, x0, 0L);
5496
5497                 /* Let's guard the treasure well */
5498                 vault_monsters(y0, x0, randint0(2) + 3);
5499
5500                 /* Traps naturally */
5501                 vault_traps(y0, x0, 4, 4, randint0(3) + 2);
5502         }
5503
5504         return TRUE;
5505 }
5506
5507
5508 /*
5509  * Helper function for "trapped monster pit"
5510  */
5511 static bool vault_aux_trapped_pit(int r_idx)
5512 {
5513         monster_race *r_ptr = &r_info[r_idx];
5514
5515         /* Validate the monster */
5516         if (!vault_monster_okay(r_idx)) return (FALSE);
5517
5518         /* No wall passing monster */
5519         if (r_ptr->flags2 & (RF2_PASS_WALL | RF2_KILL_WALL)) return (FALSE);
5520
5521         /* Okay */
5522         return (TRUE);
5523 }
5524
5525
5526 /*
5527  * Type 12 -- Trapped monster pits
5528  *
5529  * A trapped monster pit is a "big" room with a straight corridor in
5530  * which wall opening traps are placed, and with two "inner" rooms
5531  * containing a "collection" of monsters of a given type organized in
5532  * the room.
5533  *
5534  * The trapped monster pit appears as shown below, where the actual
5535  * monsters in each location depend on the type of the pit
5536  *
5537  *  #########################
5538  *  #                       #
5539  *  ####################### #
5540  *  #####001123454321100### #
5541  *  ###0012234567654322100# #
5542  *  ####################### #
5543  *  #           ^           #
5544  *  # #######################
5545  *  # #0012234567654322100###
5546  *  # ###001123454321100#####
5547  *  # #######################
5548  *  #                       #
5549  *  #########################
5550  *
5551  * Note that the monsters in the pit are now chosen by using "get_mon_num()"
5552  * to request 16 "appropriate" monsters, sorting them by level, and using
5553  * the "even" entries in this sorted list for the contents of the pit.
5554  *
5555  * Hack -- all of the "dragons" in a "dragon" pit must be the same "color",
5556  * which is handled by requiring a specific "breath" attack for all of the
5557  * dragons.  This may include "multi-hued" breath.  Note that "wyrms" may
5558  * be present in many of the dragon pits, if they have the proper breath.
5559  *
5560  * Note the use of the "get_mon_num_prep()" function, and the special
5561  * "get_mon_num_hook()" restriction function, to prepare the "monster
5562  * allocation table" in such a way as to optimize the selection of
5563  * "appropriate" non-unique monsters for the pit.
5564  *
5565  * Note that the "get_mon_num()" function may (rarely) fail, in which case
5566  * the pit will be empty, and will not effect the level rating.
5567  *
5568  * Note that "monster pits" will never contain "unique" monsters.
5569  */
5570 static bool build_type13(void)
5571 {
5572         static int placing[][3] = {
5573                 {-2, -9, 0}, {-2, -8, 0}, {-3, -7, 0}, {-3, -6, 0},
5574                 {+2, -9, 0}, {+2, -8, 0}, {+3, -7, 0}, {+3, -6, 0},
5575                 {-2, +9, 0}, {-2, +8, 0}, {-3, +7, 0}, {-3, +6, 0},
5576                 {+2, +9, 0}, {+2, +8, 0}, {+3, +7, 0}, {+3, +6, 0},
5577                 {-2, -7, 1}, {-3, -5, 1}, {-3, -4, 1},
5578                 {+2, -7, 1}, {+3, -5, 1}, {+3, -4, 1},
5579                 {-2, +7, 1}, {-3, +5, 1}, {-3, +4, 1},
5580                 {+2, +7, 1}, {+3, +5, 1}, {+3, +4, 1},
5581                 {-2, -6, 2}, {-2, -5, 2}, {-3, -3, 2},
5582                 {+2, -6, 2}, {+2, -5, 2}, {+3, -3, 2},
5583                 {-2, +6, 2}, {-2, +5, 2}, {-3, +3, 2},
5584                 {+2, +6, 2}, {+2, +5, 2}, {+3, +3, 2},
5585                 {-2, -4, 3}, {-3, -2, 3},
5586                 {+2, -4, 3}, {+3, -2, 3},
5587                 {-2, +4, 3}, {-3, +2, 3},
5588                 {+2, +4, 3}, {+3, +2, 3},
5589                 {-2, -3, 4}, {-3, -1, 4},
5590                 {+2, -3, 4}, {+3, -1, 4},
5591                 {-2, +3, 4}, {-3, +1, 4},
5592                 {+2, +3, 4}, {+3, +1, 4},
5593                 {-2, -2, 5}, {-3, 0, 5}, {-2, +2, 5},
5594                 {+2, -2, 5}, {+3, 0, 5}, {+2, +2, 5},
5595                 {-2, -1, 6}, {-2, +1, 6},
5596                 {+2, -1, 6}, {+2, +1, 6},
5597                 {-2, 0, 7}, {+2, 0, 7},
5598                 {0, 0, -1}
5599         };
5600
5601         int y, x, y1, x1, y2, x2, xval, yval;
5602         int i, j;
5603
5604         int what[16];
5605
5606         monster_type align;
5607
5608         cave_type *c_ptr;
5609
5610         int cur_pit_type = pick_vault_type(pit_types, d_info[dungeon_type].pit);
5611         vault_aux_type *n_ptr;
5612
5613         /* Only in Angband */
5614         if (dungeon_type != DUNGEON_ANGBAND) return FALSE;
5615
5616         /* No type available */
5617         if (cur_pit_type < 0) return FALSE;
5618
5619         n_ptr = &pit_types[cur_pit_type];
5620
5621         /* Process a preparation function if necessary */
5622         if (n_ptr->prep_func) (*(n_ptr->prep_func))();
5623
5624         /* Prepare allocation table */
5625         get_mon_num_prep(n_ptr->hook_func, vault_aux_trapped_pit);
5626
5627         align.sub_align = SUB_ALIGN_NEUTRAL;
5628
5629         /* Pick some monster types */
5630         for (i = 0; i < 16; i++)
5631         {
5632                 int r_idx = 0, attempts = 100;
5633                 monster_race *r_ptr = NULL;
5634
5635                 while (attempts--)
5636                 {
5637                         /* Get a (hard) monster type */
5638                         r_idx = get_mon_num(dun_level + 0);
5639                         r_ptr = &r_info[r_idx];
5640
5641                         /* Decline incorrect alignment */
5642                         if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue;
5643
5644                         /* Accept this monster */
5645                         break;
5646                 }
5647
5648                 /* Notice failure */
5649                 if (!r_idx || !attempts) return FALSE;
5650
5651                 /* Note the alignment */
5652                 if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL;
5653                 if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD;
5654
5655                 what[i] = r_idx;
5656         }
5657
5658         /* Find and reserve some space in the dungeon.  Get center of room. */
5659         if (!find_space(&yval, &xval, 13, 25)) return FALSE;
5660
5661         /* Large room */
5662         y1 = yval - 5;
5663         y2 = yval + 5;
5664         x1 = xval - 11;
5665         x2 = xval + 11;
5666
5667         /* Fill with inner walls */
5668         for (y = y1 - 1; y <= y2 + 1; y++)
5669         {
5670                 for (x = x1 - 1; x <= x2 + 1; x++)
5671                 {
5672                         c_ptr = &cave[y][x];
5673                         place_inner_grid(c_ptr);
5674                         c_ptr->info |= (CAVE_ROOM);
5675                 }
5676         }
5677
5678         /* Place the floor area 1 */
5679         for (x = x1 + 3; x <= x2 - 3; x++)
5680         {
5681                 c_ptr = &cave[yval-2][x];
5682                 place_floor_grid(c_ptr);
5683                 add_cave_info(yval-2, x, CAVE_ICKY);
5684
5685                 c_ptr = &cave[yval+2][x];
5686                 place_floor_grid(c_ptr);
5687                 add_cave_info(yval+2, x, CAVE_ICKY);
5688         }
5689
5690         /* Place the floor area 2 */
5691         for (x = x1 + 5; x <= x2 - 5; x++)
5692         {
5693                 c_ptr = &cave[yval-3][x];
5694                 place_floor_grid(c_ptr);
5695                 add_cave_info(yval-3, x, CAVE_ICKY);
5696
5697                 c_ptr = &cave[yval+3][x];
5698                 place_floor_grid(c_ptr);
5699                 add_cave_info(yval+3, x, CAVE_ICKY);
5700         }
5701
5702         /* Corridor */
5703         for (x = x1; x <= x2; x++)
5704         {
5705                 c_ptr = &cave[yval][x];
5706                 place_floor_grid(c_ptr);
5707                 c_ptr = &cave[y1][x];
5708                 place_floor_grid(c_ptr);
5709                 c_ptr = &cave[y2][x];
5710                 place_floor_grid(c_ptr);
5711         }
5712
5713         /* Place the outer walls */
5714         for (y = y1 - 1; y <= y2 + 1; y++)
5715         {
5716                 c_ptr = &cave[y][x1 - 1];
5717                 place_outer_grid(c_ptr);
5718                 c_ptr = &cave[y][x2 + 1];
5719                 place_outer_grid(c_ptr);
5720         }
5721         for (x = x1 - 1; x <= x2 + 1; x++)
5722         {
5723                 c_ptr = &cave[y1 - 1][x];
5724                 place_outer_grid(c_ptr);
5725                 c_ptr = &cave[y2 + 1][x];
5726                 place_outer_grid(c_ptr);
5727         }
5728
5729         /* Random corridor */
5730         if (one_in_(2))
5731         {
5732                 for (y = y1; y <= yval; y++)
5733                 {
5734                         place_floor_bold(y, x2);
5735                         place_solid_bold(y, x1-1);
5736                 }
5737                 for (y = yval; y <= y2 + 1; y++)
5738                 {
5739                         place_floor_bold(y, x1);
5740                         place_solid_bold(y, x2+1);
5741                 }
5742         }
5743         else
5744         {
5745                 for (y = yval; y <= y2 + 1; y++)
5746                 {
5747                         place_floor_bold(y, x1);
5748                         place_solid_bold(y, x2+1);
5749                 }
5750                 for (y = y1; y <= yval; y++)
5751                 {
5752                         place_floor_bold(y, x2);
5753                         place_solid_bold(y, x1-1);
5754                 }
5755         }
5756
5757         /* Place the wall open trap */
5758         cave[yval][xval].mimic = cave[yval][xval].feat;
5759         cave[yval][xval].feat = FEAT_TRAP_OPEN;
5760
5761         /* Sort the entries */
5762         for (i = 0; i < 16 - 1; i++)
5763         {
5764                 /* Sort the entries */
5765                 for (j = 0; j < 16 - 1; j++)
5766                 {
5767                         int i1 = j;
5768                         int i2 = j + 1;
5769
5770                         int p1 = r_info[what[i1]].level;
5771                         int p2 = r_info[what[i2]].level;
5772
5773                         /* Bubble */
5774                         if (p1 > p2)
5775                         {
5776                                 int tmp = what[i1];
5777                                 what[i1] = what[i2];
5778                                 what[i2] = tmp;
5779                         }
5780                 }
5781         }
5782
5783         /* Message */
5784         if (cheat_room)
5785         {
5786                 /* Room type */
5787 #ifdef JP
5788                 msg_format("%s%s¤Îæ«¥Ô¥Ã¥È", n_ptr->name, pit_subtype_string(cur_pit_type, FALSE));
5789 #else
5790                 msg_format("Trapped monster pit (%s%s)", n_ptr->name, pit_subtype_string(cur_pit_type, FALSE));
5791 #endif
5792         }
5793
5794         /* Select the entries */
5795         for (i = 0; i < 8; i++)
5796         {
5797                 /* Every other entry */
5798                 what[i] = what[i * 2];
5799
5800                 if (cheat_hear)
5801                 {
5802                         /* Message */
5803                         msg_print(r_name + r_info[what[i]].name);
5804                 }
5805         }
5806
5807         /* Increase the level rating */
5808         rating += 20;
5809
5810         /* (Sometimes) Cause a "special feeling" (for "Monster Pits") */
5811         if ((dun_level <= 40) && (randint1(dun_level * dun_level + 50) < 300))
5812         {
5813                 good_item_flag = TRUE;
5814         }
5815
5816         for (i = 0; placing[i][2] >= 0; i++)
5817         {
5818                 y = yval + placing[i][0];
5819                 x = xval + placing[i][1];
5820                 place_monster_aux(0, y, x, what[placing[i][2]], PM_NO_KAGE);
5821         }
5822
5823         return TRUE;
5824 }
5825
5826
5827 /*
5828  * Type 14 -- trapped rooms
5829  *
5830  * A special trap is placed at center of the room
5831  */
5832 static bool build_type14(void)
5833 {
5834         int y, x, y2, x2, yval, xval;
5835         int y1, x1, xsize, ysize;
5836
5837         bool light;
5838
5839         cave_type *c_ptr;
5840         s16b trap;
5841
5842         /* Pick a room size */
5843         y1 = randint1(4);
5844         x1 = randint1(11);
5845         y2 = randint1(3);
5846         x2 = randint1(11);
5847
5848         xsize = x1 + x2 + 1;
5849         ysize = y1 + y2 + 1;
5850
5851         /* Find and reserve some space in the dungeon.  Get center of room. */
5852         if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE;
5853
5854         /* Choose lite or dark */
5855         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
5856
5857
5858         /* Get corner values */
5859         y1 = yval - ysize / 2;
5860         x1 = xval - xsize / 2;
5861         y2 = yval + (ysize - 1) / 2;
5862         x2 = xval + (xsize - 1) / 2;
5863
5864
5865         /* Place a full floor under the room */
5866         for (y = y1 - 1; y <= y2 + 1; y++)
5867         {
5868                 for (x = x1 - 1; x <= x2 + 1; x++)
5869                 {
5870                         c_ptr = &cave[y][x];
5871                         place_floor_grid(c_ptr);
5872                         c_ptr->info |= (CAVE_ROOM);
5873                         if (light) c_ptr->info |= (CAVE_GLOW);
5874                 }
5875         }
5876
5877         /* Walls around the room */
5878         for (y = y1 - 1; y <= y2 + 1; y++)
5879         {
5880                 c_ptr = &cave[y][x1 - 1];
5881                 place_outer_grid(c_ptr);
5882                 c_ptr = &cave[y][x2 + 1];
5883                 place_outer_grid(c_ptr);
5884         }
5885         for (x = x1 - 1; x <= x2 + 1; x++)
5886         {
5887                 c_ptr = &cave[y1 - 1][x];
5888                 place_outer_grid(c_ptr);
5889                 c_ptr = &cave[y2 + 1][x];
5890                 place_outer_grid(c_ptr);
5891         }
5892
5893         if (dun_level < 30 + randint1(30))
5894                 trap = FEAT_TRAP_PIRANHA;
5895         else
5896                 trap = FEAT_TRAP_ARMAGEDDON;
5897
5898         /* Place a special trap */
5899         c_ptr = &cave[rand_spread(yval, ysize/4)][rand_spread(xval, xsize/4)];
5900         c_ptr->mimic = c_ptr->feat;
5901         c_ptr->feat = trap;
5902
5903         /* Message */
5904         if (cheat_room)
5905         {
5906 #ifdef JP
5907                 msg_format("%s¤ÎÉô²°", f_name + f_info[trap].name);
5908 #else
5909                 msg_format("Room of %s", f_name + f_info[trap].name);
5910 #endif
5911         }
5912
5913         return TRUE;
5914 }
5915
5916
5917 /*
5918  * Attempt to build a room of the given type at the given block
5919  *
5920  * Note that we restrict the number of "crowded" rooms to reduce
5921  * the chance of overflowing the monster list during level creation.
5922  */
5923 bool room_build(int typ)
5924 {
5925         /* Build a room */
5926         switch (typ)
5927         {
5928         /* Build an appropriate room */
5929         case ROOM_T_NORMAL:        return build_type1();
5930         case ROOM_T_OVERLAP:       return build_type2();
5931         case ROOM_T_CROSS:         return build_type3();
5932         case ROOM_T_INNER_FEAT:    return build_type4();
5933         case ROOM_T_NEST:          return build_type5();
5934         case ROOM_T_PIT:           return build_type6();
5935         case ROOM_T_LESSER_VAULT:  return build_type7();
5936         case ROOM_T_GREATER_VAULT: return build_type8();
5937         case ROOM_T_FRACAVE:       return build_type9();
5938         case ROOM_T_RANDOM_VAULT:  return build_type10();
5939         case ROOM_T_OVAL:          return build_type11();
5940         case ROOM_T_CRYPT:         return build_type12();
5941         case ROOM_T_TRAP_PIT:      return build_type13();
5942         case ROOM_T_TRAP:          return build_type14();
5943         }
5944
5945         /* Paranoia */
5946         return FALSE;
5947 }
5948
5949
5950 #define MOVE_PLIST(dst, src) (prob_list[dst] += prob_list[src], prob_list[src] = 0)
5951
5952 /*
5953  * [from SAngband (originally from OAngband)]
5954  *
5955  * Generate rooms in dungeon.  Build bigger rooms at first.
5956  */
5957 void generate_rooms(void)
5958 {
5959         int i;
5960         bool remain;
5961         int crowded = 0;
5962         int total_prob;
5963         int prob_list[ROOM_T_MAX];
5964         int rooms_built = 0;
5965         int area_size = 100 * (cur_hgt*cur_wid) / (MAX_HGT*MAX_WID);
5966         int level_index = MIN(10, div_round(dun_level, 10));
5967
5968         /* Number of each type of room on this level */
5969         s16b room_num[ROOM_T_MAX];
5970
5971         /* Limit number of rooms */
5972         int dun_rooms = DUN_ROOMS_MAX * area_size / 100;
5973
5974         /* Assume normal cave */
5975         room_info_type *room_info_ptr = room_info_normal;
5976
5977
5978         /*
5979          * Initialize probability list.
5980          */
5981         for (i = 0; i < ROOM_T_MAX; i++)
5982         {
5983                 /* No rooms allowed above their minimum depth. */
5984                 if (dun_level < room_info_ptr[i].min_level)
5985                 {
5986                         prob_list[i] = 0;
5987                 }
5988                 else
5989                 {
5990                         prob_list[i] = room_info_ptr[i].prob[level_index];
5991                 }
5992         }
5993
5994         /*
5995          * XXX -- Various dungeon types and options.
5996          */
5997
5998         /* Ironman sees only Greater Vaults */
5999         if (ironman_rooms && !((d_info[dungeon_type].flags1 & (DF1_BEGINNER | DF1_CHAMELEON))))
6000         {
6001                 for (i = 0; i < ROOM_T_MAX; i++)
6002                 {
6003                         if (i == ROOM_T_GREATER_VAULT) prob_list[i] = 1;
6004                         else prob_list[i] = 0;
6005                 }
6006         }
6007
6008         /* Forbidden vaults */
6009         else if (d_info[dungeon_type].flags1 & DF1_NO_VAULT)
6010         {
6011                 prob_list[ROOM_T_LESSER_VAULT] = 0;
6012                 prob_list[ROOM_T_GREATER_VAULT] = 0;
6013                 prob_list[ROOM_T_RANDOM_VAULT] = 0;
6014         }
6015
6016
6017         /* NO_CAVE dungeon (Castle)*/
6018         if (d_info[dungeon_type].flags1 & DF1_NO_CAVE)
6019         {
6020                 MOVE_PLIST(ROOM_T_NORMAL, ROOM_T_FRACAVE);
6021                 MOVE_PLIST(ROOM_T_INNER_FEAT, ROOM_T_CRYPT);
6022                 MOVE_PLIST(ROOM_T_INNER_FEAT, ROOM_T_OVAL);
6023         }
6024
6025         /* CAVE dungeon (Orc cave etc.) */
6026         else if (d_info[dungeon_type].flags1 & DF1_CAVE)
6027         {
6028                 MOVE_PLIST(ROOM_T_FRACAVE, ROOM_T_NORMAL);
6029         }
6030
6031         /* No caves when a (random) cavern exists: they look bad */
6032         else if (dun->cavern || dun->empty_level)
6033         {
6034                 prob_list[ROOM_T_FRACAVE] = 0;
6035         }
6036
6037
6038         /*
6039          * Initialize number of rooms,
6040          * And calcurate total probability.
6041          */
6042         for (total_prob = 0, i = 0; i < ROOM_T_MAX; i++)
6043         {
6044                 room_num[i] = 0;
6045                 total_prob += prob_list[i];
6046         }
6047
6048         /*
6049          * Prepare the number of rooms, of all types, we should build
6050          * on this level.
6051          */
6052         for (i = dun_rooms; i > 0; i--)
6053         {
6054                 int room_type;
6055                 int rand = randint0(total_prob);
6056
6057                 /* Get room_type randomly */
6058                 for (room_type = 0; room_type < ROOM_T_MAX; room_type++)
6059                 {
6060                         if (rand < prob_list[room_type]) break;
6061                         else rand -= prob_list[room_type];
6062                 }
6063
6064                 /* Paranoia */
6065                 if (room_type >= ROOM_T_MAX) room_type = ROOM_T_NORMAL;
6066
6067                 /* Increase the number of rooms of that type we should build. */
6068                 room_num[room_type]++;
6069
6070                 switch (room_type)
6071                 {
6072                 case ROOM_T_NEST:
6073                 case ROOM_T_PIT:
6074                 case ROOM_T_LESSER_VAULT:
6075                 case ROOM_T_TRAP_PIT:
6076
6077                         /* Large room */
6078                         i -= 2;
6079                         break;
6080
6081                 case ROOM_T_GREATER_VAULT:
6082                 case ROOM_T_RANDOM_VAULT:
6083
6084                         /* Largest room */
6085                         i -= 3;
6086                         break;
6087                 }
6088         }
6089
6090         /*
6091          * Build each type of room one by one until we cannot build any more.
6092          * [from SAngband (originally from OAngband)]
6093          */
6094         while (TRUE)
6095         {
6096                 /* Assume no remaining rooms */
6097                 remain = FALSE;
6098
6099                 for (i = 0; i < ROOM_T_MAX; i++)
6100                 {
6101                         /* What type of room are we building now? */
6102                         int room_type = room_build_order[i];
6103
6104                         /* Go next if none available */
6105                         if (!room_num[room_type]) continue;
6106
6107                         /* Use up one unit */
6108                         room_num[room_type]--;
6109
6110                         /* Build the room. */
6111                         if (room_build(room_type))
6112                         {
6113                                 /* Increase the room built count. */
6114                                 rooms_built++;
6115
6116                                 /* Mark as there was some remaining rooms */
6117                                 remain = TRUE;
6118
6119                                 switch (room_type)
6120                                 {
6121                                 case ROOM_T_PIT:
6122                                 case ROOM_T_NEST:
6123                                 case ROOM_T_TRAP_PIT:
6124
6125                                         /* Avoid too many monsters */
6126                                         if (++crowded >= 2)
6127                                         {
6128                                                 room_num[ROOM_T_PIT] = 0;
6129                                                 room_num[ROOM_T_NEST] = 0;
6130                                                 room_num[ROOM_T_TRAP_PIT] = 0;
6131                                         }
6132                                 }
6133                         }
6134
6135                         /* Stop building this type on failure. */
6136                         else
6137                         {
6138                                 room_num[room_type] = 0;
6139                         }
6140                 }
6141
6142                 /* End loop if no room remain */
6143                 if (!remain) break;
6144         }
6145
6146         if (cheat_room)
6147         {
6148 #ifdef JP
6149                 msg_format("Éô²°¿ô: %d", rooms_built);
6150 #else
6151                 msg_format("Number of Rooms: %d", rooms_built);
6152 #endif
6153         }
6154 }