src/grid.c

   1 /*!
   2  * @file grid.c
   3  * @brief ダンジョンの生成処理の基幹部分 / low-level dungeon creation primitives
   4  * @date 2014/01/04
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
   7  *\n
   8  * This software may be copied and distributed for educational, research,\n
   9  * and not for profit purposes provided that this copyright and statement\n
  10  * are included in all such copies.  Other copyrights may also apply.\n
  11  * \n
  12  * 2014 Deskull Doxygen向けのコメント整理\n
  13  */
  14
  15 #include "angband.h"
  16 #include "generate.h"
  17 #include "grid.h"
  18 #include "trap.h"
  19
  20
  21 /*!
  22  * @brief 新規フロアに入りたてのプレイヤーをランダムな場所に配置する / Returns random co-ordinates for player/monster/object
  23  * @return 配置に成功したらTRUEを返す
  24  */
  25 bool new_player_spot(void)
  26 {
  27         POSITION y = 0, x = 0;
  28         int max_attempts = 10000;
  29
  30         cave_type *c_ptr;
  31         feature_type *f_ptr;
  32
  33         /* Place the player */
  34         while (max_attempts--)
  35         {
  36                 /* Pick a legal spot */
  37                 y = (POSITION)rand_range(1, cur_hgt - 2);
  38                 x = (POSITION)rand_range(1, cur_wid - 2);
  39
  40                 c_ptr = &cave[y][x];
  41
  42                 /* Must be a "naked" floor grid */
  43                 if (c_ptr->m_idx) continue;
  44                 if (dun_level)
  45                 {
  46                         f_ptr = &f_info[c_ptr->feat];
  47
  48                         if (max_attempts > 5000) /* Rule 1 */
  49                         {
  50                                 if (!have_flag(f_ptr->flags, FF_FLOOR)) continue;
  51                         }
  52                         else /* Rule 2 */
  53                         {
  54                                 if (!have_flag(f_ptr->flags, FF_MOVE)) continue;
  55                                 if (have_flag(f_ptr->flags, FF_HIT_TRAP)) continue;
  56                         }
  57
  58                         /* Refuse to start on anti-teleport grids in dungeon */
  59                         if (!have_flag(f_ptr->flags, FF_TELEPORTABLE)) continue;
  60                 }
  61                 if (!player_can_enter(c_ptr->feat, 0)) continue;
  62                 if (!in_bounds(y, x)) continue;
  63
  64                 /* Refuse to start on anti-teleport grids */
  65                 if (c_ptr->info & (CAVE_ICKY)) continue;
  66
  67                 break;
  68         }
  69
  70         if (max_attempts < 1) /* Should be -1, actually if we failed... */
  71                 return FALSE;
  72
  73         /* Save the new player grid */
  74         p_ptr->y = y;
  75         p_ptr->x = x;
  76
  77         return TRUE;
  78 }
  79
  80
  81
  82 /*!
  83  * @brief 所定の位置に上り階段か下り階段を配置する / Place an up/down staircase at given location
  84  * @param y 配置を試みたいマスのY座標
  85  * @param x 配置を試みたいマスのX座標
  86  * @return なし
  87  */
  88 void place_random_stairs(POSITION y, POSITION x)
  89 {
  90         bool up_stairs = TRUE;
  91         bool down_stairs = TRUE;
  92         cave_type *c_ptr;
  93
  94         /* Paranoia */
  95         c_ptr = &cave[y][x];
  96         if (!is_floor_grid(c_ptr) || c_ptr->o_idx) return;
  97
  98         /* Town */
  99         if (!dun_level)
 100                 up_stairs = FALSE;
 101
 102         /* Ironman */
 103         if (ironman_downward)
 104                 up_stairs = FALSE;
 105
 106         /* Bottom */
 107         if (dun_level >= d_info[dungeon_type].maxdepth)
 108                 down_stairs = FALSE;
 109
 110         /* Quest-level */
 111         if (quest_number(dun_level) && (dun_level > 1))
 112                 down_stairs = FALSE;
 113
 114         /* We can't place both */
 115         if (down_stairs && up_stairs)
 116         {
 117                 /* Choose a staircase randomly */
 118                 if (randint0(100) < 50)
 119                         up_stairs = FALSE;
 120                 else
 121                         down_stairs = FALSE;
 122         }
 123
 124         /* Place the stairs */
 125         if (up_stairs)
 126                 place_up_stairs(y, x);
 127         else if (down_stairs)
 128                 place_down_stairs(y, x);
 129 }
 130
 131 /*!
 132  * @brief 所定の位置にさまざまな状態や種類のドアを配置する / Place a random type of door at the given location
 133  * @param y ドアの配置を試みたいマスのY座標
 134  * @param x ドアの配置を試みたいマスのX座標
 135  * @param room 部屋に接している場合向けのドア生成か否か
 136  * @return なし
 137  */
 138 void place_random_door(POSITION y, POSITION x, bool room)
 139 {
 140         int tmp, type;
 141         FEAT_IDX feat = feat_none;
 142         cave_type *c_ptr = &cave[y][x];
 143
 144         /* Initialize mimic info */
 145         c_ptr->mimic = 0;
 146
 147         if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
 148         {
 149                 place_floor_bold(y, x);
 150                 return;
 151         }
 152
 153         type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) &&
 154                 one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN :
 155                 ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
 156
 157         /* Choose an object */
 158         tmp = randint0(1000);
 159
 160         /* Open doors (300/1000) */
 161         if (tmp < 300)
 162         {
 163                 /* Create open door */
 164                 feat = feat_door[type].open;
 165         }
 166
 167         /* Broken doors (100/1000) */
 168         else if (tmp < 400)
 169         {
 170                 /* Create broken door */
 171                 feat = feat_door[type].broken;
 172         }
 173
 174         /* Secret doors (200/1000) */
 175         else if (tmp < 600)
 176         {
 177                 /* Create secret door */
 178                 place_closed_door(y, x, type);
 179
 180                 if (type != DOOR_CURTAIN)
 181                 {
 182                         /* Hide. If on the edge of room, use outer wall. */
 183                         c_ptr->mimic = room ? feat_wall_outer : fill_type[randint0(100)];
 184
 185                         /* Floor type terrain cannot hide a door */
 186                         if (feat_supports_los(c_ptr->mimic) && !feat_supports_los(c_ptr->feat))
 187                         {
 188                                 if (have_flag(f_info[c_ptr->mimic].flags, FF_MOVE) || have_flag(f_info[c_ptr->mimic].flags, FF_CAN_FLY))
 189                                 {
 190                                         c_ptr->feat = one_in_(2) ? c_ptr->mimic : floor_type[randint0(100)];
 191                                 }
 192                                 c_ptr->mimic = 0;
 193                         }
 194                 }
 195         }
 196
 197         /* Closed, locked, or stuck doors (400/1000) */
 198         else place_closed_door(y, x, type);
 199
 200         if (tmp < 400)
 201         {
 202                 if (feat != feat_none)
 203                 {
 204                         set_cave_feat(y, x, feat);
 205                 }
 206                 else
 207                 {
 208                         place_floor_bold(y, x);
 209                 }
 210         }
 211
 212         delete_monster(y, x);
 213 }
 214
 215 /*!
 216  * @brief 所定の位置に各種の閉じたドアを配置する / Place a random type of normal door at the given location.
 217  * @param y ドアの配置を試みたいマスのY座標
 218  * @param x ドアの配置を試みたいマスのX座標
 219  * @param type ドアの地形ID
 220  * @return なし
 221  */
 222 void place_closed_door(POSITION y, POSITION x, int type)
 223 {
 224         int tmp;
 225         FEAT_IDX feat = feat_none;
 226
 227         if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
 228         {
 229                 place_floor_bold(y, x);
 230                 return;
 231         }
 232
 233         /* Choose an object */
 234         tmp = randint0(400);
 235
 236         /* Closed doors (300/400) */
 237         if (tmp < 300)
 238         {
 239                 /* Create closed door */
 240                 feat = feat_door[type].closed;
 241         }
 242
 243         /* Locked doors (99/400) */
 244         else if (tmp < 399)
 245         {
 246                 /* Create locked door */
 247                 feat = feat_locked_door_random(type);
 248         }
 249
 250         /* Stuck doors (1/400) */
 251         else
 252         {
 253                 /* Create jammed door */
 254                 feat = feat_jammed_door_random(type);
 255         }
 256
 257         if (feat != feat_none)
 258         {
 259                 cave_set_feat(y, x, feat);
 260
 261                 /* Now it is not floor */
 262                 cave[y][x].info &= ~(CAVE_MASK);
 263         }
 264         else
 265         {
 266                 place_floor_bold(y, x);
 267         }
 268 }
 269
 270 /*!
 271 * @brief 鍵のかかったドアを配置する
 272 * @param y 配置したいフロアのY座標
 273 * @param x 配置したいフロアのX座標
 274 * @return なし
 275 */
 276 void place_locked_door(POSITION y, POSITION x)
 277 {
 278         if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
 279         {
 280                 place_floor_bold(y, x);
 281         }
 282         else
 283         {
 284                 set_cave_feat(y, x, feat_locked_door_random((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR));
 285                 cave[y][x].info &= ~(CAVE_FLOOR);
 286                 delete_monster(y, x);
 287         }
 288 }
 289
 290
 291 /*!
 292 * @brief 隠しドアを配置する
 293 * @param y 配置したいフロアのY座標
 294 * @param x 配置したいフロアのX座標
 295 * @param type DOOR_DEFAULT / DOOR_DOOR / DOOR_GLASS_DOOR / DOOR_CURTAIN のいずれか
 296 * @return なし
 297 */
 298 void place_secret_door(POSITION y, POSITION x, int type)
 299 {
 300         if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
 301         {
 302                 place_floor_bold(y, x);
 303         }
 304         else
 305         {
 306                 cave_type *c_ptr = &cave[y][x];
 307
 308                 if (type == DOOR_DEFAULT)
 309                 {
 310                         type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) &&
 311                                 one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN :
 312                                 ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
 313                 }
 314
 315                 /* Create secret door */
 316                 place_closed_door(y, x, type);
 317
 318                 if (type != DOOR_CURTAIN)
 319                 {
 320                         /* Hide by inner wall because this is used in rooms only */
 321                         c_ptr->mimic = feat_wall_inner;
 322
 323                         /* Floor type terrain cannot hide a door */
 324                         if (feat_supports_los(c_ptr->mimic) && !feat_supports_los(c_ptr->feat))
 325                         {
 326                                 if (have_flag(f_info[c_ptr->mimic].flags, FF_MOVE) || have_flag(f_info[c_ptr->mimic].flags, FF_CAN_FLY))
 327                                 {
 328                                         c_ptr->feat = one_in_(2) ? c_ptr->mimic : floor_type[randint0(100)];
 329                                 }
 330                                 c_ptr->mimic = 0;
 331                         }
 332                 }
 333
 334                 c_ptr->info &= ~(CAVE_FLOOR);
 335                 delete_monster(y, x);
 336         }
 337 }
 338
 339 /*
 340  * Routine used by the random vault creators to add a door to a location
 341  * Note that range checking has to be done in the calling routine.
 342  *
 343  * The doors must be INSIDE the allocated region.
 344  */
 345 void add_door(POSITION x, POSITION y)
 346 {
 347         /* Need to have a wall in the center square */
 348         if (!is_outer_bold(y, x)) return;
 349
 350         /* look at:
 351         *  x#x
 352         *  .#.
 353         *  x#x
 354         *
 355         *  where x=don't care
 356         *  .=floor, #=wall
 357         */
 358
 359         if (is_floor_bold(y - 1, x) && is_floor_bold(y + 1, x) &&
 360                 (is_outer_bold(y, x - 1) && is_outer_bold(y, x + 1)))
 361         {
 362                 /* secret door */
 363                 place_secret_door(y, x, DOOR_DEFAULT);
 364
 365                 /* set boundarys so don't get wide doors */
 366                 place_solid_bold(y, x - 1);
 367                 place_solid_bold(y, x + 1);
 368         }
 369
 370
 371         /* look at:
 372         *  x#x
 373         *  .#.
 374         *  x#x
 375         *
 376         *  where x = don't care
 377         *  .=floor, #=wall
 378         */
 379         if (is_outer_bold(y - 1, x) && is_outer_bold(y + 1, x) &&
 380                 is_floor_bold(y, x - 1) && is_floor_bold(y, x + 1))
 381         {
 382                 /* secret door */
 383                 place_secret_door(y, x, DOOR_DEFAULT);
 384
 385                 /* set boundarys so don't get wide doors */
 386                 place_solid_bold(y - 1, x);
 387                 place_solid_bold(y + 1, x);
 388         }
 389 }
 390
 391 /*!
 392 * @brief 隣接4マスに存在する通路の数を返す / Count the number of "corridor" grids adjacent to the given grid.
 393 * @param y1 基準となるマスのY座標
 394 * @param x1 基準となるマスのX座標
 395 * @return 通路の数
 396 * @note Assumes "in_bounds(y1, x1)"
 397 * @details
 398 * XXX XXX This routine currently only counts actual "empty floor"\n
 399 * grids which are not in rooms.  We might want to also count stairs,\n
 400 * open doors, closed doors, etc.
 401 */
 402 static int next_to_corr(POSITION y1, POSITION x1)
 403 {
 404         int i, k = 0;
 405         POSITION y, x;
 406
 407         cave_type *c_ptr;
 408
 409         /* Scan adjacent grids */
 410         for (i = 0; i < 4; i++)
 411         {
 412                 /* Extract the location */
 413                 y = y1 + ddy_ddd[i];
 414                 x = x1 + ddx_ddd[i];
 415
 416                 /* Access the grid */
 417                 c_ptr = &cave[y][x];
 418
 419                 /* Skip non floors */
 420                 if (cave_have_flag_grid(c_ptr, FF_WALL)) continue;
 421
 422                 /* Skip non "empty floor" grids */
 423                 if (!is_floor_grid(c_ptr))
 424                         continue;
 425
 426                 /* Skip grids inside rooms */
 427                 if (c_ptr->info & (CAVE_ROOM)) continue;
 428
 429                 /* Count these grids */
 430                 k++;
 431         }
 432
 433         /* Return the number of corridors */
 434         return (k);
 435 }
 436
 437 /*!
 438 * @brief ドアを設置可能な地形かを返す / Determine if the given location is "between" two walls, and "next to" two corridor spaces.
 439 * @param y 判定を行いたいマスのY座標
 440 * @param x 判定を行いたいマスのX座標
 441 * @return ドアを設置可能ならばTRUEを返す
 442 * @note Assumes "in_bounds(y1, x1)"
 443 * @details
 444 * \n
 445 * Assumes "in_bounds(y, x)"\n
 446 */
 447 static bool possible_doorway(POSITION y, POSITION x)
 448 {
 449         /* Count the adjacent corridors */
 450         if (next_to_corr(y, x) >= 2)
 451         {
 452                 /* Check Vertical */
 453                 if (cave_have_flag_bold(y - 1, x, FF_WALL) &&
 454                         cave_have_flag_bold(y + 1, x, FF_WALL))
 455                 {
 456                         return (TRUE);
 457                 }
 458
 459                 /* Check Horizontal */
 460                 if (cave_have_flag_bold(y, x - 1, FF_WALL) &&
 461                         cave_have_flag_bold(y, x + 1, FF_WALL))
 462                 {
 463                         return (TRUE);
 464                 }
 465         }
 466
 467         /* No doorway */
 468         return (FALSE);
 469 }
 470
 471 /*!
 472 * @brief ドアの設置を試みる / Places door at y, x position if at least 2 walls found
 473 * @param y 設置を行いたいマスのY座標
 474 * @param x 設置を行いたいマスのX座標
 475 * @return なし
 476 */
 477 void try_door(POSITION y, POSITION x)
 478 {
 479         /* Paranoia */
 480         if (!in_bounds(y, x)) return;
 481
 482         /* Ignore walls */
 483         if (cave_have_flag_bold(y, x, FF_WALL)) return;
 484
 485         /* Ignore room grids */
 486         if (cave[y][x].info & (CAVE_ROOM)) return;
 487
 488         /* Occasional door (if allowed) */
 489         if ((randint0(100) < dun_tun_jct) && possible_doorway(y, x) && !(d_info[dungeon_type].flags1 & DF1_NO_DOORS))
 490         {
 491                 /* Place a door */
 492                 place_random_door(y, x, FALSE);
 493         }
 494 }
 495
 496
 497 /*!
 498  * @brief 長方形の空洞を生成する / Make an empty square floor, for the middle of rooms
 499  * @param x1 長方形の左端X座標(-1)
 500  * @param x2 長方形の右端X座標(+1)
 501  * @param y1 長方形の上端Y座標(-1)
 502  * @param y2 長方形の下端Y座標(+1)
 503  * @param light 照明の有無
 504  * @return なし
 505  */
 506 void place_floor(POSITION x1, POSITION x2, POSITION y1, POSITION y2, bool light)
 507 {
 508         POSITION x, y;
 509
 510         /* Place a full floor under the room */
 511         for (y = y1 - 1; y <= y2 + 1; y++)
 512         {
 513                 for (x = x1 - 1; x <= x2 + 1; x++)
 514                 {
 515                         place_floor_bold(y, x);
 516                         add_cave_info(y, x, CAVE_ROOM);
 517                         if (light) add_cave_info(y, x, CAVE_GLOW);
 518                 }
 519         }
 520 }
 521
 522
 523 /*!
 524  * @brief 長方形の部屋を生成する / Make an empty square room, only floor and wall grids
 525  * @param x1 長方形の左端X座標(-1)
 526  * @param x2 長方形の右端X座標(+1)
 527  * @param y1 長方形の上端Y座標(-1)
 528  * @param y2 長方形の下端Y座標(+1)
 529  * @param light 照明の有無
 530  * @return なし
 531  */
 532 void place_room(POSITION x1, POSITION x2, POSITION y1, POSITION y2, bool light)
 533 {
 534         POSITION y, x;
 535
 536         place_floor(x1, x2, y1, y2, light);
 537
 538         /* Walls around the room */
 539         for (y = y1 - 1; y <= y2 + 1; y++)
 540         {
 541                 place_outer_bold(y, x1 - 1);
 542                 place_outer_bold(y, x2 + 1);
 543         }
 544         for (x = x1 - 1; x <= x2 + 1; x++)
 545         {
 546                 place_outer_bold(y1 - 1, x);
 547                 place_outer_bold(y2 + 1, x);
 548         }
 549 }
 550
 551
 552 /*!
 553  * @brief 特殊な部屋向けに各種アイテムを配置する / Create up to "num" objects near the given coordinates
 554  * @param y 配置したい中心マスのY座標
 555  * @param x 配置したい中心マスのX座標
 556  * @param num 配置したい数
 557  * @return なし
 558  * @details
 559  * Only really called by some of the "vault" routines.
 560  */
 561 void vault_objects(POSITION y, POSITION x, int num)
 562 {
 563         int dummy = 0;
 564         int i = 0, j = y, k = x;
 565
 566         cave_type *c_ptr;
 567
 568
 569         /* Attempt to place 'num' objects */
 570         for (; num > 0; --num)
 571         {
 572                 /* Try up to 11 spots looking for empty space */
 573                 for (i = 0; i < 11; ++i)
 574                 {
 575                         /* Pick a random location */
 576                         while (dummy < SAFE_MAX_ATTEMPTS)
 577                         {
 578                                 j = rand_spread(y, 2);
 579                                 k = rand_spread(x, 3);
 580                                 dummy++;
 581                                 if (!in_bounds(j, k)) continue;
 582                                 break;
 583                         }
 584
 585
 586                         if (dummy >= SAFE_MAX_ATTEMPTS && cheat_room)
 587                         {
 588                                 msg_print(_("警告！地下室のアイテムを配置できません！", "Warning! Could not place vault object!"));
 589                         }
 590
 591
 592                         /* Require "clean" floor space */
 593                         c_ptr = &cave[j][k];
 594                         if (!is_floor_grid(c_ptr) || c_ptr->o_idx) continue;
 595
 596                         /* Place an item */
 597                         if (randint0(100) < 75)
 598                         {
 599                                 place_object(j, k, 0L);
 600                         }
 601
 602                         /* Place gold */
 603                         else
 604                         {
 605                                 place_gold(j, k);
 606                         }
 607
 608                         /* Placement accomplished */
 609                         break;
 610                 }
 611         }
 612 }
 613
 614 /*!
 615  * @brief 特殊な部屋向けに各種アイテムを配置する(vault_trapのサブセット) / Place a trap with a given displacement of point
 616  * @param y トラップを配置したいマスの中心Y座標
 617  * @param x トラップを配置したいマスの中心X座標
 618  * @param yd Y方向の配置分散マス数
 619  * @param xd X方向の配置分散マス数
 620  * @return なし
 621  * @details
 622  * Only really called by some of the "vault" routines.
 623  */
 624 void vault_trap_aux(POSITION y, POSITION x, POSITION yd, POSITION xd)
 625 {
 626         int count = 0, y1 = y, x1 = x;
 627         int dummy = 0;
 628
 629         cave_type *c_ptr;
 630
 631         /* Place traps */
 632         for (count = 0; count <= 5; count++)
 633         {
 634                 /* Get a location */
 635                 while (dummy < SAFE_MAX_ATTEMPTS)
 636                 {
 637                         y1 = rand_spread(y, yd);
 638                         x1 = rand_spread(x, xd);
 639                         dummy++;
 640                         if (!in_bounds(y1, x1)) continue;
 641                         break;
 642                 }
 643
 644                 if (dummy >= SAFE_MAX_ATTEMPTS && cheat_room)
 645                 {
 646                         msg_print(_("警告！地下室のトラップを配置できません！", "Warning! Could not place vault trap!"));
 647                 }
 648
 649                 /* Require "naked" floor grids */
 650                 c_ptr = &cave[y1][x1];
 651                 if (!is_floor_grid(c_ptr) || c_ptr->o_idx || c_ptr->m_idx) continue;
 652
 653                 /* Place the trap */
 654                 place_trap(y1, x1);
 655
 656                 break;
 657         }
 658 }
 659
 660 /*!
 661  * @brief 特殊な部屋向けに各種アイテムを配置する(メインルーチン) / Place some traps with a given displacement of given location
 662  * @param y トラップを配置したいマスの中心Y座標
 663  * @param x トラップを配置したいマスの中心X座標
 664  * @param yd Y方向の配置分散マス数
 665  * @param xd X方向の配置分散マス数
 666  * @param num 配置したいトラップの数
 667  * @return なし
 668  * @details
 669  * Only really called by some of the "vault" routines.
 670  */
 671 void vault_traps(POSITION y, POSITION x, POSITION yd, POSITION xd, int num)
 672 {
 673         int i;
 674
 675         for (i = 0; i < num; i++)
 676         {
 677                 vault_trap_aux(y, x, yd, xd);
 678         }
 679 }
 680
 681 /*!
 682  * @brief 特殊な部屋地形向けにモンスターを配置する / Hack -- Place some sleeping monsters near the given location
 683  * @param y1 モンスターを配置したいマスの中心Y座標
 684  * @param x1 モンスターを配置したいマスの中心X座標
 685  * @param num 配置したいモンスターの数
 686  * @return なし
 687  * @details
 688  * Only really called by some of the "vault" routines.
 689  */
 690 void vault_monsters(POSITION y1, POSITION x1, int num)
 691 {
 692         int k, i;
 693         POSITION y, x;
 694         cave_type *c_ptr;
 695
 696         /* Try to summon "num" monsters "near" the given location */
 697         for (k = 0; k < num; k++)
 698         {
 699                 /* Try nine locations */
 700                 for (i = 0; i < 9; i++)
 701                 {
 702                         int d = 1;
 703
 704                         /* Pick a nearby location */
 705                         scatter(&y, &x, y1, x1, d, 0);
 706
 707                         /* Require "empty" floor grids */
 708                         c_ptr = &cave[y][x];
 709                         if (!cave_empty_grid(c_ptr)) continue;
 710
 711                         /* Place the monster (allow groups) */
 712                         monster_level = base_level + 2;
 713                         (void)place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
 714                         monster_level = base_level;
 715                 }
 716         }
 717 }
 718
 719
 720 /*!
 721  * @brief build_tunnel用に通路を掘るための方向を位置関係通りに決める / Always picks a correct direction
 722  * @param rdir Y方向に取るべきベクトル値を返す参照ポインタ
 723  * @param cdir X方向に取るべきベクトル値を返す参照ポインタ
 724  * @param y1 始点Y座標
 725  * @param x1 始点X座標
 726  * @param y2 終点Y座標
 727  * @param x2 終点X座標
 728  * @return なし
 729  */
 730 void correct_dir(int *rdir, int *cdir, POSITION y1, POSITION x1, POSITION y2, POSITION x2)
 731 {
 732         /* Extract vertical and horizontal directions */
 733         *rdir = (y1 == y2) ? 0 : (y1 < y2) ? 1 : -1;
 734         *cdir = (x1 == x2) ? 0 : (x1 < x2) ? 1 : -1;
 735
 736         /* Never move diagonally */
 737         if (*rdir && *cdir)
 738         {
 739                 if (randint0(100) < 50)
 740                         *rdir = 0;
 741                 else
 742                         *cdir = 0;
 743         }
 744 }
 745
 746 /*!
 747  * @brief build_tunnel用に通路を掘るための方向をランダムに決める / Pick a random direction
 748  * @param rdir Y方向に取るべきベクトル値を返す参照ポインタ
 749  * @param cdir X方向に取るべきベクトル値を返す参照ポインタ
 750  * @return なし
 751  */
 752 void rand_dir(int *rdir, int *cdir)
 753 {
 754         /* Pick a random direction */
 755         int i = randint0(4);
 756
 757         /* Extract the dy/dx components */
 758         *rdir = ddy_ddd[i];
 759         *cdir = ddx_ddd[i];
 760 }
 761
 762 /*!
 763  * @brief 指定のマスが床系地形であるかを返す / Function that sees if a square is a floor.  (Includes range checking.)
 764  * @param x チェックするマスのX座標
 765  * @param y チェックするマスのY座標
 766  * @return 床系地形ならばTRUE
 767  */
 768 bool get_is_floor(POSITION x, POSITION y)
 769 {
 770         if (!in_bounds(y, x))
 771         {
 772                 /* Out of bounds */
 773                 return (FALSE);
 774         }
 775
 776         /* Do the real check */
 777         if (is_floor_bold(y, x)) return (TRUE);
 778
 779         return (FALSE);
 780 }
 781
 782 /*!
 783  * @brief 指定のマスを床地形に変える / Set a square to be floor.  (Includes range checking.)
 784  * @param x 地形を変えたいマスのX座標
 785  * @param y 地形を変えたいマスのY座標
 786  * @return なし
 787  */
 788 void set_floor(POSITION x, POSITION y)
 789 {
 790         if (!in_bounds(y, x))
 791         {
 792                 /* Out of bounds */
 793                 return;
 794         }
 795
 796         if (cave[y][x].info & CAVE_ROOM)
 797         {
 798                 /* A room border don't touch. */
 799                 return;
 800         }
 801
 802         /* Set to be floor if is a wall (don't touch lakes). */
 803         if (is_extra_bold(y, x))
 804                 place_floor_bold(y, x);
 805 }
 806
 807