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 = (byte_hack)*y;
 490                 dun->cent[dun->cent_n].x = (byte_hack)*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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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(MONRACE_IDX 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         MONRACE_IDX 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(MONRACE_IDX 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)(MONRACE_IDX 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                 MONRACE_IDX r_idx = 0;
2291                 int attempts = 100;
2292                 monster_race *r_ptr = NULL;
2293
2294                 while (attempts--)
2295                 {
2296                         /* Get a (hard) monster type */
2297                         r_idx = get_mon_num(dun_level + 11);
2298                         r_ptr = &r_info[r_idx];
2299
2300                         /* Decline incorrect alignment */
2301                         if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue;
2302
2303                         /* Accept this monster */
2304                         break;
2305                 }
2306
2307                 /* Notice failure */
2308                 if (!r_idx || !attempts) return FALSE;
2309
2310                 /* Note the alignment */
2311                 if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL;
2312                 if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD;
2313
2314                 nest_mon_info[i].r_idx = (s16b)r_idx;
2315                 nest_mon_info[i].used = FALSE;
2316         }
2317
2318         /* Find and reserve some space in the dungeon.  Get center of room. */
2319         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
2320
2321         /* Large room */
2322         y1 = yval - 4;
2323         y2 = yval + 4;
2324         x1 = xval - 11;
2325         x2 = xval + 11;
2326
2327         /* Place the floor area */
2328         for (y = y1 - 1; y <= y2 + 1; y++)
2329         {
2330                 for (x = x1 - 1; x <= x2 + 1; x++)
2331                 {
2332                         c_ptr = &cave[y][x];
2333                         place_floor_grid(c_ptr);
2334                         c_ptr->info |= (CAVE_ROOM);
2335                 }
2336         }
2337
2338         /* Place the outer walls */
2339         for (y = y1 - 1; y <= y2 + 1; y++)
2340         {
2341                 c_ptr = &cave[y][x1 - 1];
2342                 place_outer_grid(c_ptr);
2343                 c_ptr = &cave[y][x2 + 1];
2344                 place_outer_grid(c_ptr);
2345         }
2346         for (x = x1 - 1; x <= x2 + 1; x++)
2347         {
2348                 c_ptr = &cave[y1 - 1][x];
2349                 place_outer_grid(c_ptr);
2350                 c_ptr = &cave[y2 + 1][x];
2351                 place_outer_grid(c_ptr);
2352         }
2353
2354
2355         /* Advance to the center room */
2356         y1 = y1 + 2;
2357         y2 = y2 - 2;
2358         x1 = x1 + 2;
2359         x2 = x2 - 2;
2360
2361         /* The inner walls */
2362         for (y = y1 - 1; y <= y2 + 1; y++)
2363         {
2364                 c_ptr = &cave[y][x1 - 1];
2365                 place_inner_grid(c_ptr);
2366                 c_ptr = &cave[y][x2 + 1];
2367                 place_inner_grid(c_ptr);
2368         }
2369
2370         for (x = x1 - 1; x <= x2 + 1; x++)
2371         {
2372                 c_ptr = &cave[y1 - 1][x];
2373                 place_inner_grid(c_ptr);
2374                 c_ptr = &cave[y2 + 1][x];
2375                 place_inner_grid(c_ptr);
2376         }
2377         for (y = y1; y <= y2; y++)
2378         {
2379                 for (x = x1; x <= x2; x++)
2380                 {
2381                         add_cave_info(y, x, CAVE_ICKY);
2382                 }
2383         }
2384
2385         /* Place a secret door */
2386         switch (randint1(4))
2387         {
2388                 case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break;
2389                 case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break;
2390                 case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break;
2391                 case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break;
2392         }
2393
2394         msg_format_wizard(CHEAT_DUNGEON, _("モンスター部屋(nest)(%s%s)を生成します。", "Monster nest (%s%s)"), n_ptr->name, pit_subtype_string(cur_nest_type, TRUE));
2395
2396         /* Place some monsters */
2397         for (y = yval - 2; y <= yval + 2; y++)
2398         {
2399                 for (x = xval - 9; x <= xval + 9; x++)
2400                 {
2401                         MONRACE_IDX r_idx;
2402
2403                         i = randint0(NUM_NEST_MON_TYPE);
2404                         r_idx = nest_mon_info[i].r_idx;
2405
2406                         /* Place that "random" monster (no groups) */
2407                         (void)place_monster_aux(0, y, x, r_idx, 0L);
2408
2409                         nest_mon_info[i].used = TRUE;
2410                 }
2411         }
2412
2413         if (cheat_room)
2414         {
2415                 ang_sort_comp = ang_sort_comp_nest_mon_info;
2416                 ang_sort_swap = ang_sort_swap_nest_mon_info;
2417                 ang_sort(nest_mon_info, NULL, NUM_NEST_MON_TYPE);
2418
2419                 /* Dump the entries (prevent multi-printing) */
2420                 for (i = 0; i < NUM_NEST_MON_TYPE; i++)
2421                 {
2422                         if (!nest_mon_info[i].used) break;
2423                         for (; i < NUM_NEST_MON_TYPE - 1; i++)
2424                         {
2425                                 if (nest_mon_info[i].r_idx != nest_mon_info[i + 1].r_idx) break;
2426                                 if (!nest_mon_info[i + 1].used) break;
2427                         }
2428                         msg_format_wizard(CHEAT_DUNGEON, "Nest構成モンスターNo.%d:%s", i, r_name + r_info[nest_mon_info[i].r_idx].name);
2429                 }
2430         }
2431
2432         return TRUE;
2433 }
2434
2435
2436 /*!
2437  * @brief タイプ6の部屋…pitを生成する / Type 6 -- Monster pits
2438  * @return なし
2439  * @details
2440  * A monster pit is a "big" room, with an "inner" room, containing\n
2441  * a "collection" of monsters of a given type organized in the room.\n
2442  *\n
2443  * The inside room in a monster pit appears as shown below, where the\n
2444  * actual monsters in each location depend on the type of the pit\n
2445  *\n
2446  *   XXXXXXXXXXXXXXXXXXXXX\n
2447  *   X0000000000000000000X\n
2448  *   X0112233455543322110X\n
2449  *   X0112233467643322110X\n
2450  *   X0112233455543322110X\n
2451  *   X0000000000000000000X\n
2452  *   XXXXXXXXXXXXXXXXXXXXX\n
2453  *\n
2454  * Note that the monsters in the pit are now chosen by using "get_mon_num()"\n
2455  * to request 16 "appropriate" monsters, sorting them by level, and using\n
2456  * the "even" entries in this sorted list for the contents of the pit.\n
2457  *\n
2458  * Hack -- all of the "dragons" in a "dragon" pit must be the same "color",\n
2459  * which is handled by requiring a specific "breath" attack for all of the\n
2460  * dragons.  This may include "multi-hued" breath.  Note that "wyrms" may\n
2461  * be present in many of the dragon pits, if they have the proper breath.\n
2462  *\n
2463  * Note the use of the "get_mon_num_prep()" function, and the special\n
2464  * "get_mon_num_hook()" restriction function, to prepare the "monster\n
2465  * allocation table" in such a way as to optimize the selection of\n
2466  * "appropriate" non-unique monsters for the pit.\n
2467  *\n
2468  * Note that the "get_mon_num()" function may (rarely) fail, in which case\n
2469  * the pit will be empty.\n
2470  *\n
2471  * Note that "monster pits" will never contain "unique" monsters.\n
2472  */
2473 static bool build_type6(void)
2474 {
2475         int y, x, y1, x1, y2, x2, xval, yval;
2476         int i, j;
2477
2478         int what[16];
2479
2480         monster_type align;
2481
2482         cave_type *c_ptr;
2483
2484         int cur_pit_type = pick_vault_type(pit_types, d_info[dungeon_type].pit);
2485         vault_aux_type *n_ptr;
2486
2487         /* No type available */
2488         if (cur_pit_type < 0) return FALSE;
2489
2490         n_ptr = &pit_types[cur_pit_type];
2491
2492         /* Process a preparation function if necessary */
2493         if (n_ptr->prep_func) (*(n_ptr->prep_func))();
2494
2495         /* Prepare allocation table */
2496         get_mon_num_prep(n_ptr->hook_func, NULL);
2497
2498         align.sub_align = SUB_ALIGN_NEUTRAL;
2499
2500         /* Pick some monster types */
2501         for (i = 0; i < 16; i++)
2502         {
2503                 MONRACE_IDX r_idx = 0;
2504                 int attempts = 100;
2505                 monster_race *r_ptr = NULL;
2506
2507                 while (attempts--)
2508                 {
2509                         /* Get a (hard) monster type */
2510                         r_idx = get_mon_num(dun_level + 11);
2511                         r_ptr = &r_info[r_idx];
2512
2513                         /* Decline incorrect alignment */
2514                         if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue;
2515
2516                         /* Accept this monster */
2517                         break;
2518                 }
2519
2520                 /* Notice failure */
2521                 if (!r_idx || !attempts) return FALSE;
2522
2523                 /* Note the alignment */
2524                 if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL;
2525                 if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD;
2526
2527                 what[i] = r_idx;
2528         }
2529
2530         /* Find and reserve some space in the dungeon.  Get center of room. */
2531         if (!find_space(&yval, &xval, 11, 25)) return FALSE;
2532
2533         /* Large room */
2534         y1 = yval - 4;
2535         y2 = yval + 4;
2536         x1 = xval - 11;
2537         x2 = xval + 11;
2538
2539         /* Place the floor area */
2540         for (y = y1 - 1; y <= y2 + 1; y++)
2541         {
2542                 for (x = x1 - 1; x <= x2 + 1; x++)
2543                 {
2544                         c_ptr = &cave[y][x];
2545                         place_floor_grid(c_ptr);
2546                         c_ptr->info |= (CAVE_ROOM);
2547                 }
2548         }
2549
2550         /* Place the outer walls */
2551         for (y = y1 - 1; y <= y2 + 1; y++)
2552         {
2553                 c_ptr = &cave[y][x1 - 1];
2554                 place_outer_grid(c_ptr);
2555                 c_ptr = &cave[y][x2 + 1];
2556                 place_outer_grid(c_ptr);
2557         }
2558         for (x = x1 - 1; x <= x2 + 1; x++)
2559         {
2560                 c_ptr = &cave[y1 - 1][x];
2561                 place_outer_grid(c_ptr);
2562                 c_ptr = &cave[y2 + 1][x];
2563                 place_outer_grid(c_ptr);
2564         }
2565
2566         /* Advance to the center room */
2567         y1 = y1 + 2;
2568         y2 = y2 - 2;
2569         x1 = x1 + 2;
2570         x2 = x2 - 2;
2571
2572         /* The inner walls */
2573         for (y = y1 - 1; y <= y2 + 1; y++)
2574         {
2575                 c_ptr = &cave[y][x1 - 1];
2576                 place_inner_grid(c_ptr);
2577                 c_ptr = &cave[y][x2 + 1];
2578                 place_inner_grid(c_ptr);
2579         }
2580         for (x = x1 - 1; x <= x2 + 1; x++)
2581         {
2582                 c_ptr = &cave[y1 - 1][x];
2583                 place_inner_grid(c_ptr);
2584                 c_ptr = &cave[y2 + 1][x];
2585                 place_inner_grid(c_ptr);
2586         }
2587         for (y = y1; y <= y2; y++)
2588         {
2589                 for (x = x1; x <= x2; x++)
2590                 {
2591                         add_cave_info(y, x, CAVE_ICKY);
2592                 }
2593         }
2594
2595         /* Place a secret door */
2596         switch (randint1(4))
2597         {
2598                 case 1: place_secret_door(y1 - 1, xval, DOOR_DEFAULT); break;
2599                 case 2: place_secret_door(y2 + 1, xval, DOOR_DEFAULT); break;
2600                 case 3: place_secret_door(yval, x1 - 1, DOOR_DEFAULT); break;
2601                 case 4: place_secret_door(yval, x2 + 1, DOOR_DEFAULT); break;
2602         }
2603
2604         /* Sort the entries */
2605         for (i = 0; i < 16 - 1; i++)
2606         {
2607                 /* Sort the entries */
2608                 for (j = 0; j < 16 - 1; j++)
2609                 {
2610                         int i1 = j;
2611                         int i2 = j + 1;
2612
2613                         int p1 = r_info[what[i1]].level;
2614                         int p2 = r_info[what[i2]].level;
2615
2616                         /* Bubble */
2617                         if (p1 > p2)
2618                         {
2619                                 int tmp = what[i1];
2620                                 what[i1] = what[i2];
2621                                 what[i2] = tmp;
2622                         }
2623                 }
2624         }
2625
2626         msg_format_wizard(CHEAT_DUNGEON, _("モンスター部屋(pit)(%s%s)を生成します。", "Monster pit (%s%s)"), n_ptr->name, pit_subtype_string(cur_pit_type, FALSE));
2627
2628         /* Select the entries */
2629         for (i = 0; i < 8; i++)
2630         {
2631                 /* Every other entry */
2632                 what[i] = what[i * 2];
2633                 msg_format_wizard(CHEAT_DUNGEON, _("Nest構成モンスター選択No.%d:%s", "Nest Monster Select No.%d:%s"), i, r_name + r_info[what[i]].name);
2634         }
2635
2636         /* Top and bottom rows */
2637         for (x = xval - 9; x <= xval + 9; x++)
2638         {
2639                 place_monster_aux(0, yval - 2, x, what[0], PM_NO_KAGE);
2640                 place_monster_aux(0, yval + 2, x, what[0], PM_NO_KAGE);
2641         }
2642
2643         /* Middle columns */
2644         for (y = yval - 1; y <= yval + 1; y++)
2645         {
2646                 place_monster_aux(0, y, xval - 9, what[0], PM_NO_KAGE);
2647                 place_monster_aux(0, y, xval + 9, what[0], PM_NO_KAGE);
2648
2649                 place_monster_aux(0, y, xval - 8, what[1], PM_NO_KAGE);
2650                 place_monster_aux(0, y, xval + 8, what[1], PM_NO_KAGE);
2651
2652                 place_monster_aux(0, y, xval - 7, what[1], PM_NO_KAGE);
2653                 place_monster_aux(0, y, xval + 7, what[1], PM_NO_KAGE);
2654
2655                 place_monster_aux(0, y, xval - 6, what[2], PM_NO_KAGE);
2656                 place_monster_aux(0, y, xval + 6, what[2], PM_NO_KAGE);
2657
2658                 place_monster_aux(0, y, xval - 5, what[2], PM_NO_KAGE);
2659                 place_monster_aux(0, y, xval + 5, what[2], PM_NO_KAGE);
2660
2661                 place_monster_aux(0, y, xval - 4, what[3], PM_NO_KAGE);
2662                 place_monster_aux(0, y, xval + 4, what[3], PM_NO_KAGE);
2663
2664                 place_monster_aux(0, y, xval - 3, what[3], PM_NO_KAGE);
2665                 place_monster_aux(0, y, xval + 3, what[3], PM_NO_KAGE);
2666
2667                 place_monster_aux(0, y, xval - 2, what[4], PM_NO_KAGE);
2668                 place_monster_aux(0, y, xval + 2, what[4], PM_NO_KAGE);
2669         }
2670
2671         /* Above/Below the center monster */
2672         for (x = xval - 1; x <= xval + 1; x++)
2673         {
2674                 place_monster_aux(0, yval + 1, x, what[5], PM_NO_KAGE);
2675                 place_monster_aux(0, yval - 1, x, what[5], PM_NO_KAGE);
2676         }
2677
2678         /* Next to the center monster */
2679         place_monster_aux(0, yval, xval + 1, what[6], PM_NO_KAGE);
2680         place_monster_aux(0, yval, xval - 1, what[6], PM_NO_KAGE);
2681
2682         /* Center monster */
2683         place_monster_aux(0, yval, xval, what[7], PM_NO_KAGE);
2684
2685         return TRUE;
2686 }
2687
2688
2689 /*!
2690  * @brief Vault地形を回転、上下左右反転するための座標変換を返す / coordinate translation code
2691  * @param x 変換したい点のX座標参照ポインタ
2692  * @param y 変換したい点のY座標参照ポインタ
2693  * @param xoffset Vault生成時の基準X座標
2694  * @param yoffset Vault生成時の基準Y座標
2695  * @param transno 処理ID
2696  * @return なし
2697  */
2698 static void coord_trans(int *x, int *y, int xoffset, int yoffset, int transno)
2699 {
2700         int i;
2701         int temp;
2702
2703         /*
2704          * transno specifies what transformation is required. (0-7)
2705          * The lower two bits indicate by how much the vault is rotated,
2706          * and the upper bit indicates a reflection.
2707          * This is done by using rotation matrices... however since
2708          * these are mostly zeros for rotations by 90 degrees this can
2709          * be expressed simply in terms of swapping and inverting the
2710          * x and y coordinates.
2711          */
2712         for (i = 0; i < transno % 4; i++)
2713         {
2714                 /* rotate by 90 degrees */
2715                 temp = *x;
2716                 *x = -(*y);
2717                 *y = temp;
2718         }
2719
2720         if (transno / 4)
2721         {
2722                 /* Reflect depending on status of 3rd bit. */
2723                 *x = -(*x);
2724         }
2725
2726         /* Add offsets so vault stays in the first quadrant */
2727         *x += xoffset;
2728         *y += yoffset;
2729 }
2730
2731 /*!
2732  * @brief Vaultをフロアに配置する / Hack -- fill in "vault" rooms
2733  * @param yval 生成基準Y座標
2734  * @param xval 生成基準X座標
2735  * @param ymax VaultのYサイズ
2736  * @param xmax VaultのXサイズ
2737  * @param data Vaultのデータ文字列
2738  * @param xoffset 変換基準X座標
2739  * @param yoffset 変換基準Y座標
2740  * @param transno 変換ID
2741  * @return なし
2742  */
2743 static void build_vault(int yval, int xval, int ymax, int xmax, cptr data,
2744                 int xoffset, int yoffset, int transno)
2745 {
2746         int dx, dy, x, y, i, j;
2747
2748         cptr t;
2749
2750         cave_type *c_ptr;
2751
2752
2753         /* Place dungeon features and objects */
2754         for (t = data, dy = 0; dy < ymax; dy++)
2755         {
2756                 for (dx = 0; dx < xmax; dx++, t++)
2757                 {
2758                         /* prevent loop counter from being overwritten */
2759                         i = dx;
2760                         j = dy;
2761
2762                         /* Flip / rotate */
2763                         coord_trans(&i, &j, xoffset, yoffset, transno);
2764
2765                         /* Extract the location */
2766                         if (transno % 2 == 0)
2767                         {
2768                                 /* no swap of x/y */
2769                                 x = xval - (xmax / 2) + i;
2770                                 y = yval - (ymax / 2) + j;
2771                         }
2772                         else
2773                         {
2774                                 /* swap of x/y */
2775                                 x = xval - (ymax / 2) + i;
2776                                 y = yval - (xmax / 2) + j;
2777                         }
2778
2779                         /* Hack -- skip "non-grids" */
2780                         if (*t == ' ') continue;
2781
2782                         /* Access the grid */
2783                         c_ptr = &cave[y][x];
2784
2785                         /* Lay down a floor */
2786                         place_floor_grid(c_ptr);
2787
2788                         /* Remove any mimic */
2789                         c_ptr->mimic = 0;
2790
2791                         /* Part of a vault */
2792                         c_ptr->info |= (CAVE_ROOM | CAVE_ICKY);
2793
2794                         /* Analyze the grid */
2795                         switch (*t)
2796                         {
2797                                 /* Granite wall (outer) */
2798                         case '%':
2799                                 place_outer_noperm_grid(c_ptr);
2800                                 break;
2801
2802                                 /* Granite wall (inner) */
2803                         case '#':
2804                                 place_inner_grid(c_ptr);
2805                                 break;
2806
2807                                 /* Glass wall (inner) */
2808                         case '$':
2809                                 place_inner_grid(c_ptr);
2810                                 c_ptr->feat = feat_glass_wall;
2811                                 break;
2812
2813                                 /* Permanent wall (inner) */
2814                         case 'X':
2815                                 place_inner_perm_grid(c_ptr);
2816                                 break;
2817
2818                                 /* Permanent glass wall (inner) */
2819                         case 'Y':
2820                                 place_inner_perm_grid(c_ptr);
2821                                 c_ptr->feat = feat_permanent_glass_wall;
2822                                 break;
2823
2824                                 /* Treasure/trap */
2825                         case '*':
2826                                 if (randint0(100) < 75)
2827                                 {
2828                                         place_object(y, x, 0L);
2829                                 }
2830                                 else
2831                                 {
2832                                         place_trap(y, x);
2833                                 }
2834                                 break;
2835
2836                                 /* Secret doors */
2837                         case '+':
2838                                 place_secret_door(y, x, DOOR_DEFAULT);
2839                                 break;
2840
2841                                 /* Secret glass doors */
2842                         case '-':
2843                                 place_secret_door(y, x, DOOR_GLASS_DOOR);
2844                                 if (is_closed_door(c_ptr->feat)) c_ptr->mimic = feat_glass_wall;
2845                                 break;
2846
2847                                 /* Curtains */
2848                         case '\'':
2849                                 place_secret_door(y, x, DOOR_CURTAIN);
2850                                 break;
2851
2852                                 /* Trap */
2853                         case '^':
2854                                 place_trap(y, x);
2855                                 break;
2856
2857                                 /* Black market in a dungeon */
2858                         case 'S':
2859                                 set_cave_feat(y, x, feat_black_market);
2860                                 store_init(NO_TOWN, STORE_BLACK);
2861                                 break;
2862
2863                                 /* The Pattern */
2864                         case 'p':
2865                                 set_cave_feat(y, x, feat_pattern_start);
2866                                 break;
2867
2868                         case 'a':
2869                                 set_cave_feat(y, x, feat_pattern_1);
2870                                 break;
2871
2872                         case 'b':
2873                                 set_cave_feat(y, x, feat_pattern_2);
2874                                 break;
2875
2876                         case 'c':
2877                                 set_cave_feat(y, x, feat_pattern_3);
2878                                 break;
2879
2880                         case 'd':
2881                                 set_cave_feat(y, x, feat_pattern_4);
2882                                 break;
2883
2884                         case 'P':
2885                                 set_cave_feat(y, x, feat_pattern_end);
2886                                 break;
2887
2888                         case 'B':
2889                                 set_cave_feat(y, x, feat_pattern_exit);
2890                                 break;
2891
2892                         case 'A':
2893                                 /* Reward for Pattern walk */
2894                                 object_level = base_level + 12;
2895                                 place_object(y, x, AM_GOOD | AM_GREAT);
2896                                 object_level = base_level;
2897                                 break;
2898                         }
2899                 }
2900         }
2901
2902
2903         /* Place dungeon monsters and objects */
2904         for (t = data, dy = 0; dy < ymax; dy++)
2905         {
2906                 for (dx = 0; dx < xmax; dx++, t++)
2907                 {
2908                         /* prevent loop counter from being overwritten */
2909                         i = dx;
2910                         j = dy;
2911
2912                         /* Flip / rotate */
2913                         coord_trans(&i, &j, xoffset, yoffset, transno);
2914
2915                         /* Extract the location */
2916                         if (transno % 2 == 0)
2917                         {
2918                                 /* no swap of x/y */
2919                                 x = xval - (xmax / 2) + i;
2920                                 y = yval - (ymax / 2) + j;
2921                         }
2922                         else
2923                         {
2924                                 /* swap of x/y */
2925                                 x = xval - (ymax / 2) + i;
2926                                 y = yval - (xmax / 2) + j;
2927                         }
2928
2929                         /* Hack -- skip "non-grids" */
2930                         if (*t == ' ') continue;
2931
2932                         /* Analyze the symbol */
2933                         switch (*t)
2934                         {
2935                                 /* Monster */
2936                                 case '&':
2937                                 {
2938                                         monster_level = base_level + 5;
2939                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
2940                                         monster_level = base_level;
2941                                         break;
2942                                 }
2943
2944                                 /* Meaner monster */
2945                                 case '@':
2946                                 {
2947                                         monster_level = base_level + 11;
2948                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
2949                                         monster_level = base_level;
2950                                         break;
2951                                 }
2952
2953                                 /* Meaner monster, plus treasure */
2954                                 case '9':
2955                                 {
2956                                         monster_level = base_level + 9;
2957                                         place_monster(y, x, PM_ALLOW_SLEEP);
2958                                         monster_level = base_level;
2959                                         object_level = base_level + 7;
2960                                         place_object(y, x, AM_GOOD);
2961                                         object_level = base_level;
2962                                         break;
2963                                 }
2964
2965                                 /* Nasty monster and treasure */
2966                                 case '8':
2967                                 {
2968                                         monster_level = base_level + 40;
2969                                         place_monster(y, x, PM_ALLOW_SLEEP);
2970                                         monster_level = base_level;
2971                                         object_level = base_level + 20;
2972                                         place_object(y, x, AM_GOOD | AM_GREAT);
2973                                         object_level = base_level;
2974                                         break;
2975                                 }
2976
2977                                 /* Monster and/or object */
2978                                 case ',':
2979                                 {
2980                                         if (randint0(100) < 50)
2981                                         {
2982                                                 monster_level = base_level + 3;
2983                                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
2984                                                 monster_level = base_level;
2985                                         }
2986                                         if (randint0(100) < 50)
2987                                         {
2988                                                 object_level = base_level + 7;
2989                                                 place_object(y, x, 0L);
2990                                                 object_level = base_level;
2991                                         }
2992                                         break;
2993                                 }
2994
2995                         }
2996                 }
2997         }
2998 }
2999
3000
3001 /*!
3002  * @brief タイプ7の部屋…v_info.txtより小型vaultを生成する / Type 7 -- simple vaults (see "v_info.txt")
3003  * @return なし
3004  */
3005 static bool build_type7(void)
3006 {
3007         vault_type *v_ptr = NULL;
3008         int dummy;
3009         int x, y;
3010         int xval, yval;
3011         int xoffset, yoffset;
3012         int transno;
3013
3014         /* Pick a lesser vault */
3015         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)
3016         {
3017                 /* Access a random vault record */
3018                 v_ptr = &v_info[randint0(max_v_idx)];
3019
3020                 /* Accept the first lesser vault */
3021                 if (v_ptr->typ == 7) break;
3022         }
3023
3024         /* No lesser vault found */
3025         if (dummy >= SAFE_MAX_ATTEMPTS)
3026         {
3027                 msg_print_wizard(CHEAT_DUNGEON, _("小型固定Vaultを配置できませんでした。", "Could not place lesser vault."));
3028                 return FALSE;
3029         }
3030
3031         /* pick type of transformation (0-7) */
3032         transno = randint0(8);
3033
3034         /* calculate offsets */
3035         x = v_ptr->wid;
3036         y = v_ptr->hgt;
3037
3038         /* Some huge vault cannot be ratated to fit in the dungeon */
3039         if (x+2 > cur_hgt-2)
3040         {
3041                 /* Forbid 90 or 270 degree ratation */
3042                 transno &= ~1;
3043         }
3044
3045         coord_trans(&x, &y, 0, 0, transno);
3046
3047         if (x < 0)
3048         {
3049                 xoffset = -x - 1;
3050         }
3051         else
3052         {
3053                 xoffset = 0;
3054         }
3055
3056         if (y < 0)
3057         {
3058                 yoffset = -y - 1;
3059         }
3060         else
3061         {
3062                 yoffset = 0;
3063         }
3064
3065         /* Find and reserve some space in the dungeon.  Get center of room. */
3066         if (!find_space(&yval, &xval, abs(y), abs(x))) return FALSE;
3067
3068 #ifdef FORCE_V_IDX
3069         v_ptr = &v_info[2];
3070 #endif
3071
3072         /* Message */
3073         msg_format_wizard(CHEAT_DUNGEON, _("小型Vault(%s)を生成しました。", "Lesser vault (%s)."), v_name + v_ptr->name);
3074
3075         /* Hack -- Build the vault */
3076         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,
3077                     v_text + v_ptr->text, xoffset, yoffset, transno);
3078
3079         return TRUE;
3080 }
3081
3082 /*!
3083  * @brief タイプ8の部屋…v_info.txtより大型vaultを生成する / Type 8 -- greater vaults (see "v_info.txt")
3084  * @return なし
3085  */
3086 static bool build_type8(void)
3087 {
3088         vault_type *v_ptr;
3089         int dummy;
3090         int xval, yval;
3091         int x, y;
3092         int transno;
3093         int xoffset, yoffset;
3094
3095         /* Pick a greater vault */
3096         for (dummy = 0; dummy < SAFE_MAX_ATTEMPTS; dummy++)
3097         {
3098                 /* Access a random vault record */
3099                 v_ptr = &v_info[randint0(max_v_idx)];
3100
3101                 /* Accept the first greater vault */
3102                 if (v_ptr->typ == 8) break;
3103         }
3104
3105         /* No greater vault found */
3106         if (dummy >= SAFE_MAX_ATTEMPTS)
3107         {
3108                 msg_print_wizard(CHEAT_DUNGEON, _("大型固定Vaultを配置できませんでした。", "Could not place greater vault."));
3109                 return FALSE;
3110         }
3111
3112         /* pick type of transformation (0-7) */
3113         transno = randint0(8);
3114
3115         /* calculate offsets */
3116         x = v_ptr->wid;
3117         y = v_ptr->hgt;
3118
3119         /* Some huge vault cannot be ratated to fit in the dungeon */
3120         if (x+2 > cur_hgt-2)
3121         {
3122                 /* Forbid 90 or 270 degree ratation */
3123                 transno &= ~1;
3124         }
3125
3126         coord_trans(&x, &y, 0, 0, transno);
3127
3128         if (x < 0)
3129         {
3130                 xoffset = - x - 1;
3131         }
3132         else
3133         {
3134                 xoffset = 0;
3135         }
3136
3137         if (y < 0)
3138         {
3139                 yoffset = - y - 1;
3140         }
3141         else
3142         {
3143                 yoffset = 0;
3144         }
3145
3146         /*
3147          * Try to allocate space for room.  If fails, exit
3148          *
3149          * Hack -- Prepare a bit larger space (+2, +2) to
3150          * prevent generation of vaults with no-entrance.
3151          */
3152         /* Find and reserve some space in the dungeon.  Get center of room. */
3153         if (!find_space(&yval, &xval, abs(y) + 2, abs(x) + 2)) return FALSE;
3154
3155 #ifdef FORCE_V_IDX
3156         v_ptr = &v_info[76 + randint1(3)];
3157 #endif
3158
3159         msg_format_wizard(CHEAT_DUNGEON, _("大型固定Vault(%s)を生成しました。", "Greater vault (%s)."), v_name + v_ptr->name);
3160
3161         /* Hack -- Build the vault */
3162         build_vault(yval, xval, v_ptr->hgt, v_ptr->wid,
3163                     v_text + v_ptr->text, xoffset, yoffset, transno);
3164
3165         return TRUE;
3166 }
3167
3168 /*
3169  * Structure to hold all "fill" data
3170  */
3171
3172 typedef struct fill_data_type fill_data_type;
3173
3174 struct fill_data_type
3175 {
3176         /* area size */
3177         int xmin;
3178         int ymin;
3179         int xmax;
3180         int ymax;
3181
3182         /* cutoffs */
3183         int c1;
3184         int c2;
3185         int c3;
3186
3187         /* features to fill with */
3188         int feat1;
3189         int feat2;
3190         int feat3;
3191
3192         int info1;
3193         int info2;
3194         int info3;
3195
3196         /* number of filled squares */
3197         int amount;
3198 };
3199
3200 static fill_data_type fill_data;
3201
3202
3203 /* Store routine for the fractal cave generator */
3204 /* this routine probably should be an inline function or a macro. */
3205 static void store_height(int x, int y, int val)
3206 {
3207         /* if on boundary set val > cutoff so walls are not as square */
3208         if (((x == fill_data.xmin) || (y == fill_data.ymin) ||
3209              (x == fill_data.xmax) || (y == fill_data.ymax)) &&
3210             (val <= fill_data.c1)) val = fill_data.c1 + 1;
3211
3212         /* store the value in height-map format */
3213         cave[y][x].feat = (s16b)val;
3214
3215         return;
3216 }
3217
3218
3219 /*
3220 * Explanation of the plasma fractal algorithm:
3221 *
3222 * A grid of points is created with the properties of a 'height-map'
3223 * This is done by making the corners of the grid have a random value.
3224 * The grid is then subdivided into one with twice the resolution.
3225 * The new points midway between two 'known' points can be calculated
3226 * by taking the average value of the 'known' ones and randomly adding
3227 * or subtracting an amount proportional to the distance between those
3228 * points.  The final 'middle' points of the grid are then calculated
3229 * by averaging all four of the originally 'known' corner points.  An
3230 * random amount is added or subtracted from this to get a value of the
3231 * height at that point.  The scaling factor here is adjusted to the
3232 * slightly larger distance diagonally as compared to orthogonally.
3233 *
3234 * This is then repeated recursively to fill an entire 'height-map'
3235 * A rectangular map is done the same way, except there are different
3236 * scaling factors along the x and y directions.
3237 *
3238 * A hack to change the amount of correlation between points is done using
3239 * the grd variable.  If the current step size is greater than grd then
3240 * the point will be random, otherwise it will be calculated by the
3241 * above algorithm.  This makes a maximum distance at which two points on
3242 * the height map can affect each other.
3243 *
3244 * How fractal caves are made:
3245 *
3246 * When the map is complete, a cut-off value is used to create a cave.
3247 * Heights below this value are "floor", and heights above are "wall".
3248 * This also can be used to create lakes, by adding more height levels
3249 * representing shallow and deep water/ lava etc.
3250 *
3251 * The grd variable affects the width of passages.
3252 * The roug variable affects the roughness of those passages
3253 *
3254 * The tricky part is making sure the created cave is connected.  This
3255 * is done by 'filling' from the inside and only keeping the 'filled'
3256 * floor.  Walls bounding the 'filled' floor are also kept.  Everything
3257 * else is converted to the normal _extra_.
3258  */
3259
3260
3261 /*
3262  *  Note that this uses the cave.feat array in a very hackish way
3263  *  the values are first set to zero, and then each array location
3264  *  is used as a "heightmap"
3265  *  The heightmap then needs to be converted back into the "feat" format.
3266  *
3267  *  grd=level at which fractal turns on.  smaller gives more mazelike caves
3268  *  roug=roughness level.  16=normal.  higher values make things more convoluted
3269  *    small values are good for smooth walls.
3270  *  size=length of the side of the square cave system.
3271  */
3272 static void generate_hmap(int y0, int x0, int xsiz, int ysiz, int grd, int roug, int cutoff)
3273 {
3274         int xhsize, yhsize, xsize, ysize, maxsize;
3275
3276         /*
3277          * fixed point variables- these are stored as 256 x normal value
3278          * this gives 8 binary places of fractional part + 8 places of normal part
3279          */
3280
3281         u16b xstep, xhstep, ystep, yhstep;
3282         u16b xstep2, xhstep2, ystep2, yhstep2;
3283         u16b i, j, ii, jj, diagsize, xxsize, yysize;
3284
3285         /* Cache for speed */
3286         u16b xm, xp, ym, yp;
3287
3288         /* redefine size so can change the value if out of range */
3289         xsize = xsiz;
3290         ysize = ysiz;
3291
3292         /* Paranoia about size of the system of caves */
3293         if (xsize > 254) xsize = 254;
3294         if (xsize < 4) xsize = 4;
3295         if (ysize > 254) ysize = 254;
3296         if (ysize < 4) ysize = 4;
3297
3298         /* get offsets to middle of array */
3299         xhsize = xsize / 2;
3300         yhsize = ysize / 2;
3301
3302         /* fix rounding problem */
3303         xsize = xhsize * 2;
3304         ysize = yhsize * 2;
3305
3306         /* get limits of region */
3307         fill_data.xmin = x0 - xhsize;
3308         fill_data.ymin = y0 - yhsize;
3309         fill_data.xmax = x0 + xhsize;
3310         fill_data.ymax = y0 + yhsize;
3311
3312         /* Store cutoff in global for quick access */
3313         fill_data.c1 = cutoff;
3314
3315         /*
3316         * Scale factor for middle points:
3317         * About sqrt(2) * 256 - correct for a square lattice
3318         * approximately correct for everything else.
3319          */
3320         diagsize = 362;
3321
3322         /* maximum of xsize and ysize */
3323         maxsize = (xsize > ysize) ? xsize : ysize;
3324
3325         /* Clear the section */
3326         for (i = 0; i <= xsize; i++)
3327         {
3328                 for (j = 0; j <= ysize; j++)
3329                 {
3330                         /* -1 is a flag for "not done yet" */
3331                         cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].feat = -1;
3332                         /* Clear icky flag because may be redoing the cave */
3333                         cave[(int)(fill_data.ymin + j)][(int)(fill_data.xmin + i)].info &= ~(CAVE_ICKY);
3334                 }
3335         }
3336
3337         /* Boundaries are walls */
3338         cave[fill_data.ymin][fill_data.xmin].feat = (s16b)maxsize;
3339         cave[fill_data.ymax][fill_data.xmin].feat = (s16b)maxsize;
3340         cave[fill_data.ymin][fill_data.xmax].feat = (s16b)maxsize;
3341         cave[fill_data.ymax][fill_data.xmax].feat = (s16b)maxsize;
3342
3343         /* Set the middle square to be an open area. */
3344         cave[y0][x0].feat = 0;
3345
3346         /* Initialize the step sizes */
3347         xstep = xhstep = xsize * 256;
3348         ystep = yhstep = ysize * 256;
3349         xxsize = xsize * 256;
3350         yysize = ysize * 256;
3351
3352         /*
3353          * Fill in the rectangle with fractal height data -
3354          * like the 'plasma fractal' in fractint.
3355          */
3356         while ((xhstep > 256) || (yhstep > 256))
3357         {
3358                 /* Halve the step sizes */
3359                 xstep = xhstep;
3360                 xhstep /= 2;
3361                 ystep = yhstep;
3362                 yhstep /= 2;
3363
3364                 /* cache well used values */
3365                 xstep2 = xstep / 256;
3366                 ystep2 = ystep / 256;
3367
3368                 xhstep2 = xhstep / 256;
3369                 yhstep2 = yhstep / 256;
3370
3371                 /* middle top to bottom. */
3372                 for (i = xhstep; i <= xxsize - xhstep; i += xstep)
3373                 {
3374                         for (j = 0; j <= yysize; j += ystep)
3375                         {
3376                                 /* cache often used values */
3377                                 ii = i / 256 + fill_data.xmin;
3378                                 jj = j / 256 + fill_data.ymin;
3379
3380                                 /* Test square */
3381                                 if (cave[jj][ii].feat == -1)
3382                                 {
3383                                         if (xhstep2 > grd)
3384                                         {
3385                                                 /* If greater than 'grid' level then is random */
3386                                                 store_height(ii, jj, randint1(maxsize));
3387                                         }
3388                                         else
3389                                         {
3390                                                 /* Average of left and right points +random bit */
3391                                                 store_height(ii, jj,
3392                                                         (cave[jj][fill_data.xmin + (i - xhstep) / 256].feat
3393                                                          + cave[jj][fill_data.xmin + (i + xhstep) / 256].feat) / 2
3394                                                          + (randint1(xstep2) - xhstep2) * roug / 16);
3395                                         }
3396                                 }
3397                         }
3398                 }
3399
3400
3401                 /* middle left to right. */
3402                 for (j = yhstep; j <= yysize - yhstep; j += ystep)
3403                 {
3404                         for (i = 0; i <= xxsize; i += xstep)
3405                         {
3406                                 /* cache often used values */
3407                                 ii = i / 256 + fill_data.xmin;
3408                                 jj = j / 256 + fill_data.ymin;
3409
3410                                 /* Test square */
3411                                 if (cave[jj][ii].feat == -1)
3412                                 {
3413                                         if (xhstep2 > grd)
3414                                         {
3415                                                 /* If greater than 'grid' level then is random */
3416                                                 store_height(ii, jj, randint1(maxsize));
3417                                         }
3418                                         else
3419                                         {
3420                                                 /* Average of up and down points +random bit */
3421                                                 store_height(ii, jj,
3422                                                         (cave[fill_data.ymin + (j - yhstep) / 256][ii].feat
3423                                                         + cave[fill_data.ymin + (j + yhstep) / 256][ii].feat) / 2
3424                                                         + (randint1(ystep2) - yhstep2) * roug / 16);
3425                                         }
3426                                 }
3427                         }
3428                 }
3429
3430                 /* center. */
3431                 for (i = xhstep; i <= xxsize - xhstep; i += xstep)
3432                 {
3433                         for (j = yhstep; j <= yysize - yhstep; j += ystep)
3434                         {
3435                                 /* cache often used values */
3436                                 ii = i / 256 + fill_data.xmin;
3437                                 jj = j / 256 + fill_data.ymin;
3438
3439                                 /* Test square */
3440                                 if (cave[jj][ii].feat == -1)
3441                                 {
3442                                         if (xhstep2 > grd)
3443                                         {
3444                                                 /* If greater than 'grid' level then is random */
3445                                                 store_height(ii, jj, randint1(maxsize));
3446                                         }
3447                                         else
3448                                         {
3449                                                 /* Cache reused values. */
3450                                                 xm = fill_data.xmin + (i - xhstep) / 256;
3451                                                 xp = fill_data.xmin + (i + xhstep) / 256;
3452                                                 ym = fill_data.ymin + (j - yhstep) / 256;
3453                                                 yp = fill_data.ymin + (j + yhstep) / 256;
3454
3455                                                 /*
3456                                                  * Average over all four corners + scale by diagsize to
3457                                                  * reduce the effect of the square grid on the shape of the fractal
3458                                                  */
3459                                                 store_height(ii, jj,
3460                                                         (cave[ym][xm].feat + cave[yp][xm].feat
3461                                                         + cave[ym][xp].feat + cave[yp][xp].feat) / 4
3462                                                         + (randint1(xstep2) - xhstep2) * (diagsize / 16) / 256 * roug);
3463                                         }
3464                                 }
3465                         }
3466                 }
3467         }
3468 }
3469
3470
3471 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)
3472 {
3473         /*
3474          * function used to convert from height-map back to the
3475          *  normal angband cave format
3476          */
3477         if (cave[y][x].info & CAVE_ICKY)
3478         {
3479                 /* already done */
3480                 return FALSE;
3481         }
3482         else
3483         {
3484                 /* Show that have looked at this square */
3485                 cave[y][x].info|= (CAVE_ICKY);
3486
3487                 /* Use cutoffs c1-c3 to allocate regions of floor /water/ lava etc. */
3488                 if (cave[y][x].feat <= c1)
3489                 {
3490                         /* 25% of the time use the other tile : it looks better this way */
3491                         if (randint1(100) < 75)
3492                         {
3493                                 cave[y][x].feat = (s16b)feat1;
3494                                 cave[y][x].info &= ~(CAVE_MASK);
3495                                 cave[y][x].info |= info1;
3496                                 return TRUE;
3497                         }
3498                         else
3499                         {
3500                                 cave[y][x].feat = (s16b)feat2;
3501                                 cave[y][x].info &= ~(CAVE_MASK);
3502                                 cave[y][x].info |= info2;
3503                                 return TRUE;
3504                         }
3505                 }
3506                 else if (cave[y][x].feat <= c2)
3507                 {
3508                         /* 25% of the time use the other tile : it looks better this way */
3509                         if (randint1(100) < 75)
3510                         {
3511                                 cave[y][x].feat = (s16b)feat2;
3512                                 cave[y][x].info &= ~(CAVE_MASK);
3513                                 cave[y][x].info |= info2;
3514                                 return TRUE;
3515                         }
3516                         else
3517                         {
3518                                 cave[y][x].feat = (s16b)feat1;
3519                                 cave[y][x].info &= ~(CAVE_MASK);
3520                                 cave[y][x].info |= info1;
3521                                 return TRUE;
3522                         }
3523                 }
3524                 else if (cave[y][x].feat <= c3)
3525                 {
3526                         cave[y][x].feat = (s16b)feat3;
3527                         cave[y][x].info &= ~(CAVE_MASK);
3528                         cave[y][x].info |= info3;
3529                         return TRUE;
3530                 }
3531                 /* if greater than cutoff then is a wall */
3532                 else
3533                 {
3534                         place_outer_bold(y, x);
3535                         return FALSE;
3536                 }
3537         }
3538 }
3539
3540
3541
3542
3543 /*
3544  * Quick and nasty fill routine used to find the connected region
3545  * of floor in the middle of the cave
3546  */
3547 static void cave_fill(POSITION y, POSITION x)
3548 {
3549         int i, j, d;
3550         int ty, tx;
3551
3552         int flow_tail = 1;
3553         int flow_head = 0;
3554
3555
3556         /*** Start Grid ***/
3557
3558         /* Enqueue that entry */
3559         temp_y[0] = y;
3560         temp_x[0] = x;
3561
3562
3563         /* Now process the queue */
3564         while (flow_head != flow_tail)
3565         {
3566                 /* Extract the next entry */
3567                 ty = temp_y[flow_head];
3568                 tx = temp_x[flow_head];
3569
3570                 /* Forget that entry */
3571                 if (++flow_head == TEMP_MAX) flow_head = 0;
3572
3573                 /* Add the "children" */
3574                 for (d = 0; d < 8; d++)
3575                 {
3576                         int old_head = flow_tail;
3577
3578                         /* Child location */
3579                         j = ty + ddy_ddd[d];
3580                         i = tx + ddx_ddd[d];
3581
3582                         /* Paranoia Don't leave the cave */
3583                         if (!in_bounds(j, i))
3584                         {
3585                                 /* affect boundary */
3586                                 cave[j][i].info |= CAVE_ICKY;
3587 /*                              return; */
3588                         }
3589
3590                         /* If within bounds */
3591                         else if ((i > fill_data.xmin) && (i < fill_data.xmax)
3592                                 && (j > fill_data.ymin) && (j < fill_data.ymax))
3593                         {
3594                                 /* If not a wall or floor done before */
3595                                 if (hack_isnt_wall(j, i,
3596                                         fill_data.c1, fill_data.c2, fill_data.c3,
3597                                         fill_data.feat1, fill_data.feat2, fill_data.feat3,
3598                                         fill_data.info1, fill_data.info2, fill_data.info3))
3599                                 {
3600                                         /* Enqueue that entry */
3601                                         temp_y[flow_tail] = (byte_hack)j;
3602                                         temp_x[flow_tail] = (byte_hack)i;
3603
3604                                         /* Advance the queue */
3605                                         if (++flow_tail == TEMP_MAX) flow_tail = 0;
3606
3607                                         /* Hack -- Overflow by forgetting new entry */
3608                                         if (flow_tail == flow_head)
3609                                         {
3610                                                 flow_tail = old_head;
3611                                         }
3612                                         else
3613                                         {
3614                                                 /* keep tally of size of cave system */
3615                                                 (fill_data.amount)++;
3616                                         }
3617                                 }
3618                         }
3619                         else
3620                         {
3621                                 /* affect boundary */
3622                                 cave[j][i].info |= CAVE_ICKY;
3623                         }
3624                 }
3625         }
3626 }
3627
3628
3629 static bool generate_fracave(int y0, int x0, int xsize, int ysize, int cutoff, bool light, bool room)
3630 {
3631         int x, y, i, xhsize, yhsize;
3632
3633         /* offsets to middle from corner */
3634         xhsize = xsize / 2;
3635         yhsize = ysize / 2;
3636
3637
3638         /*
3639          * select region connected to center of cave system
3640          * this gets rid of alot of isolated one-sqaures that
3641          * can make teleport traps instadeaths...
3642          */
3643
3644         /* cutoffs */
3645         fill_data.c1 = cutoff;
3646         fill_data.c2 = 0;
3647         fill_data.c3 = 0;
3648
3649         /* features to fill with */
3650         fill_data.feat1 = floor_type[randint0(100)];
3651         fill_data.feat2 = floor_type[randint0(100)];
3652         fill_data.feat3 = floor_type[randint0(100)];
3653
3654         fill_data.info1 = CAVE_FLOOR;
3655         fill_data.info2 = CAVE_FLOOR;
3656         fill_data.info3 = CAVE_FLOOR;
3657
3658         /* number of filled squares */
3659         fill_data.amount = 0;
3660
3661         cave_fill((byte)y0, (byte)x0);
3662
3663         /* if tally too small, try again */
3664         if (fill_data.amount < 10)
3665         {
3666                 /* too small - clear area and try again later */
3667                 for (x = 0; x <= xsize; ++x)
3668                 {
3669                         for (y = 0; y <= ysize; ++y)
3670                         {
3671                                 place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3672                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
3673                         }
3674                 }
3675                 return FALSE;
3676         }
3677
3678         /*
3679          * Do boundarys-check to see if they are next to a filled region
3680          * If not then they are set to normal granite
3681          * If so then they are marked as room walls.
3682          */
3683         for (i = 0; i <= xsize; ++i)
3684         {
3685                 /* top boundary */
3686                 if ((cave[0 + y0 - yhsize][i + x0 - xhsize].info & CAVE_ICKY) && (room))
3687                 {
3688                         /* Next to a 'filled' region? - set to be room walls */
3689                         place_outer_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3690                         if (light) cave[y0 + 0 - yhsize][x0 + i - xhsize].info |= (CAVE_GLOW);
3691                         cave[y0 + 0 - yhsize][x0 + i - xhsize].info |= (CAVE_ROOM);
3692                         place_outer_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3693                 }
3694                 else
3695                 {
3696                         /* set to be normal granite */
3697                         place_extra_bold(y0 + 0 - yhsize, x0 + i - xhsize);
3698                 }
3699
3700                 /* bottom boundary */
3701                 if ((cave[ysize + y0 - yhsize][i + x0 - xhsize].info & CAVE_ICKY) && (room))
3702                 {
3703                         /* Next to a 'filled' region? - set to be room walls */
3704                         place_outer_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3705                         if (light) cave[y0 + ysize - yhsize][x0 + i - xhsize].info|=(CAVE_GLOW);
3706                         cave[y0 + ysize - yhsize][x0 + i - xhsize].info|=(CAVE_ROOM);
3707                         place_outer_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3708                 }
3709                 else
3710                 {
3711                         /* set to be normal granite */
3712                         place_extra_bold(y0 + ysize - yhsize, x0 + i - xhsize);
3713                 }
3714
3715                 /* clear the icky flag-don't need it any more */
3716                 cave[y0 + 0 - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
3717                 cave[y0 + ysize - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
3718         }
3719
3720         /* Do the left and right boundaries minus the corners (done above) */
3721         for (i = 1; i < ysize; ++i)
3722         {
3723                 /* left boundary */
3724                 if ((cave[i + y0 - yhsize][0 + x0 - xhsize].info & CAVE_ICKY) && room)
3725                 {
3726                         /* room boundary */
3727                         place_outer_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3728                         if (light) cave[y0 + i - yhsize][x0 + 0 - xhsize].info |= (CAVE_GLOW);
3729                         cave[y0 + i - yhsize][x0 + 0 - xhsize].info |= (CAVE_ROOM);
3730                         place_outer_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3731                 }
3732                 else
3733                 {
3734                         /* outside room */
3735                         place_extra_bold(y0 + i - yhsize, x0 + 0 - xhsize);
3736                 }
3737                 /* right boundary */
3738                 if ((cave[i + y0 - yhsize][xsize + x0 - xhsize].info & CAVE_ICKY) && room)
3739                 {
3740                         /* room boundary */
3741                         place_outer_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3742                         if (light) cave[y0 + i - yhsize][x0 + xsize - xhsize].info |= (CAVE_GLOW);
3743                         cave[y0 + i - yhsize][x0 + xsize - xhsize].info |= (CAVE_ROOM);
3744                         place_outer_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3745                 }
3746                 else
3747                 {
3748                         /* outside room */
3749                         place_extra_bold(y0 + i - yhsize, x0 + xsize - xhsize);
3750                 }
3751
3752                 /* clear icky flag -done with it */
3753                 cave[y0 + i - yhsize][x0 + 0 - xhsize].info &= ~(CAVE_ICKY);
3754                 cave[y0 + i - yhsize][x0 + xsize - xhsize].info &= ~(CAVE_ICKY);
3755         }
3756
3757
3758         /* Do the rest: convert back to the normal format */
3759         for (x = 1; x < xsize; ++x)
3760         {
3761                 for (y = 1; y < ysize; ++y)
3762                 {
3763                         if (is_floor_bold(y0 + y - yhsize, x0 + x - xhsize) &&
3764                             (cave[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY))
3765                         {
3766                                 /* Clear the icky flag in the filled region */
3767                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~CAVE_ICKY;
3768
3769                                 /* Set appropriate flags */
3770                                 if (light) cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_GLOW);
3771                                 if (room) cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_ROOM);
3772                         }
3773                         else if (is_outer_bold(y0 + y - yhsize, x0 + x - xhsize) &&
3774                                  (cave[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY))
3775                         {
3776                                 /* Walls */
3777                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY);
3778                                 if (light) cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_GLOW);
3779                                 if (room)
3780                                 {
3781                                         cave[y0 + y - yhsize][x0 + x - xhsize].info |= (CAVE_ROOM);
3782                                 }
3783                                 else
3784                                 {
3785
3786                                         place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3787                                         cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ROOM);
3788                                 }
3789                         }
3790                         else
3791                         {
3792                                 /* Clear the unconnected regions */
3793                                 place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
3794                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
3795                         }
3796                 }
3797         }
3798
3799         /*
3800          * XXX XXX XXX There is a slight problem when tunnels pierce the caves:
3801          * Extra doors appear inside the system.  (Its not very noticeable though.)
3802          * This can be removed by "filling" from the outside in.  This allows a separation
3803          * from _outer_ with _inner_.  (Internal walls are  _outer_ instead.)
3804          * The extra effort for what seems to be only a minor thing (even non-existant if you
3805          * think of the caves not as normal rooms, but as holes in the dungeon), doesn't seem
3806          * worth it.
3807          */
3808
3809         return TRUE;
3810 }
3811
3812
3813 /*!
3814  * @brief タイプ9の部屋…フラクタルカーブによる洞窟生成 / Type 9 -- Driver routine to create fractal cave system
3815  * @return なし
3816  */
3817 static bool build_type9(void)
3818 {
3819         int grd, roug, cutoff, xsize, ysize, y0, x0;
3820
3821         bool done, light, room;
3822
3823         /* get size: note 'Evenness'*/
3824         xsize = randint1(22) * 2 + 6;
3825         ysize = randint1(15) * 2 + 6;
3826
3827         /* Find and reserve some space in the dungeon.  Get center of room. */
3828         if (!find_space(&y0, &x0, ysize + 1, xsize + 1))
3829         {
3830                 /* Limit to the minimum room size, and retry */
3831                 xsize = 8;
3832                 ysize = 8;
3833
3834                 /* Find and reserve some space in the dungeon.  Get center of room. */
3835                 if (!find_space(&y0, &x0, ysize + 1, xsize + 1))
3836                 {
3837                         /*
3838                          * Still no space?!
3839                          * Try normal room
3840                          */
3841                         return build_type1();
3842                 }
3843         }
3844
3845         light = done = FALSE;
3846         room = TRUE;
3847
3848         if ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
3849
3850         while (!done)
3851         {
3852                 /* Note: size must be even or there are rounding problems
3853                 * This causes the tunnels not to connect properly to the room */
3854
3855                 /* testing values for these parameters feel free to adjust */
3856                 grd = 1 << (randint0(4));
3857
3858                 /* want average of about 16 */
3859                 roug = randint1(8) * randint1(4);
3860
3861                 /* about size/2 */
3862                 cutoff = randint1(xsize / 4) + randint1(ysize / 4) +
3863                          randint1(xsize / 4) + randint1(ysize / 4);
3864
3865                 /* make it */
3866                 generate_hmap(y0, x0, xsize, ysize, grd, roug, cutoff);
3867
3868                 /* Convert to normal format + clean up */
3869                 done = generate_fracave(y0, x0, xsize, ysize, cutoff, light, room);
3870         }
3871
3872         return TRUE;
3873 }
3874
3875 #ifdef ALLOW_CAVERNS_AND_LAKES
3876 /*
3877  * Builds a cave system in the center of the dungeon.
3878  */
3879 void build_cavern(void)
3880 {
3881         int grd, roug, cutoff, xsize, ysize, x0, y0;
3882         bool done, light;
3883
3884         light = done = FALSE;
3885         if ((dun_level <= randint1(50)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
3886
3887         /* Make a cave the size of the dungeon */
3888         xsize = cur_wid - 1;
3889         ysize = cur_hgt - 1;
3890         x0 = xsize / 2;
3891         y0 = ysize / 2;
3892
3893         /* Paranoia: make size even */
3894         xsize = x0 * 2;
3895         ysize = y0 * 2;
3896
3897         while (!done)
3898         {
3899                 /* testing values for these parameters: feel free to adjust */
3900                 grd = randint1(4) + 4;
3901
3902                 /* want average of about 16 */
3903                 roug = randint1(8) * randint1(4);
3904
3905                 /* about size/2 */
3906                 cutoff = xsize / 2;
3907
3908                  /* make it */
3909                 generate_hmap(y0 + 1, x0 + 1, xsize, ysize, grd, roug, cutoff);
3910
3911                 /* Convert to normal format+ clean up */
3912                 done = generate_fracave(y0 + 1, x0 + 1, xsize, ysize, cutoff, light, FALSE);
3913         }
3914 }
3915
3916 static bool generate_lake(int y0, int x0, int xsize, int ysize, int c1, int c2, int c3, int type)
3917 {
3918         int x, y, i, xhsize, yhsize;
3919         int feat1, feat2, feat3;
3920
3921         /* offsets to middle from corner */
3922         xhsize = xsize / 2;
3923         yhsize = ysize / 2;
3924
3925         /* Get features based on type */
3926         switch (type)
3927         {
3928         case LAKE_T_LAVA: /* Lava */
3929                 feat1 = feat_deep_lava;
3930                 feat2 = feat_shallow_lava;
3931                 feat3 = floor_type[randint0(100)];
3932                 break;
3933         case LAKE_T_WATER: /* Water */
3934                 feat1 = feat_deep_water;
3935                 feat2 = feat_shallow_water;
3936                 feat3 = floor_type[randint0(100)];
3937                 break;
3938         case LAKE_T_CAVE: /* Collapsed cave */
3939                 feat1 = floor_type[randint0(100)];
3940                 feat2 = floor_type[randint0(100)];
3941                 feat3 = feat_rubble;
3942                 break;
3943         case LAKE_T_EARTH_VAULT: /* Earth vault */
3944                 feat1 = feat_rubble;
3945                 feat2 = floor_type[randint0(100)];
3946                 feat3 = feat_rubble;
3947                 break;
3948         case LAKE_T_AIR_VAULT: /* Air vault */
3949                 feat1 = feat_grass;
3950                 feat2 = feat_tree;
3951                 feat3 = feat_grass;
3952                 break;
3953         case LAKE_T_WATER_VAULT: /* Water vault */
3954                 feat1 = feat_shallow_water;
3955                 feat2 = feat_deep_water;
3956                 feat3 = feat_shallow_water;
3957                 break;
3958         case LAKE_T_FIRE_VAULT: /* Fire Vault */
3959                 feat1 = feat_shallow_lava;
3960                 feat2 = feat_deep_lava;
3961                 feat3 = feat_shallow_lava;
3962                 break;
3963
3964         /* Paranoia */
3965         default: return FALSE;
3966         }
3967
3968         /*
3969          * select region connected to center of cave system
3970          * this gets rid of alot of isolated one-sqaures that
3971          * can make teleport traps instadeaths...
3972          */
3973
3974         /* cutoffs */
3975         fill_data.c1 = c1;
3976         fill_data.c2 = c2;
3977         fill_data.c3 = c3;
3978
3979         /* features to fill with */
3980         fill_data.feat1 = feat1;
3981         fill_data.feat2 = feat2;
3982         fill_data.feat3 = feat3;
3983
3984         fill_data.info1 = 0;
3985         fill_data.info2 = 0;
3986         fill_data.info3 = 0;
3987
3988         /* number of filled squares */
3989         fill_data.amount = 0;
3990
3991         /* select region connected to center of cave system
3992         * this gets rid of alot of isolated one-sqaures that
3993         * can make teleport traps instadeaths... */
3994         cave_fill((byte)y0, (byte)x0);
3995
3996         /* if tally too small, try again */
3997         if (fill_data.amount < 10)
3998         {
3999                 /* too small -clear area and try again later */
4000                 for (x = 0; x <= xsize; ++x)
4001                 {
4002                         for (y = 0; y <= ysize; ++y)
4003                         {
4004                                 place_floor_bold(y0 + y - yhsize, x0 + x - xhsize);
4005                                 cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY);
4006                         }
4007                 }
4008                 return FALSE;
4009         }
4010
4011         /* Do boundarys- set to normal granite */
4012         for (i = 0; i <= xsize; ++i)
4013         {
4014                 place_extra_bold(y0 + 0 - yhsize, x0 + i - xhsize);
4015                 place_extra_bold(y0 + ysize - yhsize, x0 + i - xhsize);
4016
4017                 /* clear the icky flag-don't need it any more */
4018                 cave[y0 + 0 - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
4019                 cave[y0 + ysize - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
4020         }
4021
4022         /* Do the left and right boundaries minus the corners (done above) */
4023
4024         for (i = 1; i < ysize; ++i)
4025         {
4026                 place_extra_bold(y0 + i - yhsize, x0 + 0 - xhsize);
4027                 place_extra_bold(y0 + i - yhsize, x0 + xsize - xhsize);
4028
4029                 /* clear icky flag -done with it */
4030                 cave[y0 + i - yhsize][x0 + 0 - xhsize].info &= ~(CAVE_ICKY);
4031                 cave[y0 + i - yhsize][x0 + xsize - xhsize].info &= ~(CAVE_ICKY);
4032         }
4033
4034
4035         /* Do the rest: convert back to the normal format */
4036         for (x = 1; x < xsize; ++x)
4037         {
4038                 for (y = 1; y < ysize; ++y)
4039                 {
4040                         /* Fill unconnected regions with granite */
4041                         if ((!(cave[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY)) ||
4042                                 is_outer_bold(y0 + y - yhsize, x0 + x - xhsize))
4043                                 place_extra_bold(y0 + y - yhsize, x0 + x - xhsize);
4044
4045                         /* turn off icky flag (no longer needed.) */
4046                         cave[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
4047
4048                         /* Light lava */
4049                         if (cave_have_flag_bold(y0 + y - yhsize, x0 + x - xhsize, FF_LAVA))
4050                         {
4051                                 if (!(d_info[dungeon_type].flags1 & DF1_DARKNESS)) cave[y0 + y - yhsize][x0 + x - xhsize].info |= CAVE_GLOW;
4052                         }
4053                 }
4054         }
4055
4056         return TRUE;
4057 }
4058
4059
4060 /*
4061  * makes a lake/collapsed cave system in the center of the dungeon
4062  */
4063 void build_lake(int type)
4064 {
4065         int grd, roug, xsize, ysize, x0, y0;
4066         bool done = FALSE;
4067         int c1, c2, c3;
4068
4069         /* paranoia - exit if lake type out of range. */
4070         if ((type < LAKE_T_LAVA) || (type > LAKE_T_FIRE_VAULT))
4071         {
4072                 msg_format("Invalid lake type (%d)", type);
4073                 return;
4074         }
4075
4076         /* Make the size of the dungeon */
4077         xsize = cur_wid - 1;
4078         ysize = cur_hgt - 1;
4079         x0 = xsize / 2;
4080         y0 = ysize / 2;
4081
4082         /* Paranoia: make size even */
4083         xsize = x0 * 2;
4084         ysize = y0 * 2;
4085
4086         while (!done)
4087         {
4088                 /* testing values for these parameters: feel free to adjust */
4089                 grd = randint1(3) + 4;
4090
4091                 /* want average of about 16 */
4092                 roug = randint1(8) * randint1(4);
4093
4094                 /* Make up size of various componants */
4095                 /* Floor */
4096                 c3 = 3 * xsize / 4;
4097
4098                 /* Deep water/lava */
4099                 c1 = randint0(c3 / 2) + randint0(c3 / 2) - 5;
4100
4101                 /* Shallow boundary */
4102                 c2 = (c1 + c3) / 2;
4103
4104                 /* make it */
4105                 generate_hmap(y0 + 1, x0 + 1, xsize, ysize, grd, roug, c3);
4106
4107                 /* Convert to normal format+ clean up */
4108                 done = generate_lake(y0 + 1, x0 + 1, xsize, ysize, c1, c2, c3, type);
4109         }
4110 }
4111 #endif /* ALLOW_CAVERNS_AND_LAKES */
4112
4113
4114 /*
4115  * Routine used by the random vault creators to add a door to a location
4116  * Note that range checking has to be done in the calling routine.
4117  *
4118  * The doors must be INSIDE the allocated region.
4119  */
4120 static void add_door(int x, int y)
4121 {
4122         /* Need to have a wall in the center square */
4123         if (!is_outer_bold(y, x)) return;
4124
4125         /* look at:
4126          *  x#x
4127          *  .#.
4128          *  x#x
4129          *
4130          *  where x=don't care
4131          *  .=floor, #=wall
4132          */
4133
4134         if (is_floor_bold(y-1,x) && is_floor_bold(y+1,x) &&
4135             (is_outer_bold(y, x - 1) && is_outer_bold(y, x + 1)))
4136         {
4137                 /* secret door */
4138                 place_secret_door(y, x, DOOR_DEFAULT);
4139
4140                 /* set boundarys so don't get wide doors */
4141                 place_solid_bold(y, x - 1);
4142                 place_solid_bold(y, x + 1);
4143         }
4144
4145
4146         /* look at:
4147          *  x#x
4148          *  .#.
4149          *  x#x
4150          *
4151          *  where x = don't care
4152          *  .=floor, #=wall
4153          */
4154         if (is_outer_bold(y - 1, x) && is_outer_bold(y + 1, x) &&
4155             is_floor_bold(y,x-1) && is_floor_bold(y,x+1))
4156         {
4157                 /* secret door */
4158                 place_secret_door(y, x, DOOR_DEFAULT);
4159
4160                 /* set boundarys so don't get wide doors */
4161                 place_solid_bold(y - 1, x);
4162                 place_solid_bold(y + 1, x);
4163         }
4164 }
4165
4166
4167 /*
4168  * Routine that fills the empty areas of a room with treasure and monsters.
4169  */
4170 static void fill_treasure(int x1, int x2, int y1, int y2, int difficulty)
4171 {
4172         int x, y, cx, cy, size;
4173         s32b value;
4174
4175         /* center of room:*/
4176         cx = (x1 + x2) / 2;
4177         cy = (y1 + y2) / 2;
4178
4179         /* Rough measure of size of vault= sum of lengths of sides */
4180         size = abs(x2 - x1) + abs(y2 - y1);
4181
4182         for (x = x1; x <= x2; x++)
4183         {
4184                 for (y = y1; y <= y2; y++)
4185                 {
4186                         /* Thing added based on distance to center of vault
4187                          * Difficulty is 1-easy to 10-hard */
4188                         value = ((((s32b)(distance(cx, cy, x, y))) * 100) / size) + randint1(10) - difficulty;
4189
4190                         /* hack- empty square part of the time */
4191                         if ((randint1(100) - difficulty * 3) > 50) value = 20;
4192
4193                          /* if floor, shallow water and lava */
4194                         if (is_floor_bold(y, x) ||
4195                             (cave_have_flag_bold(y, x, FF_PLACE) && cave_have_flag_bold(y, x, FF_DROP)))
4196                         {
4197                                 /* The smaller 'value' is, the better the stuff */
4198                                 if (value < 0)
4199                                 {
4200                                         /* Meanest monster + treasure */
4201                                         monster_level = base_level + 40;
4202                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4203                                         monster_level = base_level;
4204                                         object_level = base_level + 20;
4205                                         place_object(y, x, AM_GOOD);
4206                                         object_level = base_level;
4207                                 }
4208                                 else if (value < 5)
4209                                 {
4210                                         /* Mean monster +treasure */
4211                                         monster_level = base_level + 20;
4212                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4213                                         monster_level = base_level;
4214                                         object_level = base_level + 10;
4215                                         place_object(y, x, AM_GOOD);
4216                                         object_level = base_level;
4217                                 }
4218                                 else if (value < 10)
4219                                 {
4220                                         /* Monster */
4221                                         monster_level = base_level + 9;
4222                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4223                                         monster_level = base_level;
4224                                 }
4225                                 else if (value < 17)
4226                                 {
4227                                         /* Intentional Blank space */
4228
4229                                         /*
4230                                          * (Want some of the vault to be empty
4231                                          * so have room for group monsters.
4232                                          * This is used in the hack above to lower
4233                                          * the density of stuff in the vault.)
4234                                          */
4235                                 }
4236                                 else if (value < 23)
4237                                 {
4238                                         /* Object or trap */
4239                                         if (randint0(100) < 25)
4240                                         {
4241                                                 place_object(y, x, 0L);
4242                                         }
4243                                         else
4244                                         {
4245                                                 place_trap(y, x);
4246                                         }
4247                                 }
4248                                 else if (value < 30)
4249                                 {
4250                                         /* Monster and trap */
4251                                         monster_level = base_level + 5;
4252                                         place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4253                                         monster_level = base_level;
4254                                         place_trap(y, x);
4255                                 }
4256                                 else if (value < 40)
4257                                 {
4258                                         /* Monster or object */
4259                                         if (randint0(100) < 50)
4260                                         {
4261                                                 monster_level = base_level + 3;
4262                                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4263                                                 monster_level = base_level;
4264                                         }
4265                                         if (randint0(100) < 50)
4266                                         {
4267                                                 object_level = base_level + 7;
4268                                                 place_object(y, x, 0L);
4269                                                 object_level = base_level;
4270                                         }
4271                                 }
4272                                 else if (value < 50)
4273                                 {
4274                                         /* Trap */
4275                                         place_trap(y, x);
4276                                 }
4277                                 else
4278                                 {
4279                                         /* Various Stuff */
4280
4281                                         /* 20% monster, 40% trap, 20% object, 20% blank space */
4282                                         if (randint0(100) < 20)
4283                                         {
4284                                                 place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
4285                                         }
4286                                         else if (randint0(100) < 50)
4287                                         {
4288                                                 place_trap(y, x);
4289                                         }
4290                                         else if (randint0(100) < 50)
4291                                         {
4292                                                 place_object(y, x, 0L);
4293                                         }
4294                                 }
4295
4296                         }
4297                 }
4298         }
4299 }
4300
4301
4302 /*
4303  * This function creates a random vault that looks like a collection of bubbles.
4304  * It works by getting a set of coordinates that represent the center of each
4305  * bubble.  The entire room is made by seeing which bubble center is closest. If
4306  * two centers are equidistant then the square is a wall, otherwise it is a floor.
4307  * The only exception is for squares really near a center, these are always floor.
4308  * (It looks better than without this check.)
4309  *
4310  * Note: If two centers are on the same point then this algorithm will create a
4311  *       blank bubble filled with walls. - This is prevented from happening.
4312  */
4313 static void build_bubble_vault(int x0, int y0, int xsize, int ysize)
4314 {
4315         #define BUBBLENUM 10            /* number of bubbles */
4316
4317         /* array of center points of bubbles */
4318         coord center[BUBBLENUM];
4319
4320         int i, j, x, y;
4321         u16b min1, min2, temp;
4322         bool done;
4323
4324         /* Offset from center to top left hand corner */
4325         int xhsize = xsize / 2;
4326         int yhsize = ysize / 2;
4327
4328         msg_print_wizard(CHEAT_DUNGEON, _("泡型ランダムVaultを生成しました。", "Room Vault."));
4329
4330         /* Allocate center of bubbles */
4331         center[0].x = (byte)randint1(xsize - 3) + 1;
4332         center[0].y = (byte)randint1(ysize - 3) + 1;
4333
4334         for (i = 1; i < BUBBLENUM; i++)
4335         {
4336                 done = FALSE;
4337
4338                 /* get center and check to see if it is unique */
4339                 while (!done)
4340                 {
4341                         done = TRUE;
4342
4343                         x = randint1(xsize - 3) + 1;
4344                         y = randint1(ysize - 3) + 1;
4345
4346                         for (j = 0; j < i; j++)
4347                         {
4348                                 /* rough test to see if there is an overlap */
4349                                 if ((x == center[j].x) && (y == center[j].y)) done = FALSE;
4350                         }
4351                 }
4352
4353                 center[i].x = (byte_hack)x;
4354                 center[i].y = (byte_hack)y;
4355         }
4356
4357
4358         /* Top and bottom boundaries */
4359         for (i = 0; i < xsize; i++)
4360         {
4361                 int side_x = x0 - xhsize + i;
4362
4363                 place_outer_noperm_bold(y0 - yhsize + 0, side_x);
4364                 cave[y0 - yhsize + 0][side_x].info |= (CAVE_ROOM | CAVE_ICKY);
4365                 place_outer_noperm_bold(y0 - yhsize + ysize - 1, side_x);
4366                 cave[y0 - yhsize + ysize - 1][side_x].info |= (CAVE_ROOM | CAVE_ICKY);
4367         }
4368
4369         /* Left and right boundaries */
4370         for (i = 1; i < ysize - 1; i++)
4371         {
4372                 int side_y = y0 - yhsize + i;
4373
4374                 place_outer_noperm_bold(side_y, x0 - xhsize + 0);
4375                 cave[side_y][x0 - xhsize + 0].info |= (CAVE_ROOM | CAVE_ICKY);
4376                 place_outer_noperm_bold(side_y, x0 - xhsize + xsize - 1);
4377                 cave[side_y][x0 - xhsize + xsize - 1].info |= (CAVE_ROOM | CAVE_ICKY);
4378         }
4379
4380         /* Fill in middle with bubbles */
4381         for (x = 1; x < xsize - 1; x++)
4382         {
4383                 for (y = 1; y < ysize - 1; y++)
4384                 {
4385                         /* Get distances to two closest centers */
4386
4387                         /* initialize */
4388                         min1 = (u16b)distance(x, y, center[0].x, center[0].y);
4389                         min2 = (u16b)distance(x, y, center[1].x, center[1].y);
4390
4391                         if (min1 > min2)
4392                         {
4393                                 /* swap if in wrong order */
4394                                 temp = min1;
4395                                 min1 = min2;
4396                                 min2 = temp;
4397                         }
4398
4399                         /* Scan the rest */
4400                         for (i = 2; i < BUBBLENUM; i++)
4401                         {
4402                                 temp = (u16b)distance(x, y, center[i].x, center[i].y);
4403
4404                                 if (temp < min1)
4405                                 {
4406                                         /* smallest */
4407                                         min2 = min1;
4408                                         min1 = temp;
4409                                 }
4410                                 else if (temp < min2)
4411                                 {
4412                                         /* second smallest */
4413                                         min2 = temp;
4414                                 }
4415                         }
4416                         if (((min2 - min1) <= 2) && (!(min1 < 3)))
4417                         {
4418                                 /* Boundary at midpoint+ not at inner region of bubble */
4419                                 place_outer_noperm_bold(y0 - yhsize + y, x0 - xhsize + x);
4420                         }
4421                         else
4422                         {
4423                                 /* middle of a bubble */
4424                                 place_floor_bold(y0 - yhsize + y, x0 - xhsize + x);
4425                         }
4426
4427                         /* clean up rest of flags */
4428                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= (CAVE_ROOM | CAVE_ICKY);
4429                 }
4430         }
4431
4432         /* Try to add some random doors */
4433         for (i = 0; i < 500; i++)
4434         {
4435                 x = randint1(xsize - 3) - xhsize + x0 + 1;
4436                 y = randint1(ysize - 3) - yhsize + y0 + 1;
4437                 add_door(x, y);
4438         }
4439
4440         /* Fill with monsters and treasure, low difficulty */
4441         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 2, y0 - yhsize + 1, y0 - yhsize + ysize - 2, randint1(5));
4442 }
4443
4444
4445 /*
4446  * Overlay a rectangular room given its bounds
4447  * This routine is used by build_room_vault
4448  * The area inside the walls is not touched:
4449  * only granite is removed- normal walls stay
4450  */
4451 static void build_room(int x1, int x2, int y1, int y2)
4452 {
4453         int x, y, i, xsize, ysize, temp;
4454
4455         /* Check if rectangle has no width */
4456         if ((x1 == x2) || (y1 == y2)) return;
4457
4458         /* initialize */
4459         if (x1 > x2)
4460         {
4461                 /* Swap boundaries if in wrong order */
4462                 temp = x1;
4463                 x1 = x2;
4464                 x2 = temp;
4465         }
4466
4467         if (y1 > y2)
4468         {
4469                 /* Swap boundaries if in wrong order */
4470                 temp = y1;
4471                 y1 = y2;
4472                 y2 = temp;
4473         }
4474
4475         /* get total widths */
4476         xsize = x2 - x1;
4477         ysize = y2 - y1;
4478
4479
4480         /* Top and bottom boundaries */
4481         for (i = 0; i <= xsize; i++)
4482         {
4483                 place_outer_noperm_bold(y1, x1 + i);
4484                 cave[y1][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
4485                 place_outer_noperm_bold(y2, x1 + i);
4486                 cave[y2][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
4487         }
4488
4489         /* Left and right boundaries */
4490         for (i = 1; i < ysize; i++)
4491         {
4492                 place_outer_noperm_bold(y1 + i, x1);
4493                 cave[y1 + i][x1].info|=(CAVE_ROOM | CAVE_ICKY);
4494                 place_outer_noperm_bold(y1 + i, x2);
4495                 cave[y1 + i][x2].info|=(CAVE_ROOM | CAVE_ICKY);
4496         }
4497
4498         /* Middle */
4499         for (x = 1; x < xsize; x++)
4500         {
4501                 for (y = 1; y < ysize; y++)
4502                 {
4503                         if (is_extra_bold(y1+y, x1+x))
4504                         {
4505                                 /* clear the untouched region */
4506                                 place_floor_bold(y1 + y, x1 + x);
4507                                 cave[y1 + y][x1 + x].info |= (CAVE_ROOM | CAVE_ICKY);
4508                         }
4509                         else
4510                         {
4511                                 /* make it a room- but don't touch */
4512                                 cave[y1 + y][x1 + x].info |= (CAVE_ROOM | CAVE_ICKY);
4513                         }
4514                 }
4515         }
4516 }
4517
4518
4519 /* Create a random vault that looks like a collection of overlapping rooms */
4520
4521 static void build_room_vault(int x0, int y0, int xsize, int ysize)
4522 {
4523         int i, x1, x2, y1, y2, xhsize, yhsize;
4524
4525         /* get offset from center */
4526         xhsize = xsize / 2;
4527         yhsize = ysize / 2;
4528
4529         msg_print_wizard(CHEAT_DUNGEON, _("部屋型ランダムVaultを生成しました。", "Room Vault."));
4530
4531         /* fill area so don't get problems with arena levels */
4532         for (x1 = 0; x1 < xsize; x1++)
4533         {
4534                 int x = x0 - xhsize + x1;
4535
4536                 for (y1 = 0; y1 < ysize; y1++)
4537                 {
4538                         int y = y0 - yhsize + y1;
4539
4540                         place_extra_bold(y, x);
4541                         cave[y][x].info &= (~CAVE_ICKY);
4542                 }
4543         }
4544
4545         /* add ten random rooms */
4546         for (i = 0; i < 10; i++)
4547         {
4548                 x1 = randint1(xhsize) * 2 + x0 - xhsize;
4549                 x2 = randint1(xhsize) * 2 + x0 - xhsize;
4550                 y1 = randint1(yhsize) * 2 + y0 - yhsize;
4551                 y2 = randint1(yhsize) * 2 + y0 - yhsize;
4552                 build_room(x1, x2, y1, y2);
4553         }
4554
4555         /* Add some random doors */
4556         for (i = 0; i < 500; i++)
4557         {
4558                 x1 = randint1(xsize - 3) - xhsize + x0 + 1;
4559                 y1 = randint1(ysize - 3) - yhsize + y0 + 1;
4560                 add_door(x1, y1);
4561         }
4562
4563         /* Fill with monsters and treasure, high difficulty */
4564         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 2, y0 - yhsize + 1, y0 - yhsize + ysize - 2, randint1(5) + 5);
4565 }
4566
4567
4568 /* Create a random vault out of a fractal cave */
4569 static void build_cave_vault(int x0, int y0, int xsiz, int ysiz)
4570 {
4571         int grd, roug, cutoff, xhsize, yhsize, xsize, ysize, x, y;
4572         bool done, light, room;
4573
4574         /* round to make sizes even */
4575         xhsize = xsiz / 2;
4576         yhsize = ysiz / 2;
4577         xsize = xhsize * 2;
4578         ysize = yhsize * 2;
4579
4580         msg_print_wizard(CHEAT_DUNGEON, _("洞穴ランダムVaultを生成しました。", "Cave Vault."));
4581
4582         light = done = FALSE;
4583         room = TRUE;
4584
4585         while (!done)
4586         {
4587                 /* testing values for these parameters feel free to adjust */
4588                 grd = 1 << randint0(4);
4589
4590                 /* want average of about 16 */
4591                 roug = randint1(8) * randint1(4);
4592
4593                 /* about size/2 */
4594                 cutoff = randint1(xsize / 4) + randint1(ysize / 4) +
4595                          randint1(xsize / 4) + randint1(ysize / 4);
4596
4597                 /* make it */
4598                 generate_hmap(y0, x0, xsize, ysize, grd, roug, cutoff);
4599
4600                 /* Convert to normal format+ clean up */
4601                 done = generate_fracave(y0, x0, xsize, ysize, cutoff, light, room);
4602         }
4603
4604         /* Set icky flag because is a vault */
4605         for (x = 0; x <= xsize; x++)
4606         {
4607                 for (y = 0; y <= ysize; y++)
4608                 {
4609                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= CAVE_ICKY;
4610                 }
4611         }
4612
4613         /* Fill with monsters and treasure, low difficulty */
4614         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 1, y0 - yhsize + 1, y0 - yhsize + ysize - 1, randint1(5));
4615 }
4616
4617 /*
4618  * maze vault -- rectangular labyrinthine rooms
4619  *
4620  * maze vault uses two routines:
4621  *    r_visit - a recursive routine that builds the labyrinth
4622  *    build_maze_vault - a driver routine that calls r_visit and adds
4623  *                   monsters, traps and treasure
4624  *
4625  * The labyrinth is built by creating a spanning tree of a graph.
4626  * The graph vertices are at
4627  *    (x, y) = (2j + x1, 2k + y1)   j = 0,...,m-1    k = 0,...,n-1
4628  * and the edges are the vertical and horizontal nearest neighbors.
4629  *
4630  * The spanning tree is created by performing a suitably randomized
4631  * depth-first traversal of the graph. The only adjustable parameter
4632  * is the randint0(3) below; it governs the relative density of
4633  * twists and turns in the labyrinth: smaller number, more twists.
4634  */
4635 static void r_visit(int y1, int x1, int y2, int x2,
4636                     int node, int dir, int *visited)
4637 {
4638         int i, j, m, n, temp, x, y, adj[4];
4639
4640         /* dimensions of vertex array */
4641         m = (x2 - x1) / 2 + 1;
4642         n = (y2 - y1) / 2 + 1;
4643
4644         /* mark node visited and set it to a floor */
4645         visited[node] = 1;
4646         x = 2 * (node % m) + x1;
4647         y = 2 * (node / m) + y1;
4648         place_floor_bold(y, x);
4649
4650         /* setup order of adjacent node visits */
4651         if (one_in_(3))
4652         {
4653                 /* pick a random ordering */
4654                 for (i = 0; i < 4; i++)
4655                         adj[i] = i;
4656                 for (i = 0; i < 4; i++)
4657                 {
4658                         j = randint0(4);
4659                         temp = adj[i];
4660                         adj[i] = adj[j];
4661                         adj[j] = temp;
4662                 }
4663                 dir = adj[0];
4664         }
4665         else
4666         {
4667                 /* pick a random ordering with dir first */
4668                 adj[0] = dir;
4669                 for (i = 1; i < 4; i++)
4670                         adj[i] = i;
4671                 for (i = 1; i < 4; i++)
4672                 {
4673                         j = 1 + randint0(3);
4674                         temp = adj[i];
4675                         adj[i] = adj[j];
4676                         adj[j] = temp;
4677                 }
4678         }
4679
4680         for (i = 0; i < 4; i++)
4681         {
4682                 switch (adj[i])
4683                 {
4684                         case 0:
4685                                 /* (0,+) - check for bottom boundary */
4686                                 if ((node / m < n - 1) && (visited[node + m] == 0))
4687                                 {
4688                                         place_floor_bold(y + 1, x);
4689                                         r_visit(y1, x1, y2, x2, node + m, dir, visited);
4690                                 }
4691                                 break;
4692                         case 1:
4693                                 /* (0,-) - check for top boundary */
4694                                 if ((node / m > 0) && (visited[node - m] == 0))
4695                                 {
4696                                         place_floor_bold(y - 1, x);
4697                                         r_visit(y1, x1, y2, x2, node - m, dir, visited);
4698                                 }
4699                                 break;
4700                         case 2:
4701                                 /* (+,0) - check for right boundary */
4702                                 if ((node % m < m - 1) && (visited[node + 1] == 0))
4703                                 {
4704                                         place_floor_bold(y, x + 1);
4705                                         r_visit(y1, x1, y2, x2, node + 1, dir, visited);
4706                                 }
4707                                 break;
4708                         case 3:
4709                                 /* (-,0) - check for left boundary */
4710                                 if ((node % m > 0) && (visited[node - 1] == 0))
4711                                 {
4712                                         place_floor_bold(y, x - 1);
4713                                         r_visit(y1, x1, y2, x2, node - 1, dir, visited);
4714                                 }
4715                 } /* end switch */
4716         }
4717 }
4718
4719
4720 void build_maze_vault(int x0, int y0, int xsize, int ysize, bool is_vault)
4721 {
4722         int y, x, dy, dx;
4723         int y1, x1, y2, x2;
4724         int m, n, num_vertices, *visited;
4725         bool light;
4726         cave_type *c_ptr;
4727
4728         msg_print_wizard(CHEAT_DUNGEON, _("迷路ランダムVaultを生成しました。", "Maze Vault."));
4729
4730         /* Choose lite or dark */
4731         light = ((dun_level <= randint1(25)) && is_vault && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
4732
4733         /* Pick a random room size - randomized by calling routine */
4734         dy = ysize / 2 - 1;
4735         dx = xsize / 2 - 1;
4736
4737         y1 = y0 - dy;
4738         x1 = x0 - dx;
4739         y2 = y0 + dy;
4740         x2 = x0 + dx;
4741
4742         /* generate the room */
4743         for (y = y1 - 1; y <= y2 + 1; y++)
4744         {
4745                 for (x = x1 - 1; x <= x2 + 1; x++)
4746                 {
4747                         c_ptr = &cave[y][x];
4748                         c_ptr->info |= CAVE_ROOM;
4749                         if (is_vault) c_ptr->info |= CAVE_ICKY;
4750                         if ((x == x1 - 1) || (x == x2 + 1) || (y == y1 - 1) || (y == y2 + 1))
4751                         {
4752                                 place_outer_grid(c_ptr);
4753                         }
4754                         else if (!is_vault)
4755                         {
4756                                 place_extra_grid(c_ptr);
4757                         }
4758                         else
4759                         {
4760                                 place_inner_grid(c_ptr);
4761                         }
4762                         if (light) c_ptr->info |= (CAVE_GLOW);
4763                 }
4764         }
4765
4766         /* dimensions of vertex array */
4767         m = dx + 1;
4768         n = dy + 1;
4769         num_vertices = m * n;
4770
4771         /* initialize array of visited vertices */
4772         C_MAKE(visited, num_vertices, int);
4773
4774         /* traverse the graph to create a spaning tree, pick a random root */
4775         r_visit(y1, x1, y2, x2, randint0(num_vertices), 0, visited);
4776
4777         /* Fill with monsters and treasure, low difficulty */
4778         if (is_vault) fill_treasure(x1, x2, y1, y2, randint1(5));
4779
4780         C_KILL(visited, num_vertices, int);
4781 }
4782
4783
4784 /* Build a "mini" checkerboard vault
4785  *
4786  * This is done by making a permanent wall maze and setting
4787  * the diagonal sqaures of the checker board to be granite.
4788  * The vault has two entrances on opposite sides to guarantee
4789  * a way to get in even if the vault abuts a side of the dungeon.
4790  */
4791 static void build_mini_c_vault(int x0, int y0, int xsize, int ysize)
4792 {
4793         int dy, dx;
4794         int y1, x1, y2, x2, y, x, total;
4795         int m, n, num_vertices;
4796         int *visited;
4797
4798         msg_print_wizard(CHEAT_DUNGEON, _("小型チェッカーランダムVaultを生成しました。", "Mini Checker Board Vault."));
4799
4800         /* Pick a random room size */
4801         dy = ysize / 2 - 1;
4802         dx = xsize / 2 - 1;
4803
4804         y1 = y0 - dy;
4805         x1 = x0 - dx;
4806         y2 = y0 + dy;
4807         x2 = x0 + dx;
4808
4809
4810         /* generate the room */
4811         for (x = x1 - 2; x <= x2 + 2; x++)
4812         {
4813                 if (!in_bounds(y1-2,x)) break;
4814
4815                 cave[y1-2][x].info |= (CAVE_ROOM | CAVE_ICKY);
4816
4817                 place_outer_noperm_bold(y1-2, x);
4818         }
4819
4820         for (x = x1 - 2; x <= x2 + 2; x++)
4821         {
4822                 if (!in_bounds(y2+2,x)) break;
4823
4824                 cave[y2+2][x].info |= (CAVE_ROOM | CAVE_ICKY);
4825
4826                 place_outer_noperm_bold(y2+2, x);
4827         }
4828
4829         for (y = y1 - 2; y <= y2 + 2; y++)
4830         {
4831                 if (!in_bounds(y,x1-2)) break;
4832
4833                 cave[y][x1-2].info |= (CAVE_ROOM | CAVE_ICKY);
4834
4835                 place_outer_noperm_bold(y, x1-2);
4836         }
4837
4838         for (y = y1 - 2; y <= y2 + 2; y++)
4839         {
4840                 if (!in_bounds(y,x2+2)) break;
4841
4842                 cave[y][x2+2].info |= (CAVE_ROOM | CAVE_ICKY);
4843
4844                 place_outer_noperm_bold(y, x2+2);
4845         }
4846
4847         for (y = y1 - 1; y <= y2 + 1; y++)
4848         {
4849                 for (x = x1 - 1; x <= x2 + 1; x++)
4850                 {
4851                         cave_type *c_ptr = &cave[y][x];
4852
4853                         c_ptr->info |= (CAVE_ROOM | CAVE_ICKY);
4854
4855                         /* Permanent walls */
4856                         place_inner_perm_grid(c_ptr);
4857                 }
4858         }
4859
4860
4861         /* dimensions of vertex array */
4862         m = dx + 1;
4863         n = dy + 1;
4864         num_vertices = m * n;
4865
4866         /* initialize array of visited vertices */
4867         C_MAKE(visited, num_vertices, int);
4868
4869         /* traverse the graph to create a spannng tree, pick a random root */
4870         r_visit(y1, x1, y2, x2, randint0(num_vertices), 0, visited);
4871
4872         /* Make it look like a checker board vault */
4873         for (x = x1; x <= x2; x++)
4874         {
4875                 for (y = y1; y <= y2; y++)
4876                 {
4877                         total = x - x1 + y - y1;
4878                         /* If total is odd- and is a floor then make a wall */
4879                         if ((total % 2 == 1) && is_floor_bold(y, x))
4880                         {
4881                                 place_inner_bold(y, x);
4882                         }
4883                 }
4884         }
4885
4886         /* Make a couple of entrances */
4887         if (one_in_(2))
4888         {
4889                 /* left and right */
4890                 y = randint1(dy) + dy / 2;
4891                 place_inner_bold(y1 + y, x1 - 1);
4892                 place_inner_bold(y1 + y, x2 + 1);
4893         }
4894         else
4895         {
4896                 /* top and bottom */
4897                 x = randint1(dx) + dx / 2;
4898                 place_inner_bold(y1 - 1, x1 + x);
4899                 place_inner_bold(y2 + 1, x1 + x);
4900         }
4901
4902         /* Fill with monsters and treasure, highest difficulty */
4903         fill_treasure(x1, x2, y1, y2, 10);
4904
4905         C_KILL(visited, num_vertices, int);
4906 }
4907
4908
4909 /* Build a town/ castle by using a recursive algorithm.
4910  * Basically divide each region in a probalistic way to create
4911  * smaller regions.  When the regions get too small stop.
4912  *
4913  * The power variable is a measure of how well defended a region is.
4914  * This alters the possible choices.
4915  */
4916 static void build_recursive_room(int x1, int y1, int x2, int y2, int power)
4917 {
4918         int xsize, ysize;
4919         int x, y;
4920         int choice;
4921
4922         /* Temp variables */
4923         int t1, t2, t3, t4;
4924
4925         xsize = x2 - x1;
4926         ysize = y2 - y1;
4927
4928         if ((power < 3) && (xsize > 12) && (ysize > 12))
4929         {
4930                 /* Need outside wall +keep */
4931                 choice = 1;
4932         }
4933         else
4934         {
4935                 if (power < 10)
4936                 {
4937                         /* Make rooms + subdivide */
4938                         if ((randint1(10) > 2) && (xsize < 8) && (ysize < 8))
4939                         {
4940                                 choice = 4;
4941                         }
4942                         else
4943                         {
4944                                 choice = randint1(2) + 1;
4945                         }
4946                 }
4947                 else
4948                 {
4949                         /* Mostly subdivide */
4950                         choice = randint1(3) + 1;
4951                 }
4952         }
4953
4954         /* Based on the choice made above, do something */
4955
4956         switch (choice)
4957         {
4958                 case 1:
4959                 {
4960                         /* Outer walls */
4961
4962                         /* top and bottom */
4963                         for (x = x1; x <= x2; x++)
4964                         {
4965                                 place_outer_bold(y1, x);
4966                                 place_outer_bold(y2, x);
4967                         }
4968
4969                         /* left and right */
4970                         for (y = y1 + 1; y < y2; y++)
4971                         {
4972                                 place_outer_bold(y, x1);
4973                                 place_outer_bold(y, x2);
4974                         }
4975
4976                         /* Make a couple of entrances */
4977                         if (one_in_(2))
4978                         {
4979                                 /* left and right */
4980                                 y = randint1(ysize) + y1;
4981                                 place_floor_bold(y, x1);
4982                                 place_floor_bold(y, x2);
4983                         }
4984                         else
4985                         {
4986                                 /* top and bottom */
4987                                 x = randint1(xsize) + x1;
4988                                 place_floor_bold(y1, x);
4989                                 place_floor_bold(y2, x);
4990                         }
4991
4992                         /* Select size of keep */
4993                         t1 = randint1(ysize / 3) + y1;
4994                         t2 = y2 - randint1(ysize / 3);
4995                         t3 = randint1(xsize / 3) + x1;
4996                         t4 = x2 - randint1(xsize / 3);
4997
4998                         /* Do outside areas */
4999
5000                         /* Above and below keep */
5001                         build_recursive_room(x1 + 1, y1 + 1, x2 - 1, t1, power + 1);
5002                         build_recursive_room(x1 + 1, t2, x2 - 1, y2, power + 1);
5003
5004                         /* Left and right of keep */
5005                         build_recursive_room(x1 + 1, t1 + 1, t3, t2 - 1, power + 3);
5006                         build_recursive_room(t4, t1 + 1, x2 - 1, t2 - 1, power + 3);
5007
5008                         /* Make the keep itself: */
5009                         x1 = t3;
5010                         x2 = t4;
5011                         y1 = t1;
5012                         y2 = t2;
5013                         xsize = x2 - x1;
5014                         ysize = y2 - y1;
5015                         power += 2;
5016
5017                         /* Fall through */
5018                 }
5019                 case 4:
5020                 {
5021                         /* Try to build a room */
5022                         if ((xsize < 3) || (ysize < 3))
5023                         {
5024                                 for (y = y1; y < y2; y++)
5025                                 {
5026                                         for (x = x1; x < x2; x++)
5027                                         {
5028                                                 place_inner_bold(y, x);
5029                                         }
5030                                 }
5031
5032                                 /* Too small */
5033                                 return;
5034                         }
5035
5036                         /* Make outside walls */
5037                         /* top and bottom */
5038                         for (x = x1 + 1; x <= x2 - 1; x++)
5039                         {
5040                                 place_inner_bold(y1 + 1, x);
5041                                 place_inner_bold(y2 - 1, x);
5042                         }
5043
5044                         /* left and right */
5045                         for (y = y1 + 1; y <= y2 - 1; y++)
5046                         {
5047                                 place_inner_bold(y, x1 + 1);
5048                                 place_inner_bold(y, x2 - 1);
5049                         }
5050
5051                         /* Make a door */
5052                         y = randint1(ysize - 3) + y1 + 1;
5053
5054                         if (one_in_(2))
5055                         {
5056                                 /* left */
5057                                 place_floor_bold(y, x1 + 1);
5058                         }
5059                         else
5060                         {
5061                                 /* right */
5062                                 place_floor_bold(y, x2 - 1);
5063                         }
5064
5065                         /* Build the room */
5066                         build_recursive_room(x1 + 2, y1 + 2, x2 - 2, y2 - 2, power + 3);
5067                         break;
5068                 }
5069                 case 2:
5070                 {
5071                         /* Try and divide vertically */
5072                         if (xsize < 3)
5073                         {
5074                                 /* Too small */
5075                                 for (y = y1; y < y2; y++)
5076                                 {
5077                                         for (x = x1; x < x2; x++)
5078                                         {
5079                                                 place_inner_bold(y, x);
5080                                         }
5081                                 }
5082                                 return;
5083                         }
5084
5085                         t1 = randint1(xsize - 2) + x1 + 1;
5086                         build_recursive_room(x1, y1, t1, y2, power - 2);
5087                         build_recursive_room(t1 + 1, y1, x2, y2, power - 2);
5088                         break;
5089                 }
5090                 case 3:
5091                 {
5092                         /* Try and divide horizontally */
5093                         if (ysize < 3)
5094                         {
5095                                 /* Too small */
5096                                 for (y = y1; y < y2; y++)
5097                                 {
5098                                         for (x = x1; x < x2; x++)
5099                                         {
5100                                                 place_inner_bold(y, x);
5101                                         }
5102                                 }
5103                                 return;
5104                         }
5105
5106                         t1 = randint1(ysize - 2) + y1 + 1;
5107                         build_recursive_room(x1, y1, x2, t1, power - 2);
5108                         build_recursive_room(x1, t1 + 1, x2, y2, power - 2);
5109                         break;
5110                 }
5111         }
5112 }
5113
5114
5115 /* Build a castle */
5116
5117 /* Driver routine: clear the region and call the recursive
5118 * room routine.
5119 *
5120 *This makes a vault that looks like a castle/ city in the dungeon.
5121 */
5122 static void build_castle_vault(int x0, int y0, int xsize, int ysize)
5123 {
5124         int dy, dx;
5125         int y1, x1, y2, x2;
5126         int y, x;
5127
5128         /* Pick a random room size */
5129         dy = ysize / 2 - 1;
5130         dx = xsize / 2 - 1;
5131
5132         y1 = y0 - dy;
5133         x1 = x0 - dx;
5134         y2 = y0 + dy;
5135         x2 = x0 + dx;
5136
5137         msg_print_wizard(CHEAT_DUNGEON, _("城型ランダムVaultを生成しました。", "Castle Vault"));
5138
5139         /* generate the room */
5140         for (y = y1 - 1; y <= y2 + 1; y++)
5141         {
5142                 for (x = x1 - 1; x <= x2 + 1; x++)
5143                 {
5144                         cave[y][x].info |= (CAVE_ROOM | CAVE_ICKY);
5145                         /* Make everything a floor */
5146                         place_floor_bold(y, x);
5147                 }
5148         }
5149
5150         /* Make the castle */
5151         build_recursive_room(x1, y1, x2, y2, randint1(5));
5152
5153         /* Fill with monsters and treasure, low difficulty */
5154         fill_treasure(x1, x2, y1, y2, randint1(3));
5155 }
5156
5157
5158 /*
5159  * Add outer wall to a floored region
5160  * Note: no range checking is done so must be inside dungeon
5161  * This routine also stomps on doors
5162  */
5163 static void add_outer_wall(int x, int y, int light, int x1, int y1, int x2, int y2)
5164 {
5165         cave_type *c_ptr;
5166         feature_type *f_ptr;
5167         int i, j;
5168
5169         if (!in_bounds(y, x)) return;
5170
5171         c_ptr = &cave[y][x];
5172
5173         /* hack- check to see if square has been visited before
5174         * if so, then exit (use room flag to do this) */
5175         if (c_ptr->info & CAVE_ROOM) return;
5176
5177         /* set room flag */
5178         c_ptr->info |= CAVE_ROOM;
5179
5180         f_ptr = &f_info[c_ptr->feat];
5181
5182         if (is_floor_bold(y, x))
5183         {
5184                 for (i = -1; i <= 1; i++)
5185                 {
5186                         for (j = -1; j <= 1; j++)
5187                         {
5188                                 if ((x + i >= x1) && (x + i <= x2) &&
5189                                          (y + j >= y1) && (y + j <= y2))
5190                                 {
5191                                         add_outer_wall(x + i, y + j, light, x1, y1, x2, y2);
5192                                         if (light) c_ptr->info |= CAVE_GLOW;
5193                                 }
5194                         }
5195                 }
5196         }
5197         else if (is_extra_bold(y, x))
5198         {
5199                 /* Set bounding walls */
5200                 place_outer_bold(y, x);
5201                 if (light) c_ptr->info |= CAVE_GLOW;
5202         }
5203         else if (permanent_wall(f_ptr))
5204         {
5205                 /* Set bounding walls */
5206                 if (light) c_ptr->info |= CAVE_GLOW;
5207         }
5208 }
5209
5210
5211 /*
5212  * Hacked distance formula - gives the 'wrong' answer.
5213  * Used to build crypts
5214  */
5215 static int dist2(int x1, int y1, int x2, int y2,
5216                  int h1, int h2, int h3, int h4)
5217 {
5218         int dx, dy;
5219         dx = abs(x2 - x1);
5220         dy = abs(y2 - y1);
5221
5222         /* Basically this works by taking the normal pythagorean formula
5223          * and using an expansion to express this in a way without the
5224          * square root.  This approximate formula is then perturbed to give
5225          * the distorted results.  (I found this by making a mistake when I was
5226          * trying to fix the circular rooms.)
5227          */
5228
5229         /* h1-h4 are constants that describe the metric */
5230         if (dx >= 2 * dy) return (dx + (dy * h1) / h2);
5231         if (dy >= 2 * dx) return (dy + (dx * h1) / h2);
5232         return (((dx + dy) * 128) / 181 +
5233                 (dx * dx / (dy * h3) + dy * dy / (dx * h3)) * h4);
5234         /* 128/181 is approx. 1/sqrt(2) */
5235 }
5236
5237
5238 /*
5239  * Build target vault.
5240  * This is made by two concentric "crypts" with perpendicular
5241  * walls creating the cross-hairs.
5242  */
5243 static void build_target_vault(int x0, int y0, int xsize, int ysize)
5244 {
5245         int rad, x, y;
5246
5247         /* Make a random metric */
5248         int h1, h2, h3, h4;
5249         h1 = randint1(32) - 16;
5250         h2 = randint1(16);
5251         h3 = randint1(32);
5252         h4 = randint1(32) - 16;
5253
5254         msg_print_wizard(CHEAT_DUNGEON, _("対称形ランダムVaultを生成しました。", "Elemental Vault"));
5255
5256         /* work out outer radius */
5257         if (xsize > ysize)
5258         {
5259                 rad = ysize / 2;
5260         }
5261         else
5262         {
5263                 rad = xsize / 2;
5264         }
5265
5266         /* Make floor */
5267         for (x = x0 - rad; x <= x0 + rad; x++)
5268         {
5269                 for (y = y0 - rad; y <= y0 + rad; y++)
5270                 {
5271                         /* clear room flag */
5272                         cave[y][x].info &= ~(CAVE_ROOM);
5273
5274                         /* Vault - so is "icky" */
5275                         cave[y][x].info |= CAVE_ICKY;
5276
5277                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)
5278                         {
5279                                 /* inside- so is floor */
5280                                 place_floor_bold(y, x);
5281                         }
5282                         else
5283                         {
5284                                 /* make granite outside so arena works */
5285                                 place_extra_bold(y, x);
5286                         }
5287
5288                         /* proper boundary for arena */
5289                         if (((y + rad) == y0) || ((y - rad) == y0) ||
5290                             ((x + rad) == x0) || ((x - rad) == x0))
5291                         {
5292                                 place_extra_bold(y, x);
5293                         }
5294                 }
5295         }
5296
5297         /* Find visible outer walls and set to be FEAT_OUTER */
5298         add_outer_wall(x0, y0, FALSE, x0 - rad - 1, y0 - rad - 1,
5299                        x0 + rad + 1, y0 + rad + 1);
5300
5301         /* Add inner wall */
5302         for (x = x0 - rad / 2; x <= x0 + rad / 2; x++)
5303         {
5304                 for (y = y0 - rad / 2; y <= y0 + rad / 2; y++)
5305                 {
5306                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) == rad / 2)
5307                         {
5308                                 /* Make an internal wall */
5309                                 place_inner_bold(y, x);
5310                         }
5311                 }
5312         }
5313
5314         /* Add perpendicular walls */
5315         for (x = x0 - rad; x <= x0 + rad; x++)
5316         {
5317                 place_inner_bold(y0, x);
5318         }
5319
5320         for (y = y0 - rad; y <= y0 + rad; y++)
5321         {
5322                 place_inner_bold(y, x0);
5323         }
5324
5325         /* Make inner vault */
5326         for (y = y0 - 1; y <= y0 + 1; y++)
5327         {
5328                 place_inner_bold(y, x0 - 1);
5329                 place_inner_bold(y, x0 + 1);
5330         }
5331         for (x = x0 - 1; x <= x0 + 1; x++)
5332         {
5333                 place_inner_bold(y0 - 1, x);
5334                 place_inner_bold(y0 + 1, x);
5335         }
5336
5337         place_floor_bold(y0, x0);
5338
5339
5340         /* Add doors to vault */
5341         /* get two distances so can place doors relative to centre */
5342         x = (rad - 2) / 4 + 1;
5343         y = rad / 2 + x;
5344
5345         add_door(x0 + x, y0);
5346         add_door(x0 + y, y0);
5347         add_door(x0 - x, y0);
5348         add_door(x0 - y, y0);
5349         add_door(x0, y0 + x);
5350         add_door(x0, y0 + y);
5351         add_door(x0, y0 - x);
5352         add_door(x0, y0 - y);
5353
5354         /* Fill with stuff - medium difficulty */
5355         fill_treasure(x0 - rad, x0 + rad, y0 - rad, y0 + rad, randint1(3) + 3);
5356 }
5357
5358
5359 #ifdef ALLOW_CAVERNS_AND_LAKES
5360 /*
5361  * This routine uses a modified version of the lake code to make a
5362  * distribution of some terrain type over the vault.  This type
5363  * depends on the dungeon depth.
5364  *
5365  * Miniture rooms are then scattered across the vault.
5366  */
5367 static void build_elemental_vault(int x0, int y0, int xsiz, int ysiz)
5368 {
5369         int grd, roug;
5370         int c1, c2, c3;
5371         bool done = FALSE;
5372         int xsize, ysize, xhsize, yhsize, x, y, i;
5373         int type;
5374
5375         msg_print_wizard(CHEAT_DUNGEON, _("精霊界ランダムVaultを生成しました。", "Elemental Vault"));
5376
5377         /* round to make sizes even */
5378         xhsize = xsiz / 2;
5379         yhsize = ysiz / 2;
5380         xsize = xhsize * 2;
5381         ysize = yhsize * 2;
5382
5383         if (dun_level < 25)
5384         {
5385                 /* Earth vault  (Rubble) */
5386                 type = LAKE_T_EARTH_VAULT;
5387         }
5388         else if (dun_level < 50)
5389         {
5390                 /* Air vault (Trees) */
5391                 type = LAKE_T_AIR_VAULT;
5392         }
5393         else if (dun_level < 75)
5394         {
5395                 /* Water vault (shallow water) */
5396                 type = LAKE_T_WATER_VAULT;
5397         }
5398         else
5399         {
5400                 /* Fire vault (shallow lava) */
5401                 type = LAKE_T_FIRE_VAULT;
5402         }
5403
5404         while (!done)
5405         {
5406                 /* testing values for these parameters: feel free to adjust */
5407                 grd = 1 << (randint0(3));
5408
5409                 /* want average of about 16 */
5410                 roug = randint1(8) * randint1(4);
5411
5412                 /* Make up size of various componants */
5413                 /* Floor */
5414                 c3 = 2 * xsize / 3;
5415
5416                 /* Deep water/lava */
5417                 c1 = randint0(c3 / 2) + randint0(c3 / 2) - 5;
5418
5419                 /* Shallow boundary */
5420                 c2 = (c1 + c3) / 2;
5421
5422                 /* make it */
5423                 generate_hmap(y0, x0, xsize, ysize, grd, roug, c3);
5424
5425                 /* Convert to normal format+ clean up */
5426                 done = generate_lake(y0, x0, xsize, ysize, c1, c2, c3, type);
5427         }
5428
5429         /* Set icky flag because is a vault */
5430         for (x = 0; x <= xsize; x++)
5431         {
5432                 for (y = 0; y <= ysize; y++)
5433                 {
5434                         cave[y0 - yhsize + y][x0 - xhsize + x].info |= CAVE_ICKY;
5435                 }
5436         }
5437
5438         /* make a few rooms in the vault */
5439         for (i = 1; i <= (xsize * ysize) / 50; i++)
5440         {
5441                 build_small_room(x0 + randint0(xsize - 4) - xsize / 2 + 2,
5442                                  y0 + randint0(ysize - 4) - ysize / 2 + 2);
5443         }
5444
5445         /* Fill with monsters and treasure, low difficulty */
5446         fill_treasure(x0 - xhsize + 1, x0 - xhsize + xsize - 1,
5447                       y0 - yhsize + 1, y0 - yhsize + ysize - 1, randint1(5));
5448 }
5449 #endif /* ALLOW_CAVERNS_AND_LAKES */
5450
5451
5452 /*!
5453  * @brief タイプ10の部屋…ランダム生成vault / Type 10 -- Random vaults
5454  * @return なし
5455  */
5456 static bool build_type10(void)
5457 {
5458         int y0, x0, xsize, ysize, vtype;
5459
5460         /* Get size */
5461         /* big enough to look good, small enough to be fairly common. */
5462         xsize = randint1(22) + 22;
5463         ysize = randint1(11) + 11;
5464
5465         /* Find and reserve some space in the dungeon.  Get center of room. */
5466         if (!find_space(&y0, &x0, ysize + 1, xsize + 1)) return FALSE;
5467
5468         /* Select type of vault */
5469 #ifdef ALLOW_CAVERNS_AND_LAKES
5470         do
5471         {
5472                 vtype = randint1(15);
5473         }
5474         while ((d_info[dungeon_type].flags1 & DF1_NO_CAVE) &&
5475                 ((vtype == 1) || (vtype == 3) || (vtype == 8) || (vtype == 9) || (vtype == 11)));
5476 #else /* ALLOW_CAVERNS_AND_LAKES */
5477         do
5478         {
5479                 vtype = randint1(7);
5480         }
5481         while ((d_info[dungeon_type].flags1 & DF1_NO_CAVE) &&
5482                 ((vtype == 1) || (vtype == 3)));
5483 #endif /* ALLOW_CAVERNS_AND_LAKES */
5484
5485         switch (vtype)
5486         {
5487                 /* Build an appropriate room */
5488                 case 1: case  9: build_bubble_vault(x0, y0, xsize, ysize); break;
5489                 case 2: case 10: build_room_vault(x0, y0, xsize, ysize); break;
5490                 case 3: case 11: build_cave_vault(x0, y0, xsize, ysize); break;
5491                 case 4: case 12: build_maze_vault(x0, y0, xsize, ysize, TRUE); break;
5492                 case 5: case 13: build_mini_c_vault(x0, y0, xsize, ysize); break;
5493                 case 6: case 14: build_castle_vault(x0, y0, xsize, ysize); break;
5494                 case 7: case 15: build_target_vault(x0, y0, xsize, ysize); break;
5495 #ifdef ALLOW_CAVERNS_AND_LAKES
5496                 case 8: build_elemental_vault(x0, y0, xsize, ysize); break;
5497 #endif /* ALLOW_CAVERNS_AND_LAKES */
5498                 /* I know how to add a few more... give me some time. */
5499
5500                 /* Paranoia */
5501                 default: return FALSE;
5502         }
5503
5504         return TRUE;
5505 }
5506
5507
5508 /*!
5509  * @brief タイプ11の部屋…円形部屋の生成 / Type 11 -- Build an vertical oval room.
5510  * @return なし
5511  * @details
5512  * For every grid in the possible square, check the distance.\n
5513  * If it's less than the radius, make it a room square.\n
5514  *\n
5515  * When done fill from the inside to find the walls,\n
5516  */
5517 static bool build_type11(void)
5518 {
5519         int rad, x, y, x0, y0;
5520         int light = FALSE;
5521
5522         /* Occasional light */
5523         if ((randint1(dun_level) <= 15) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
5524
5525         rad = randint0(9);
5526
5527         /* Find and reserve some space in the dungeon.  Get center of room. */
5528         if (!find_space(&y0, &x0, rad * 2 + 1, rad * 2 + 1)) return FALSE;
5529
5530         /* Make circular floor */
5531         for (x = x0 - rad; x <= x0 + rad; x++)
5532         {
5533                 for (y = y0 - rad; y <= y0 + rad; y++)
5534                 {
5535                         if (distance(y0, x0, y, x) <= rad - 1)
5536                         {
5537                                 /* inside- so is floor */
5538                                 place_floor_bold(y, x);
5539                         }
5540                         else if (distance(y0, x0, y, x) <= rad + 1)
5541                         {
5542                                 /* make granite outside so arena works */
5543                                 place_extra_bold(y, x);
5544                         }
5545                 }
5546         }
5547
5548         /* Find visible outer walls and set to be FEAT_OUTER */
5549         add_outer_wall(x0, y0, light, x0 - rad, y0 - rad, x0 + rad, y0 + rad);
5550
5551         return TRUE;
5552 }
5553
5554
5555 /*!
5556  * @brief タイプ12の部屋…ドーム型部屋の生成 / Type 12 -- Build crypt room.
5557  * @return なし
5558  * @details
5559  * For every grid in the possible square, check the (fake) distance.\n
5560  * If it's less than the radius, make it a room square.\n
5561  *\n
5562  * When done fill from the inside to find the walls,\n
5563  */
5564 static bool build_type12(void)
5565 {
5566         int rad, x, y, x0, y0;
5567         int light = FALSE;
5568         bool emptyflag = TRUE;
5569
5570         /* Make a random metric */
5571         int h1, h2, h3, h4;
5572         h1 = randint1(32) - 16;
5573         h2 = randint1(16);
5574         h3 = randint1(32);
5575         h4 = randint1(32) - 16;
5576
5577         /* Occasional light */
5578         if ((randint1(dun_level) <= 5) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS)) light = TRUE;
5579
5580         rad = randint1(9);
5581
5582         /* Find and reserve some space in the dungeon.  Get center of room. */
5583         if (!find_space(&y0, &x0, rad * 2 + 3, rad * 2 + 3)) return FALSE;
5584
5585         /* Make floor */
5586         for (x = x0 - rad; x <= x0 + rad; x++)
5587         {
5588                 for (y = y0 - rad; y <= y0 + rad; y++)
5589                 {
5590                         /* clear room flag */
5591                         cave[y][x].info &= ~(CAVE_ROOM);
5592
5593                         if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)
5594                         {
5595                                 /* inside - so is floor */
5596                                 place_floor_bold(y, x);
5597                         }
5598                         else if (distance(y0, x0, y, x) < 3)
5599                         {
5600                                 place_floor_bold(y, x);
5601                         }
5602                         else
5603                         {
5604                                 /* make granite outside so arena works */
5605                                 place_extra_bold(y, x);
5606                         }
5607
5608                         /* proper boundary for arena */
5609                         if (((y + rad) == y0) || ((y - rad) == y0) ||
5610                             ((x + rad) == x0) || ((x - rad) == x0))
5611                         {
5612                                 place_extra_bold(y, x);
5613                         }
5614                 }
5615         }
5616
5617         /* Find visible outer walls and set to be FEAT_OUTER */
5618         add_outer_wall(x0, y0, light, x0 - rad - 1, y0 - rad - 1,
5619                        x0 + rad + 1, y0 + rad + 1);
5620
5621         /* Check to see if there is room for an inner vault */
5622         for (x = x0 - 2; x <= x0 + 2; x++)
5623         {
5624                 for (y = y0 - 2; y <= y0 + 2; y++)
5625                 {
5626                         if (!is_floor_bold(y, x))
5627                         {
5628                                 /* Wall in the way */
5629                                 emptyflag = FALSE;
5630                         }
5631                 }
5632         }
5633
5634         if (emptyflag && one_in_(2))
5635         {
5636                 /* Build the vault */
5637                 build_small_room(x0, y0);
5638
5639                 /* Place a treasure in the vault */
5640                 place_object(y0, x0, 0L);
5641
5642                 /* Let's guard the treasure well */
5643                 vault_monsters(y0, x0, randint0(2) + 3);
5644
5645                 /* Traps naturally */
5646                 vault_traps(y0, x0, 4, 4, randint0(3) + 2);
5647         }
5648
5649         return TRUE;
5650 }
5651
5652
5653 /*
5654  * Helper function for "trapped monster pit"
5655  */
5656 static bool vault_aux_trapped_pit(MONRACE_IDX r_idx)
5657 {
5658         monster_race *r_ptr = &r_info[r_idx];
5659
5660         /* Validate the monster */
5661         if (!vault_monster_okay(r_idx)) return (FALSE);
5662
5663         /* No wall passing monster */
5664         if (r_ptr->flags2 & (RF2_PASS_WALL | RF2_KILL_WALL)) return (FALSE);
5665
5666         /* Okay */
5667         return (TRUE);
5668 }
5669
5670
5671 /*!
5672  * @brief タイプ13の部屋…トラップpitの生成 / Type 13 -- Trapped monster pits
5673  * @return なし
5674  * @details
5675  * A trapped monster pit is a "big" room with a straight corridor in\n
5676  * which wall opening traps are placed, and with two "inner" rooms\n
5677  * containing a "collection" of monsters of a given type organized in\n
5678  * the room.\n
5679  *\n
5680  * The trapped monster pit appears as shown below, where the actual\n
5681  * monsters in each location depend on the type of the pit\n
5682  *\n
5683  *  XXXXXXXXXXXXXXXXXXXXXXXXX\n
5684  *  X                       X\n
5685  *  XXXXXXXXXXXXXXXXXXXXXXX X\n
5686  *  XXXXX001123454321100XXX X\n
5687  *  XXX0012234567654322100X X\n
5688  *  XXXXXXXXXXXXXXXXXXXXXXX X\n
5689  *  X           ^           X\n
5690  *  X XXXXXXXXXXXXXXXXXXXXXXX\n
5691  *  X X0012234567654322100XXX\n
5692  *  X XXX001123454321100XXXXX\n
5693  *  X XXXXXXXXXXXXXXXXXXXXXXX\n
5694  *  X                       X\n
5695  *  XXXXXXXXXXXXXXXXXXXXXXXXX\n
5696  *\n
5697  * Note that the monsters in the pit are now chosen by using "get_mon_num()"\n
5698  * to request 16 "appropriate" monsters, sorting them by level, and using\n
5699  * the "even" entries in this sorted list for the contents of the pit.\n
5700  *\n
5701  * Hack -- all of the "dragons" in a "dragon" pit must be the same "color",\n
5702  * which is handled by requiring a specific "breath" attack for all of the\n
5703  * dragons.  This may include "multi-hued" breath.  Note that "wyrms" may\n
5704  * be present in many of the dragon pits, if they have the proper breath.\n
5705  *\n
5706  * Note the use of the "get_mon_num_prep()" function, and the special\n
5707  * "get_mon_num_hook()" restriction function, to prepare the "monster\n
5708  * allocation table" in such a way as to optimize the selection of\n
5709  * "appropriate" non-unique monsters for the pit.\n
5710  *\n
5711  * Note that the "get_mon_num()" function may (rarely) fail, in which case\n
5712  * the pit will be empty.\n
5713  *\n
5714  * Note that "monster pits" will never contain "unique" monsters.\n
5715  */
5716 static bool build_type13(void)
5717 {
5718         static int placing[][3] = {
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, +9, 0}, {-2, +8, 0}, {-3, +7, 0}, {-3, +6, 0},
5722                 {+2, +9, 0}, {+2, +8, 0}, {+3, +7, 0}, {+3, +6, 0},
5723                 {-2, -7, 1}, {-3, -5, 1}, {-3, -4, 1},
5724                 {+2, -7, 1}, {+3, -5, 1}, {+3, -4, 1},
5725                 {-2, +7, 1}, {-3, +5, 1}, {-3, +4, 1},
5726                 {+2, +7, 1}, {+3, +5, 1}, {+3, +4, 1},
5727                 {-2, -6, 2}, {-2, -5, 2}, {-3, -3, 2},
5728                 {+2, -6, 2}, {+2, -5, 2}, {+3, -3, 2},
5729                 {-2, +6, 2}, {-2, +5, 2}, {-3, +3, 2},
5730                 {+2, +6, 2}, {+2, +5, 2}, {+3, +3, 2},
5731                 {-2, -4, 3}, {-3, -2, 3},
5732                 {+2, -4, 3}, {+3, -2, 3},
5733                 {-2, +4, 3}, {-3, +2, 3},
5734                 {+2, +4, 3}, {+3, +2, 3},
5735                 {-2, -3, 4}, {-3, -1, 4},
5736                 {+2, -3, 4}, {+3, -1, 4},
5737                 {-2, +3, 4}, {-3, +1, 4},
5738                 {+2, +3, 4}, {+3, +1, 4},
5739                 {-2, -2, 5}, {-3, 0, 5}, {-2, +2, 5},
5740                 {+2, -2, 5}, {+3, 0, 5}, {+2, +2, 5},
5741                 {-2, -1, 6}, {-2, +1, 6},
5742                 {+2, -1, 6}, {+2, +1, 6},
5743                 {-2, 0, 7}, {+2, 0, 7},
5744                 {0, 0, -1}
5745         };
5746
5747         int y, x, y1, x1, y2, x2, xval, yval;
5748         int i, j;
5749
5750         int what[16];
5751
5752         monster_type align;
5753
5754         cave_type *c_ptr;
5755
5756         int cur_pit_type = pick_vault_type(pit_types, d_info[dungeon_type].pit);
5757         vault_aux_type *n_ptr;
5758
5759         /* Only in Angband */
5760         if (dungeon_type != DUNGEON_ANGBAND) return FALSE;
5761
5762         /* No type available */
5763         if (cur_pit_type < 0) return FALSE;
5764
5765         n_ptr = &pit_types[cur_pit_type];
5766
5767         /* Process a preparation function if necessary */
5768         if (n_ptr->prep_func) (*(n_ptr->prep_func))();
5769
5770         /* Prepare allocation table */
5771         get_mon_num_prep(n_ptr->hook_func, vault_aux_trapped_pit);
5772
5773         align.sub_align = SUB_ALIGN_NEUTRAL;
5774
5775         /* Pick some monster types */
5776         for (i = 0; i < 16; i++)
5777         {
5778                 MONRACE_IDX r_idx = 0;
5779                 int attempts = 100;
5780                 monster_race *r_ptr = NULL;
5781
5782                 while (attempts--)
5783                 {
5784                         /* Get a (hard) monster type */
5785                         r_idx = get_mon_num(dun_level + 0);
5786                         r_ptr = &r_info[r_idx];
5787
5788                         /* Decline incorrect alignment */
5789                         if (monster_has_hostile_align(&align, 0, 0, r_ptr)) continue;
5790
5791                         /* Accept this monster */
5792                         break;
5793                 }
5794
5795                 /* Notice failure */
5796                 if (!r_idx || !attempts) return FALSE;
5797
5798                 /* Note the alignment */
5799                 if (r_ptr->flags3 & RF3_EVIL) align.sub_align |= SUB_ALIGN_EVIL;
5800                 if (r_ptr->flags3 & RF3_GOOD) align.sub_align |= SUB_ALIGN_GOOD;
5801
5802                 what[i] = r_idx;
5803         }
5804
5805         /* Find and reserve some space in the dungeon.  Get center of room. */
5806         if (!find_space(&yval, &xval, 13, 25)) return FALSE;
5807
5808         /* Large room */
5809         y1 = yval - 5;
5810         y2 = yval + 5;
5811         x1 = xval - 11;
5812         x2 = xval + 11;
5813
5814         /* Fill with inner walls */
5815         for (y = y1 - 1; y <= y2 + 1; y++)
5816         {
5817                 for (x = x1 - 1; x <= x2 + 1; x++)
5818                 {
5819                         c_ptr = &cave[y][x];
5820                         place_inner_grid(c_ptr);
5821                         c_ptr->info |= (CAVE_ROOM);
5822                 }
5823         }
5824
5825         /* Place the floor area 1 */
5826         for (x = x1 + 3; x <= x2 - 3; x++)
5827         {
5828                 c_ptr = &cave[yval-2][x];
5829                 place_floor_grid(c_ptr);
5830                 add_cave_info(yval-2, x, CAVE_ICKY);
5831
5832                 c_ptr = &cave[yval+2][x];
5833                 place_floor_grid(c_ptr);
5834                 add_cave_info(yval+2, x, CAVE_ICKY);
5835         }
5836
5837         /* Place the floor area 2 */
5838         for (x = x1 + 5; x <= x2 - 5; x++)
5839         {
5840                 c_ptr = &cave[yval-3][x];
5841                 place_floor_grid(c_ptr);
5842                 add_cave_info(yval-3, x, CAVE_ICKY);
5843
5844                 c_ptr = &cave[yval+3][x];
5845                 place_floor_grid(c_ptr);
5846                 add_cave_info(yval+3, x, CAVE_ICKY);
5847         }
5848
5849         /* Corridor */
5850         for (x = x1; x <= x2; x++)
5851         {
5852                 c_ptr = &cave[yval][x];
5853                 place_floor_grid(c_ptr);
5854                 c_ptr = &cave[y1][x];
5855                 place_floor_grid(c_ptr);
5856                 c_ptr = &cave[y2][x];
5857                 place_floor_grid(c_ptr);
5858         }
5859
5860         /* Place the outer walls */
5861         for (y = y1 - 1; y <= y2 + 1; y++)
5862         {
5863                 c_ptr = &cave[y][x1 - 1];
5864                 place_outer_grid(c_ptr);
5865                 c_ptr = &cave[y][x2 + 1];
5866                 place_outer_grid(c_ptr);
5867         }
5868         for (x = x1 - 1; x <= x2 + 1; x++)
5869         {
5870                 c_ptr = &cave[y1 - 1][x];
5871                 place_outer_grid(c_ptr);
5872                 c_ptr = &cave[y2 + 1][x];
5873                 place_outer_grid(c_ptr);
5874         }
5875
5876         /* Random corridor */
5877         if (one_in_(2))
5878         {
5879                 for (y = y1; y <= yval; y++)
5880                 {
5881                         place_floor_bold(y, x2);
5882                         place_solid_bold(y, x1-1);
5883                 }
5884                 for (y = yval; y <= y2 + 1; y++)
5885                 {
5886                         place_floor_bold(y, x1);
5887                         place_solid_bold(y, x2+1);
5888                 }
5889         }
5890         else
5891         {
5892                 for (y = yval; y <= y2 + 1; y++)
5893                 {
5894                         place_floor_bold(y, x1);
5895                         place_solid_bold(y, x2+1);
5896                 }
5897                 for (y = y1; y <= yval; y++)
5898                 {
5899                         place_floor_bold(y, x2);
5900                         place_solid_bold(y, x1-1);
5901                 }
5902         }
5903
5904         /* Place the wall open trap */
5905         cave[yval][xval].mimic = cave[yval][xval].feat;
5906         cave[yval][xval].feat = feat_trap_open;
5907
5908         /* Sort the entries */
5909         for (i = 0; i < 16 - 1; i++)
5910         {
5911                 /* Sort the entries */
5912                 for (j = 0; j < 16 - 1; j++)
5913                 {
5914                         int i1 = j;
5915                         int i2 = j + 1;
5916
5917                         int p1 = r_info[what[i1]].level;
5918                         int p2 = r_info[what[i2]].level;
5919
5920                         /* Bubble */
5921                         if (p1 > p2)
5922                         {
5923                                 int tmp = what[i1];
5924                                 what[i1] = what[i2];
5925                                 what[i2] = tmp;
5926                         }
5927                 }
5928         }
5929
5930         msg_format_wizard(CHEAT_DUNGEON, _("%s%sの罠ピットが生成されました。", "Trapped monster pit (%s%s)"),
5931                 n_ptr->name, pit_subtype_string(cur_pit_type, FALSE));
5932
5933         /* Select the entries */
5934         for (i = 0; i < 8; i++)
5935         {
5936                 /* Every other entry */
5937                 what[i] = what[i * 2];
5938
5939                 if (cheat_hear)
5940                 {
5941                         /* Message */
5942                         msg_print(r_name + r_info[what[i]].name);
5943                 }
5944         }
5945
5946         for (i = 0; placing[i][2] >= 0; i++)
5947         {
5948                 y = yval + placing[i][0];
5949                 x = xval + placing[i][1];
5950                 place_monster_aux(0, y, x, what[placing[i][2]], PM_NO_KAGE);
5951         }
5952
5953         return TRUE;
5954 }
5955
5956
5957 /*!
5958  * @brief タイプ14の部屋…特殊トラップ部屋の生成 / Type 14 -- trapped rooms
5959  * @return なし
5960  * @details
5961  * A special trap is placed at center of the room
5962  */
5963 static bool build_type14(void)
5964 {
5965         int y, x, y2, x2, yval, xval;
5966         int y1, x1, xsize, ysize;
5967
5968         bool light;
5969
5970         cave_type *c_ptr;
5971         s16b trap;
5972
5973         /* Pick a room size */
5974         y1 = randint1(4);
5975         x1 = randint1(11);
5976         y2 = randint1(3);
5977         x2 = randint1(11);
5978
5979         xsize = x1 + x2 + 1;
5980         ysize = y1 + y2 + 1;
5981
5982         /* Find and reserve some space in the dungeon.  Get center of room. */
5983         if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE;
5984
5985         /* Choose lite or dark */
5986         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
5987
5988
5989         /* Get corner values */
5990         y1 = yval - ysize / 2;
5991         x1 = xval - xsize / 2;
5992         y2 = yval + (ysize - 1) / 2;
5993         x2 = xval + (xsize - 1) / 2;
5994
5995
5996         /* Place a full floor under the room */
5997         for (y = y1 - 1; y <= y2 + 1; y++)
5998         {
5999                 for (x = x1 - 1; x <= x2 + 1; x++)
6000                 {
6001                         c_ptr = &cave[y][x];
6002                         place_floor_grid(c_ptr);
6003                         c_ptr->info |= (CAVE_ROOM);
6004                         if (light) c_ptr->info |= (CAVE_GLOW);
6005                 }
6006         }
6007
6008         /* Walls around the room */
6009         for (y = y1 - 1; y <= y2 + 1; y++)
6010         {
6011                 c_ptr = &cave[y][x1 - 1];
6012                 place_outer_grid(c_ptr);
6013                 c_ptr = &cave[y][x2 + 1];
6014                 place_outer_grid(c_ptr);
6015         }
6016         for (x = x1 - 1; x <= x2 + 1; x++)
6017         {
6018                 c_ptr = &cave[y1 - 1][x];
6019                 place_outer_grid(c_ptr);
6020                 c_ptr = &cave[y2 + 1][x];
6021                 place_outer_grid(c_ptr);
6022         }
6023
6024         if (dun_level < 30 + randint1(30))
6025                 trap = feat_trap_piranha;
6026         else
6027                 trap = feat_trap_armageddon;
6028
6029         /* Place a special trap */
6030         c_ptr = &cave[rand_spread(yval, ysize/4)][rand_spread(xval, xsize/4)];
6031         c_ptr->mimic = c_ptr->feat;
6032         c_ptr->feat = trap;
6033
6034         msg_format_wizard(CHEAT_DUNGEON, _("%sの部屋が生成されました。", "Room of %s was generated."), f_name + f_info[trap].name);
6035
6036         return TRUE;
6037 }
6038
6039
6040 /*
6041  * Helper function for "glass room"
6042  */
6043 static bool vault_aux_lite(MONRACE_IDX r_idx)
6044 {
6045         monster_race *r_ptr = &r_info[r_idx];
6046
6047         /* Validate the monster */
6048         if (!vault_monster_okay(r_idx)) return FALSE;
6049
6050         /* Require lite attack */
6051         if (!(r_ptr->flags4 & RF4_BR_LITE) && !(r_ptr->a_ability_flags1 & RF5_BA_LITE)) return FALSE;
6052
6053         /* No wall passing monsters */
6054         if (r_ptr->flags2 & (RF2_PASS_WALL | RF2_KILL_WALL)) return FALSE;
6055
6056         /* No disintegrating monsters */
6057         if (r_ptr->flags4 & RF4_BR_DISI) return FALSE;
6058
6059         return TRUE;
6060 }
6061
6062 /*
6063  * Helper function for "glass room"
6064  */
6065 static bool vault_aux_shards(MONRACE_IDX r_idx)
6066 {
6067         monster_race *r_ptr = &r_info[r_idx];
6068
6069         /* Validate the monster */
6070         if (!vault_monster_okay(r_idx)) return FALSE;
6071
6072         /* Require shards breath attack */
6073         if (!(r_ptr->flags4 & RF4_BR_SHAR)) return FALSE;
6074
6075         return TRUE;
6076 }
6077
6078 /*
6079  * Hack -- determine if a template is potion
6080  */
6081 static bool kind_is_potion(int k_idx)
6082 {
6083         return k_info[k_idx].tval == TV_POTION;
6084 }
6085
6086 /*!
6087  * @brief タイプ15の部屋…ガラス部屋の生成 / Type 15 -- glass rooms
6088  * @return なし
6089  */
6090 static bool build_type15(void)
6091 {
6092         int y, x, y2, x2, yval, xval;
6093         int y1, x1, xsize, ysize;
6094         bool light;
6095
6096         cave_type *c_ptr;
6097
6098         /* Pick a room size */
6099         xsize = rand_range(9, 13);
6100         ysize = rand_range(9, 13);
6101
6102         /* Find and reserve some space in the dungeon.  Get center of room. */
6103         if (!find_space(&yval, &xval, ysize + 2, xsize + 2)) return FALSE;
6104
6105         /* Choose lite or dark */
6106         light = ((dun_level <= randint1(25)) && !(d_info[dungeon_type].flags1 & DF1_DARKNESS));
6107
6108         /* Get corner values */
6109         y1 = yval - ysize / 2;
6110         x1 = xval - xsize / 2;
6111         y2 = yval + (ysize - 1) / 2;
6112         x2 = xval + (xsize - 1) / 2;
6113
6114         /* Place a full floor under the room */
6115         for (y = y1 - 1; y <= y2 + 1; y++)
6116         {
6117                 for (x = x1 - 1; x <= x2 + 1; x++)
6118                 {
6119                         c_ptr = &cave[y][x];
6120                         place_floor_grid(c_ptr);
6121                         c_ptr->feat = feat_glass_floor;
6122                         c_ptr->info |= (CAVE_ROOM);
6123                         if (light) c_ptr->info |= (CAVE_GLOW);
6124                 }
6125         }
6126
6127         /* Walls around the room */
6128         for (y = y1 - 1; y <= y2 + 1; y++)
6129         {
6130                 c_ptr = &cave[y][x1 - 1];
6131                 place_outer_grid(c_ptr);
6132                 c_ptr->feat = feat_glass_wall;
6133                 c_ptr = &cave[y][x2 + 1];
6134                 place_outer_grid(c_ptr);
6135                 c_ptr->feat = feat_glass_wall;
6136         }
6137         for (x = x1 - 1; x <= x2 + 1; x++)
6138         {
6139                 c_ptr = &cave[y1 - 1][x];
6140                 place_outer_grid(c_ptr);
6141                 c_ptr->feat = feat_glass_wall;
6142                 c_ptr = &cave[y2 + 1][x];
6143                 place_outer_grid(c_ptr);
6144                 c_ptr->feat = feat_glass_wall;
6145         }
6146
6147         switch (randint1(3))
6148         {
6149         case 1: /* 4 lite breathers + potion */
6150                 {
6151                         int dir1, dir2;
6152
6153                         /* Prepare allocation table */
6154                         get_mon_num_prep(vault_aux_lite, NULL);
6155
6156                         /* Place fixed lite berathers */
6157                         for (dir1 = 4; dir1 < 8; dir1++)
6158                         {
6159                                 MONRACE_IDX r_idx = get_mon_num(dun_level);
6160
6161                                 y = yval + 2 * ddy_ddd[dir1];
6162                                 x = xval + 2 * ddx_ddd[dir1];
6163                                 if (r_idx) place_monster_aux(0, y, x, r_idx, PM_ALLOW_SLEEP);
6164
6165                                 /* Walls around the breather */
6166                                 for (dir2 = 0; dir2 < 8; dir2++)
6167                                 {
6168                                         c_ptr = &cave[y + ddy_ddd[dir2]][x + ddx_ddd[dir2]];
6169                                         place_inner_grid(c_ptr);
6170                                         c_ptr->feat = feat_glass_wall;
6171                                 }
6172                         }
6173
6174                         /* Walls around the potion */
6175                         for (dir1 = 0; dir1 < 4; dir1++)
6176                         {
6177                                 y = yval + 2 * ddy_ddd[dir1];
6178                                 x = xval + 2 * ddx_ddd[dir1];
6179                                 c_ptr = &cave[y][x];
6180                                 place_inner_perm_grid(c_ptr);
6181                                 c_ptr->feat = feat_permanent_glass_wall;
6182                                 cave[yval + ddy_ddd[dir1]][xval + ddx_ddd[dir1]].info |= (CAVE_ICKY);
6183                         }
6184
6185                         /* Glass door */
6186                         dir1 = randint0(4);
6187                         y = yval + 2 * ddy_ddd[dir1];
6188                         x = xval + 2 * ddx_ddd[dir1];
6189                         place_secret_door(y, x, DOOR_GLASS_DOOR);
6190                         c_ptr = &cave[y][x];
6191                         if (is_closed_door(c_ptr->feat)) c_ptr->mimic = feat_glass_wall;
6192
6193                         /* Place a potion */
6194                         get_obj_num_hook = kind_is_potion;
6195                         place_object(yval, xval, AM_NO_FIXED_ART);
6196                         cave[yval][xval].info |= (CAVE_ICKY);
6197                 }
6198                 break;
6199
6200         case 2: /* 1 lite breather + random object */
6201                 {
6202                         MONRACE_IDX r_idx;
6203                         DIRECTION dir1;
6204
6205                         /* Pillars */
6206                         c_ptr = &cave[y1 + 1][x1 + 1];
6207                         place_inner_grid(c_ptr);
6208                         c_ptr->feat = feat_glass_wall;
6209
6210                         c_ptr = &cave[y1 + 1][x2 - 1];
6211                         place_inner_grid(c_ptr);
6212                         c_ptr->feat = feat_glass_wall;
6213
6214                         c_ptr = &cave[y2 - 1][x1 + 1];
6215                         place_inner_grid(c_ptr);
6216                         c_ptr->feat = feat_glass_wall;
6217
6218                         c_ptr = &cave[y2 - 1][x2 - 1];
6219                         place_inner_grid(c_ptr);
6220                         c_ptr->feat = feat_glass_wall;
6221
6222                         /* Prepare allocation table */
6223                         get_mon_num_prep(vault_aux_lite, NULL);
6224
6225                         r_idx = get_mon_num(dun_level);
6226                         if (r_idx) place_monster_aux(0, yval, xval, r_idx, 0L);
6227
6228                         /* Walls around the breather */
6229                         for (dir1 = 0; dir1 < 8; dir1++)
6230                         {
6231                                 c_ptr = &cave[yval + ddy_ddd[dir1]][xval + ddx_ddd[dir1]];
6232                                 place_inner_grid(c_ptr);
6233                                 c_ptr->feat = feat_glass_wall;
6234                         }
6235
6236                         /* Curtains around the breather */
6237                         for (y = yval - 1; y <= yval + 1; y++)
6238                         {
6239                                 place_closed_door(y, xval - 2, DOOR_CURTAIN);
6240                                 place_closed_door(y, xval + 2, DOOR_CURTAIN);
6241                         }
6242                         for (x = xval - 1; x <= xval + 1; x++)
6243                         {
6244                                 place_closed_door(yval - 2, x, DOOR_CURTAIN);
6245                                 place_closed_door(yval + 2, x, DOOR_CURTAIN);
6246                         }
6247
6248                         /* Place an object */
6249                         place_object(yval, xval, AM_NO_FIXED_ART);
6250                         cave[yval][xval].info |= (CAVE_ICKY);
6251                 }
6252                 break;
6253
6254         case 3: /* 4 shards breathers + 2 potions */
6255                 {
6256                         int dir1;
6257
6258                         /* Walls around the potion */
6259                         for (y = yval - 2; y <= yval + 2; y++)
6260                         {
6261                                 c_ptr = &cave[y][xval - 3];
6262                                 place_inner_grid(c_ptr);
6263                                 c_ptr->feat = feat_glass_wall;
6264                                 c_ptr = &cave[y][xval + 3];
6265                                 place_inner_grid(c_ptr);
6266                                 c_ptr->feat = feat_glass_wall;
6267                         }
6268                         for (x = xval - 2; x <= xval + 2; x++)
6269                         {
6270                                 c_ptr = &cave[yval - 3][x];
6271                                 place_inner_grid(c_ptr);
6272                                 c_ptr->feat = feat_glass_wall;
6273                                 c_ptr = &cave[yval + 3][x];
6274                                 place_inner_grid(c_ptr);
6275                                 c_ptr->feat = feat_glass_wall;
6276                         }
6277                         for (dir1 = 4; dir1 < 8; dir1++)
6278                         {
6279                                 c_ptr = &cave[yval + 2 * ddy_ddd[dir1]][xval + 2 * ddx_ddd[dir1]];
6280                                 place_inner_grid(c_ptr);
6281                                 c_ptr->feat = feat_glass_wall;
6282                         }
6283
6284                         /* Prepare allocation table */
6285                         get_mon_num_prep(vault_aux_shards, NULL);
6286
6287                         /* Place shard berathers */
6288                         for (dir1 = 4; dir1 < 8; dir1++)
6289                         {
6290                                 MONRACE_IDX r_idx = get_mon_num(dun_level);
6291
6292                                 y = yval + ddy_ddd[dir1];
6293                                 x = xval + ddx_ddd[dir1];
6294                                 if (r_idx) place_monster_aux(0, y, x, r_idx, 0L);
6295                         }
6296
6297                         /* Place two potions */
6298                         if (one_in_(2))
6299                         {
6300                                 get_obj_num_hook = kind_is_potion;
6301                                 place_object(yval, xval - 1, AM_NO_FIXED_ART);
6302                                 get_obj_num_hook = kind_is_potion;
6303                                 place_object(yval, xval + 1, AM_NO_FIXED_ART);
6304                         }
6305                         else
6306                         {
6307                                 get_obj_num_hook = kind_is_potion;
6308                                 place_object(yval - 1, xval, AM_NO_FIXED_ART);
6309                                 get_obj_num_hook = kind_is_potion;
6310                                 place_object(yval + 1, xval, AM_NO_FIXED_ART);
6311                         }
6312
6313                         for (y = yval - 2; y <= yval + 2; y++)
6314                                 for (x = xval - 2; x <= xval + 2; x++)
6315                                         cave[y][x].info |= (CAVE_ICKY);
6316
6317                 }
6318                 break;
6319         }
6320
6321         msg_print_wizard(CHEAT_DUNGEON, _("ガラスの部屋が生成されました。", "Glass room was generated."));
6322
6323         return TRUE;
6324 }
6325
6326
6327 /* Create a new floor room with optional light */
6328 void generate_room_floor(int y1, int x1, int y2, int x2, int light)
6329 {
6330         int y, x;
6331
6332         cave_type *c_ptr;
6333
6334         for (y = y1; y <= y2; y++)
6335         {
6336                 for (x = x1; x <= x2; x++)
6337                 {
6338                         /* Point to grid */
6339                         c_ptr = &cave[y][x];
6340                         place_floor_grid(c_ptr);
6341                         c_ptr->info |= (CAVE_ROOM);
6342                         if (light) c_ptr->info |= (CAVE_GLOW);
6343                 }
6344         }
6345 }
6346
6347 void generate_fill_perm_bold(int y1, int x1, int y2, int x2)
6348 {
6349         int y, x;
6350
6351         for (y = y1; y <= y2; y++)
6352         {
6353                 for (x = x1; x <= x2; x++)
6354                 {
6355                         /* Point to grid */
6356                         place_inner_perm_bold(y, x);
6357                 }
6358         }
6359 }
6360
6361 /* Minimum & maximum town size */
6362 #define MIN_TOWN_WID ((MAX_WID / 3) / 2)
6363 #define MIN_TOWN_HGT ((MAX_HGT / 3) / 2)
6364 #define MAX_TOWN_WID ((MAX_WID / 3) * 2 / 3)
6365 #define MAX_TOWN_HGT ((MAX_HGT / 3) * 2 / 3)
6366
6367 /* Struct for build underground buildings */
6368 typedef struct
6369 {
6370         int y0, x0; /* North-west corner (relative) */
6371         int y1, x1; /* South-east corner (relative) */
6372 }
6373 ugbldg_type;
6374
6375 ugbldg_type *ugbldg;
6376
6377 /*
6378  * Precalculate buildings' location of underground arcade
6379  */
6380 static bool precalc_ugarcade(int town_hgt, int town_wid, int n)
6381 {
6382         int i, y, x, center_y, center_x, tmp, attempt = 10000;
6383         int max_bldg_hgt = 3 * town_hgt / MAX_TOWN_HGT;
6384         int max_bldg_wid = 5 * town_wid / MAX_TOWN_WID;
6385         ugbldg_type *cur_ugbldg;
6386         bool **ugarcade_used, abort;
6387
6388         /* Allocate "ugarcade_used" array (2-dimension) */
6389         C_MAKE(ugarcade_used, town_hgt, bool *);
6390         C_MAKE(*ugarcade_used, town_hgt * town_wid, bool);
6391         for (y = 1; y < town_hgt; y++) ugarcade_used[y] = *ugarcade_used + y * town_wid;
6392
6393         /* Calculate building locations */
6394         for (i = 0; i < n; i++)
6395         {
6396                 cur_ugbldg = &ugbldg[i];
6397                 (void)WIPE(cur_ugbldg, ugbldg_type);
6398
6399                 do
6400                 {
6401                         /* Find the "center" of the store */
6402                         center_y = rand_range(2, town_hgt - 3);
6403                         center_x = rand_range(2, town_wid - 3);
6404
6405                         /* Determine the store boundaries */
6406                         tmp = center_y - randint1(max_bldg_hgt);
6407                         cur_ugbldg->y0 = MAX(tmp, 1);
6408                         tmp = center_x - randint1(max_bldg_wid);
6409                         cur_ugbldg->x0 = MAX(tmp, 1);
6410                         tmp = center_y + randint1(max_bldg_hgt);
6411                         cur_ugbldg->y1 = MIN(tmp, town_hgt - 2);
6412                         tmp = center_x + randint1(max_bldg_wid);
6413                         cur_ugbldg->x1 = MIN(tmp, town_wid - 2);
6414
6415                         /* Scan this building's area */
6416                         for (abort = FALSE, y = cur_ugbldg->y0; (y <= cur_ugbldg->y1) && !abort; y++)
6417                         {
6418                                 for (x = cur_ugbldg->x0; x <= cur_ugbldg->x1; x++)
6419                                 {
6420                                         if (ugarcade_used[y][x])
6421                                         {
6422                                                 abort = TRUE;
6423                                                 break;
6424                                         }
6425                                 }
6426                         }
6427
6428                         attempt--;
6429                 }
6430                 while (abort && attempt); /* Accept this building if no overlapping */
6431
6432                 /* Failed to generate underground arcade */
6433                 if (!attempt) break;
6434
6435                 /*
6436                  * Mark to ugarcade_used[][] as "used"
6437                  * Note: Building-adjacent grids are included for preventing
6438                  * connected bulidings.
6439                  */
6440                 for (y = cur_ugbldg->y0 - 1; y <= cur_ugbldg->y1 + 1; y++)
6441                 {
6442                         for (x = cur_ugbldg->x0 - 1; x <= cur_ugbldg->x1 + 1; x++)
6443                         {
6444                                 ugarcade_used[y][x] = TRUE;
6445                         }
6446                 }
6447         }
6448
6449         /* Free "ugarcade_used" array (2-dimension) */
6450         C_KILL(*ugarcade_used, town_hgt * town_wid, bool);
6451         C_KILL(ugarcade_used, town_hgt, bool *);
6452
6453         /* If i < n, generation is not allowed */
6454         return i == n;
6455 }
6456
6457 /*!
6458  * @brief タイプ16の部屋…地下都市生成のサブルーチン / Actually create buildings
6459  * @return なし
6460  * @param ltcy 生成基準Y座標
6461  * @param ltcx 生成基準X座標
6462  * @param stotes[] 生成する店舗のリスト
6463  * @param n 生成する店舗の数
6464  * @note
6465  * Note: ltcy and ltcx indicate "left top corner".
6466  */
6467 static void build_stores(int ltcy, int ltcx, int stores[], int n)
6468 {
6469         int i, y, x;
6470         IDX j;
6471         ugbldg_type *cur_ugbldg;
6472
6473         for (i = 0; i < n; i++)
6474         {
6475                 cur_ugbldg = &ugbldg[i];
6476
6477                 /* Generate new room */
6478                 generate_room_floor(
6479                         ltcy + cur_ugbldg->y0 - 2, ltcx + cur_ugbldg->x0 - 2,
6480                         ltcy + cur_ugbldg->y1 + 2, ltcx + cur_ugbldg->x1 + 2,
6481                         FALSE);
6482         }
6483
6484         for (i = 0; i < n; i++)
6485         {
6486                 cur_ugbldg = &ugbldg[i];
6487
6488                 /* Build an invulnerable rectangular building */
6489                 generate_fill_perm_bold(
6490                         ltcy + cur_ugbldg->y0, ltcx + cur_ugbldg->x0,
6491                         ltcy + cur_ugbldg->y1, ltcx + cur_ugbldg->x1);
6492
6493                 /* Pick a door direction (S,N,E,W) */
6494                 switch (randint0(4))
6495                 {
6496                 /* Bottom side */
6497                 case 0:
6498                         y = cur_ugbldg->y1;
6499                         x = rand_range(cur_ugbldg->x0, cur_ugbldg->x1);
6500                         break;
6501
6502                 /* Top side */
6503                 case 1:
6504                         y = cur_ugbldg->y0;
6505                         x = rand_range(cur_ugbldg->x0, cur_ugbldg->x1);
6506                         break;
6507
6508                 /* Right side */
6509                 case 2:
6510                         y = rand_range(cur_ugbldg->y0, cur_ugbldg->y1);
6511                         x = cur_ugbldg->x1;
6512                         break;
6513
6514                 /* Left side */
6515                 default:
6516                         y = rand_range(cur_ugbldg->y0, cur_ugbldg->y1);
6517                         x = cur_ugbldg->x0;
6518                         break;
6519                 }
6520
6521                 for (j = 0; j < max_f_idx; j++)
6522                 {
6523                         if (have_flag(f_info[j].flags, FF_STORE))
6524                         {
6525                                 if (f_info[j].subtype == stores[i]) break;
6526                         }
6527                 }
6528
6529                 /* Clear previous contents, add a store door */
6530                 if (j < max_f_idx)
6531                 {
6532                         cave_set_feat(ltcy + y, ltcx + x, j);
6533
6534                         /* Init store */
6535                         store_init(NO_TOWN, stores[i]);
6536                 }
6537         }
6538 }
6539
6540
6541 /*!
6542  * @brief タイプ16の部屋…地下都市の生成 / Type 16 -- Underground Arcade
6543  * @return なし
6544  * @details
6545  * Town logic flow for generation of new town\n
6546  * Originally from Vanilla 3.0.3\n
6547  *\n
6548  * We start with a fully wiped cave of normal floors.\n
6549  *\n
6550  * Note that town_gen_hack() plays games with the R.N.G.\n
6551  *\n
6552  * This function does NOT do anything about the owners of the stores,\n
6553  * nor the contents thereof.  It only handles the physical layout.\n
6554  */
6555 static bool build_type16(void)
6556 {
6557         int stores[] =
6558         {
6559                 STORE_GENERAL, STORE_ARMOURY, STORE_WEAPON, STORE_TEMPLE,
6560                 STORE_ALCHEMIST, STORE_MAGIC, STORE_BLACK, STORE_BOOK,
6561         };
6562         int n = sizeof stores / sizeof (int);
6563         int i, y, x, y1, x1, yval, xval;
6564         int town_hgt = rand_range(MIN_TOWN_HGT, MAX_TOWN_HGT);
6565         int town_wid = rand_range(MIN_TOWN_WID, MAX_TOWN_WID);
6566         bool prevent_bm = FALSE;
6567
6568         /* Hack -- If already exist black market, prevent building */
6569         for (y = 0; (y < cur_hgt) && !prevent_bm; y++)
6570         {
6571                 for (x = 0; x < cur_wid; x++)
6572                 {
6573                         if (cave[y][x].feat == FF_STORE)
6574                         {
6575                                 prevent_bm = (f_info[cave[y][x].feat].subtype == STORE_BLACK);
6576                                 break;
6577                         }
6578                 }
6579         }
6580         for (i = 0; i < n; i++)
6581         {
6582                 if ((stores[i] == STORE_BLACK) && prevent_bm) stores[i] = stores[--n];
6583         }
6584         if (!n) return FALSE;
6585
6586         /* Allocate buildings array */
6587         C_MAKE(ugbldg, n, ugbldg_type);
6588
6589         /* If cannot build stores, abort */
6590         if (!precalc_ugarcade(town_hgt, town_wid, n))
6591         {
6592                 /* Free buildings array */
6593                 C_KILL(ugbldg, n, ugbldg_type);
6594                 return FALSE;
6595         }
6596
6597         /* Find and reserve some space in the dungeon.  Get center of room. */
6598         if (!find_space(&yval, &xval, town_hgt + 4, town_wid + 4))
6599         {
6600                 /* Free buildings array */
6601                 C_KILL(ugbldg, n, ugbldg_type);
6602                 return FALSE;
6603         }
6604
6605         /* Get top left corner */
6606         y1 = yval - (town_hgt / 2);
6607         x1 = xval - (town_wid / 2);
6608
6609         /* Generate new room */
6610         generate_room_floor(
6611                 y1 + town_hgt / 3, x1 + town_wid / 3,
6612                 y1 + town_hgt * 2 / 3, x1 + town_wid * 2 / 3, FALSE);
6613
6614         /* Build stores */
6615         build_stores(y1, x1, stores, n);
6616
6617         msg_print_wizard(CHEAT_DUNGEON, _("地下街を生成しました", "Underground arcade was generated."));
6618
6619         /* Free buildings array */
6620         C_KILL(ugbldg, n, ugbldg_type);
6621
6622         return TRUE;
6623 }
6624
6625
6626 /*!
6627  * @brief 与えられた部屋型IDに応じて部屋の生成処理分岐を行い結果を返す / Attempt to build a room of the given type at the given block
6628  * @param type 部屋型ID
6629  * @note that we restrict the number of "crowded" rooms to reduce the chance of overflowing the monster list during level creation.
6630  * @return 部屋の精製に成功した場合 TRUE を返す。
6631  */
6632 static bool room_build(int typ)
6633 {
6634         /* Build a room */
6635         switch (typ)
6636         {
6637         /* Build an appropriate room */
6638         case ROOM_T_NORMAL:        return build_type1();
6639         case ROOM_T_OVERLAP:       return build_type2();
6640         case ROOM_T_CROSS:         return build_type3();
6641         case ROOM_T_INNER_FEAT:    return build_type4();
6642         case ROOM_T_NEST:          return build_type5();
6643         case ROOM_T_PIT:           return build_type6();
6644         case ROOM_T_LESSER_VAULT:  return build_type7();
6645         case ROOM_T_GREATER_VAULT: return build_type8();
6646         case ROOM_T_FRACAVE:       return build_type9();
6647         case ROOM_T_RANDOM_VAULT:  return build_type10();
6648         case ROOM_T_OVAL:          return build_type11();
6649         case ROOM_T_CRYPT:         return build_type12();
6650         case ROOM_T_TRAP_PIT:      return build_type13();
6651         case ROOM_T_TRAP:          return build_type14();
6652         case ROOM_T_GLASS:         return build_type15();
6653         case ROOM_T_ARCADE:        return build_type16();
6654         }
6655
6656         /* Paranoia */
6657         return FALSE;
6658 }
6659
6660 /*!
6661  * @brief 指定した部屋の生成確率を別の部屋に加算し、指定した部屋の生成率を0にする
6662  * @param dst 確率を移す先の部屋種ID
6663  * @param src 確率を与える元の部屋種ID
6664  */
6665 #define MOVE_PLIST(dst, src) (prob_list[dst] += prob_list[src], prob_list[src] = 0)
6666
6667 /*!
6668  * @brief 部屋生成処理のメインルーチン(Sangbandを経由してOangbandからの実装を引用) / Generate rooms in dungeon.  Build bigger rooms at first.　[from SAngband (originally from OAngband)]
6669  * @return 部屋生成に成功した場合 TRUE を返す。
6670  */
6671 bool generate_rooms(void)
6672 {
6673         int i;
6674         bool remain;
6675         int crowded = 0;
6676         int total_prob;
6677         int prob_list[ROOM_T_MAX];
6678         int rooms_built = 0;
6679         int area_size = 100 * (cur_hgt*cur_wid) / (MAX_HGT*MAX_WID);
6680         int level_index = MIN(10, div_round(dun_level, 10));
6681
6682         /* Number of each type of room on this level */
6683         s16b room_num[ROOM_T_MAX];
6684
6685         /* Limit number of rooms */
6686         int dun_rooms = DUN_ROOMS_MAX * area_size / 100;
6687
6688         /* Assume normal cave */
6689         room_info_type *room_info_ptr = room_info_normal;
6690
6691         /*
6692          * Initialize probability list.
6693          */
6694         for (i = 0; i < ROOM_T_MAX; i++)
6695         {
6696                 /* No rooms allowed above their minimum depth. */
6697                 if (dun_level < room_info_ptr[i].min_level)
6698                 {
6699                         prob_list[i] = 0;
6700                 }
6701                 else
6702                 {
6703                         prob_list[i] = room_info_ptr[i].prob[level_index];
6704                 }
6705         }
6706
6707         /*
6708          * XXX -- Various dungeon types and options.
6709          */
6710
6711         /*! @details ダンジョンにBEGINNER、CHAMELEON、SMALLESTいずれのフラグもなく、かつ「常に通常でない部屋を生成する」フラグがONならば、GRATER_VAULTのみを生成対象とする。 / Ironman sees only Greater Vaults */
6712         if (ironman_rooms && !((d_info[dungeon_type].flags1 & (DF1_BEGINNER | DF1_CHAMELEON | DF1_SMALLEST))))
6713         {
6714                 for (i = 0; i < ROOM_T_MAX; i++)
6715                 {
6716                         if (i == ROOM_T_GREATER_VAULT) prob_list[i] = 1;
6717                         else prob_list[i] = 0;
6718                 }
6719         }
6720
6721         /*! @details ダンジョンにNO_VAULTフラグがあるならば、LESSER_VAULT / GREATER_VAULT/ RANDOM_VAULTを除外 / Forbidden vaults */
6722         else if (d_info[dungeon_type].flags1 & DF1_NO_VAULT)
6723         {
6724                 prob_list[ROOM_T_LESSER_VAULT] = 0;
6725                 prob_list[ROOM_T_GREATER_VAULT] = 0;
6726                 prob_list[ROOM_T_RANDOM_VAULT] = 0;
6727         }
6728
6729         /*! @details ダンジョンにNO_CAVEフラグがある場合、FRACAVEの生成枠がNORMALに与えられる。CRIPT、OVALの生成枠がINNER_Fに与えられる。/ NO_CAVE dungeon (Castle)*/
6730         if (d_info[dungeon_type].flags1 & DF1_NO_CAVE)
6731         {
6732                 MOVE_PLIST(ROOM_T_NORMAL, ROOM_T_FRACAVE);
6733                 MOVE_PLIST(ROOM_T_INNER_FEAT, ROOM_T_CRYPT);
6734                 MOVE_PLIST(ROOM_T_INNER_FEAT, ROOM_T_OVAL);
6735         }
6736
6737         /*! @details ダンジョンにCAVEフラグがある場合、NORMALの生成枠がFRACAVEに与えられる。/ CAVE dungeon (Orc cave etc.) */
6738         else if (d_info[dungeon_type].flags1 & DF1_CAVE)
6739         {
6740                 MOVE_PLIST(ROOM_T_FRACAVE, ROOM_T_NORMAL);
6741         }
6742
6743         /*! @details ダンジョンの基本地形が最初から渓谷かアリーナ型の場合 FRACAVE は生成から除外。 /  No caves when a (random) cavern exists: they look bad */
6744         else if (dun->cavern || dun->empty_level)
6745         {
6746                 prob_list[ROOM_T_FRACAVE] = 0;
6747         }
6748
6749         /*! @details ダンジョンに最初からGLASS_ROOMフラグがある場合、GLASS を生成から除外。/ Forbidden glass rooms */
6750         if (!(d_info[dungeon_type].flags1 & DF1_GLASS_ROOM))
6751         {
6752                 prob_list[ROOM_T_GLASS] = 0;
6753         }
6754
6755         /*! @details ARCADEは同フラグがダンジョンにないと生成されない。 / Forbidden glass rooms */
6756         if (!(d_info[dungeon_type].flags1 & DF1_ARCADE))
6757         {
6758                 prob_list[ROOM_T_ARCADE] = 0;
6759         }
6760
6761         /*
6762          * Initialize number of rooms,
6763          * And calcurate total probability.
6764          */
6765         for (total_prob = 0, i = 0; i < ROOM_T_MAX; i++)
6766         {
6767                 room_num[i] = 0;
6768                 total_prob += prob_list[i];
6769         }
6770
6771         /*
6772          * Prepare the number of rooms, of all types, we should build
6773          * on this level.
6774          */
6775         for (i = dun_rooms; i > 0; i--)
6776         {
6777                 int room_type;
6778                 int rand = randint0(total_prob);
6779
6780                 /* Get room_type randomly */
6781                 for (room_type = 0; room_type < ROOM_T_MAX; room_type++)
6782                 {
6783                         if (rand < prob_list[room_type]) break;
6784                         else rand -= prob_list[room_type];
6785                 }
6786
6787                 /* Paranoia */
6788                 if (room_type >= ROOM_T_MAX) room_type = ROOM_T_NORMAL;
6789
6790                 /* Increase the number of rooms of that type we should build. */
6791                 room_num[room_type]++;
6792
6793                 switch (room_type)
6794                 {
6795                 case ROOM_T_NEST:
6796                 case ROOM_T_PIT:
6797                 case ROOM_T_LESSER_VAULT:
6798                 case ROOM_T_TRAP_PIT:
6799                 case ROOM_T_GLASS:
6800                 case ROOM_T_ARCADE:
6801
6802                         /* Large room */
6803                         i -= 2;
6804                         break;
6805
6806                 case ROOM_T_GREATER_VAULT:
6807                 case ROOM_T_RANDOM_VAULT:
6808
6809                         /* Largest room */
6810                         i -= 3;
6811                         break;
6812                 }
6813         }
6814
6815         /*
6816          * Build each type of room one by one until we cannot build any more.
6817          * [from SAngband (originally from OAngband)]
6818          */
6819         while (TRUE)
6820         {
6821                 /* Assume no remaining rooms */
6822                 remain = FALSE;
6823
6824                 for (i = 0; i < ROOM_T_MAX; i++)
6825                 {
6826                         /* What type of room are we building now? */
6827                         int room_type = room_build_order[i];
6828
6829                         /* Go next if none available */
6830                         if (!room_num[room_type]) continue;
6831
6832                         /* Use up one unit */
6833                         room_num[room_type]--;
6834
6835                         /* Build the room. */
6836                         if (room_build(room_type))
6837                         {
6838                                 /* Increase the room built count. */
6839                                 rooms_built++;
6840
6841                                 /* Mark as there was some remaining rooms */
6842                                 remain = TRUE;
6843
6844                                 switch (room_type)
6845                                 {
6846                                 case ROOM_T_PIT:
6847                                 case ROOM_T_NEST:
6848                                 case ROOM_T_TRAP_PIT:
6849
6850                                         /* Avoid too many monsters */
6851                                         if (++crowded >= 2)
6852                                         {
6853                                                 room_num[ROOM_T_PIT] = 0;
6854                                                 room_num[ROOM_T_NEST] = 0;
6855                                                 room_num[ROOM_T_TRAP_PIT] = 0;
6856                                         }
6857                                         break;
6858
6859                                 case ROOM_T_ARCADE:
6860
6861                                         /* Avoid double-town */
6862                                         room_num[ROOM_T_ARCADE] = 0;
6863                                         break;
6864                                 }
6865                         }
6866                 }
6867
6868                 /* End loop if no room remain */
6869                 if (!remain) break;
6870         }
6871
6872         /*! @details 部屋生成数が2未満の場合生成失敗を返す */
6873         if (rooms_built < 2)
6874         {
6875                 msg_format_wizard(CHEAT_DUNGEON, _("部屋数が2未満でした。生成を再試行します。", "Number of rooms was under 2. Retry."), rooms_built);
6876                 return FALSE;
6877         }
6878
6879         msg_format_wizard(CHEAT_DUNGEON, _("このダンジョンの部屋数は %d です。", "Number of Rooms: %d"), rooms_built);
6880
6881         return TRUE;
6882 }