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