src/rooms.c

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