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
  19
  20 /*!
  21  * @brief ¿·µ¬¥Õ¥í¥¢¤ËÆþ¤ê¤¿¤Æ¤Î¥×¥ì¥¤¥ä¡¼¤ò¥é¥ó¥À¥à¤Ê¾ì½ê¤ËÇÛÃÖ¤¹¤ë / Returns random co-ordinates for player/monster/object
  22  * @return ÇÛÃÖ¤ËÀ®¸ù¤·¤¿¤éTRUE¤òÊÖ¤¹
  23  */
  24 bool new_player_spot(void)
  25 {
  26         int     y, x;
  27         int max_attempts = 10000;
  28
  29         cave_type *c_ptr;
  30         feature_type *f_ptr;
  31
  32         /* Place the player */
  33         while (max_attempts--)
  34         {
  35                 /* Pick a legal spot */
  36                 y = rand_range(1, cur_hgt - 2);
  37                 x = rand_range(1, cur_wid - 2);
  38
  39                 c_ptr = &cave[y][x];
  40
  41                 /* Must be a "naked" floor grid */
  42                 if (c_ptr->m_idx) continue;
  43                 if (dun_level)
  44                 {
  45                         f_ptr = &f_info[c_ptr->feat];
  46
  47                         if (max_attempts > 5000) /* Rule 1 */
  48                         {
  49                                 if (!have_flag(f_ptr->flags, FF_FLOOR)) continue;
  50                         }
  51                         else /* Rule 2 */
  52                         {
  53                                 if (!have_flag(f_ptr->flags, FF_MOVE)) continue;
  54                                 if (have_flag(f_ptr->flags, FF_HIT_TRAP)) continue;
  55                         }
  56
  57                         /* Refuse to start on anti-teleport grids in dungeon */
  58                         if (!have_flag(f_ptr->flags, FF_TELEPORTABLE)) continue;
  59                 }
  60                 if (!player_can_enter(c_ptr->feat, 0)) continue;
  61                 if (!in_bounds(y, x)) continue;
  62
  63                 /* Refuse to start on anti-teleport grids */
  64                 if (c_ptr->info & (CAVE_ICKY)) continue;
  65
  66                 /* Done */
  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         py = y;
  75         px = 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(int y, int 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(int y, int x, bool room)
 139 {
 140         int tmp, type;
 141         s16b 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(int y, int x, int type)
 223 {
 224         int tmp;
 225         s16b 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 Ä¹Êý·Á¤Î¶õÆ¶¤òÀ¸À®¤¹¤ë / Make an empty square floor, for the middle of rooms
 272  * @param x1 Ä¹Êý·Á¤Îº¸Ã¼XºÂÉ¸(-1)
 273  * @param x2 Ä¹Êý·Á¤Î±¦Ã¼XºÂÉ¸(+1)
 274  * @param y1 Ä¹Êý·Á¤Î¾åÃ¼YºÂÉ¸(-1)
 275  * @param y2 Ä¹Êý·Á¤Î²¼Ã¼YºÂÉ¸(+1)
 276  * @param light ¾ÈÌÀ¤ÎÍÌµ
 277  * @return ¤Ê¤·
 278  */
 279 void place_floor(int x1, int x2, int y1, int y2, bool light)
 280 {
 281         int x, y;
 282
 283         /* Place a full floor under the room */
 284         for (y = y1 - 1; y <= y2 + 1; y++)
 285         {
 286                 for (x = x1 - 1; x <= x2 + 1; x++)
 287                 {
 288                         place_floor_bold(y, x);
 289                         add_cave_info(y, x, CAVE_ROOM);
 290                         if (light) add_cave_info(y, x, CAVE_GLOW);
 291                 }
 292         }
 293 }
 294
 295
 296 /*!
 297  * @brief Ä¹Êý·Á¤ÎÉô²°¤òÀ¸À®¤¹¤ë / Make an empty square room, only floor and wall grids
 298  * @param x1 Ä¹Êý·Á¤Îº¸Ã¼XºÂÉ¸(-1)
 299  * @param x2 Ä¹Êý·Á¤Î±¦Ã¼XºÂÉ¸(+1)
 300  * @param y1 Ä¹Êý·Á¤Î¾åÃ¼YºÂÉ¸(-1)
 301  * @param y2 Ä¹Êý·Á¤Î²¼Ã¼YºÂÉ¸(+1)
 302  * @param light ¾ÈÌÀ¤ÎÍÌµ
 303  * @return ¤Ê¤·
 304  */
 305 void place_room(int x1, int x2, int y1, int y2, bool light)
 306 {
 307         int y, x;
 308
 309         place_floor(x1, x2, y1, y2, light);
 310
 311         /* Walls around the room */
 312         for (y = y1 - 1; y <= y2 + 1; y++)
 313         {
 314                 place_outer_bold(y, x1 - 1);
 315                 place_outer_bold(y, x2 + 1);
 316         }
 317         for (x = x1 - 1; x <= x2 + 1; x++)
 318         {
 319                 place_outer_bold(y1 - 1, x);
 320                 place_outer_bold(y2 + 1, x);
 321         }
 322 }
 323
 324
 325 /*!
 326  * @brief ÆÃ¼ì¤ÊÉô²°¸þ¤±¤Ë³Æ¼ï¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤¹¤ë / Create up to "num" objects near the given coordinates
 327  * @param y ÇÛÃÖ¤·¤¿¤¤Ãæ¿´¥Þ¥¹¤ÎYºÂÉ¸
 328  * @param x ÇÛÃÖ¤·¤¿¤¤Ãæ¿´¥Þ¥¹¤ÎXºÂÉ¸
 329  * @param num ÇÛÃÖ¤·¤¿¤¤¿ô
 330  * @return ¤Ê¤·
 331  * @details
 332  * Only really called by some of the "vault" routines.
 333  */
 334 void vault_objects(int y, int x, int num)
 335 {
 336         int dummy = 0;
 337         int i = 0, j = y, k = x;
 338
 339         cave_type *c_ptr;
 340
 341
 342         /* Attempt to place 'num' objects */
 343         for (; num > 0; --num)
 344         {
 345                 /* Try up to 11 spots looking for empty space */
 346                 for (i = 0; i < 11; ++i)
 347                 {
 348                         /* Pick a random location */
 349                         while (dummy < SAFE_MAX_ATTEMPTS)
 350                         {
 351                                 j = rand_spread(y, 2);
 352                                 k = rand_spread(x, 3);
 353                                 dummy++;
 354                                 if (!in_bounds(j, k)) continue;
 355                                 break;
 356                         }
 357
 358
 359                         if (dummy >= SAFE_MAX_ATTEMPTS)
 360                         {
 361                                 if (cheat_room)
 362                                 {
 363 #ifdef JP
 364 msg_print("·Ù¹ð¡ªÃÏ²¼¼¼¤Î¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤Ç¤¤Þ¤»¤ó¡ª");
 365 #else
 366                                         msg_print("Warning! Could not place vault object!");
 367 #endif
 368
 369                                 }
 370                         }
 371
 372
 373                         /* Require "clean" floor space */
 374                         c_ptr = &cave[j][k];
 375                         if (!is_floor_grid(c_ptr) || c_ptr->o_idx) continue;
 376
 377                         /* Place an item */
 378                         if (randint0(100) < 75)
 379                         {
 380                                 place_object(j, k, 0L);
 381                         }
 382
 383                         /* Place gold */
 384                         else
 385                         {
 386                                 place_gold(j, k);
 387                         }
 388
 389                         /* Placement accomplished */
 390                         break;
 391                 }
 392         }
 393 }
 394
 395 /*!
 396  * @brief ÆÃ¼ì¤ÊÉô²°¸þ¤±¤Ë³Æ¼ï¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤¹¤ë(vault_trap¤Î¥µ¥Ö¥»¥Ã¥È) / Place a trap with a given displacement of point
 397  * @param y ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´YºÂÉ¸
 398  * @param x ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´XºÂÉ¸
 399  * @param yd YÊý¸þ¤ÎÇÛÃÖÊ¬»¶¥Þ¥¹¿ô
 400  * @param xd XÊý¸þ¤ÎÇÛÃÖÊ¬»¶¥Þ¥¹¿ô
 401  * @return ¤Ê¤·
 402  * @details
 403  * Only really called by some of the "vault" routines.
 404  */
 405 void vault_trap_aux(int y, int x, int yd, int xd)
 406 {
 407         int count = 0, y1 = y, x1 = x;
 408         int dummy = 0;
 409
 410         cave_type *c_ptr;
 411
 412         /* Place traps */
 413         for (count = 0; count <= 5; count++)
 414         {
 415                 /* Get a location */
 416                 while (dummy < SAFE_MAX_ATTEMPTS)
 417                 {
 418                         y1 = rand_spread(y, yd);
 419                         x1 = rand_spread(x, xd);
 420                         dummy++;
 421                         if (!in_bounds(y1, x1)) continue;
 422                         break;
 423                 }
 424
 425                 if (dummy >= SAFE_MAX_ATTEMPTS)
 426                 {
 427                         if (cheat_room)
 428                         {
 429 #ifdef JP
 430 msg_print("·Ù¹ð¡ªÃÏ²¼¼¼¤Î¥È¥é¥Ã¥×¤òÇÛÃÖ¤Ç¤¤Þ¤»¤ó¡ª");
 431 #else
 432                                 msg_print("Warning! Could not place vault trap!");
 433 #endif
 434
 435                         }
 436                 }
 437
 438                 /* Require "naked" floor grids */
 439                 c_ptr = &cave[y1][x1];
 440                 if (!is_floor_grid(c_ptr) || c_ptr->o_idx || c_ptr->m_idx) continue;
 441
 442                 /* Place the trap */
 443                 place_trap(y1, x1);
 444
 445                 /* Done */
 446                 break;
 447         }
 448 }
 449
 450 /*!
 451  * @brief ÆÃ¼ì¤ÊÉô²°¸þ¤±¤Ë³Æ¼ï¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤¹¤ë(¥á¥¤¥ó¥ë¡¼¥Á¥ó) / Place some traps with a given displacement of given location
 452  * @param y ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´YºÂÉ¸
 453  * @param x ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´XºÂÉ¸
 454  * @param yd YÊý¸þ¤ÎÇÛÃÖÊ¬»¶¥Þ¥¹¿ô
 455  * @param xd XÊý¸þ¤ÎÇÛÃÖÊ¬»¶¥Þ¥¹¿ô
 456  * @param num ÇÛÃÖ¤·¤¿¤¤¥È¥é¥Ã¥×¤Î¿ô
 457  * @return ¤Ê¤·
 458  * @details
 459  * Only really called by some of the "vault" routines.
 460  */
 461 void vault_traps(int y, int x, int yd, int xd, int num)
 462 {
 463         int i;
 464
 465         for (i = 0; i < num; i++)
 466         {
 467                 vault_trap_aux(y, x, yd, xd);
 468         }
 469 }
 470
 471 /*!
 472  * @brief ÆÃ¼ì¤ÊÉô²°ÃÏ·Á¸þ¤±¤Ë¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤¹¤ë / Hack -- Place some sleeping monsters near the given location
 473  * @param y1 ¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´YºÂÉ¸
 474  * @param x1 ¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´XºÂÉ¸
 475  * @param num ÇÛÃÖ¤·¤¿¤¤¥â¥ó¥¹¥¿¡¼¤Î¿ô
 476  * @return ¤Ê¤·
 477  * @details
 478  * Only really called by some of the "vault" routines.
 479  */
 480 void vault_monsters(int y1, int x1, int num)
 481 {
 482         int k, i, y, x;
 483         cave_type *c_ptr;
 484
 485         /* Try to summon "num" monsters "near" the given location */
 486         for (k = 0; k < num; k++)
 487         {
 488                 /* Try nine locations */
 489                 for (i = 0; i < 9; i++)
 490                 {
 491                         int d = 1;
 492
 493                         /* Pick a nearby location */
 494                         scatter(&y, &x, y1, x1, d, 0);
 495
 496                         /* Require "empty" floor grids */
 497                         c_ptr = &cave[y][x];
 498                         if (!cave_empty_grid(c_ptr)) continue;
 499
 500                         /* Place the monster (allow groups) */
 501                         monster_level = base_level + 2;
 502                         (void)place_monster(y, x, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
 503                         monster_level = base_level;
 504                 }
 505         }
 506 }
 507
 508
 509 /*!
 510  * @brief build_tunnelÍÑ¤ËÄÌÏ©¤ò·¡¤ë¤¿¤á¤ÎÊý¸þ¤ò°ÌÃÖ´Ø·¸ÄÌ¤ê¤Ë·è¤á¤ë / Always picks a correct direction
 511  * @param rdir YÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃÍ¤òÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
 512  * @param cdir XÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃÍ¤òÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
 513  * @param y1 »ÏÅÀYºÂÉ¸
 514  * @param x1 »ÏÅÀXºÂÉ¸
 515  * @param y2 ½ªÅÀYºÂÉ¸
 516  * @param x2 ½ªÅÀXºÂÉ¸
 517  * @return ¤Ê¤·
 518  */
 519 void correct_dir(int *rdir, int *cdir, int y1, int x1, int y2, int x2)
 520 {
 521         /* Extract vertical and horizontal directions */
 522         *rdir = (y1 == y2) ? 0 : (y1 < y2) ? 1 : -1;
 523         *cdir = (x1 == x2) ? 0 : (x1 < x2) ? 1 : -1;
 524
 525         /* Never move diagonally */
 526         if (*rdir && *cdir)
 527         {
 528                 if (randint0(100) < 50)
 529                         *rdir = 0;
 530                 else
 531                         *cdir = 0;
 532         }
 533 }
 534
 535 /*!
 536  * @brief build_tunnelÍÑ¤ËÄÌÏ©¤ò·¡¤ë¤¿¤á¤ÎÊý¸þ¤ò¥é¥ó¥À¥à¤Ë·è¤á¤ë / Pick a random direction
 537  * @param rdir YÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃÍ¤òÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
 538  * @param cdir XÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃÍ¤òÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
 539  * @return ¤Ê¤·
 540  */
 541 void rand_dir(int *rdir, int *cdir)
 542 {
 543         /* Pick a random direction */
 544         int i = randint0(4);
 545
 546         /* Extract the dy/dx components */
 547         *rdir = ddy_ddd[i];
 548         *cdir = ddx_ddd[i];
 549 }
 550
 551
 552 /* Function that sees if a square is a floor.  (Includes range checking.) */
 553 bool get_is_floor(int x, int y)
 554 {
 555         if (!in_bounds(y, x))
 556         {
 557                 /* Out of bounds */
 558                 return (FALSE);
 559         }
 560
 561         /* Do the real check */
 562         if (is_floor_bold(y, x)) return (TRUE);
 563
 564         return (FALSE);
 565 }
 566
 567
 568 /* Set a square to be floor.  (Includes range checking.) */
 569 void set_floor(int x, int y)
 570 {
 571         if (!in_bounds(y, x))
 572         {
 573                 /* Out of bounds */
 574                 return;
 575         }
 576
 577         if (cave[y][x].info & CAVE_ROOM)
 578         {
 579                 /* A room border don't touch. */
 580                 return;
 581         }
 582
 583         /* Set to be floor if is a wall (don't touch lakes). */
 584         if (is_extra_bold(y, x))
 585                 place_floor_bold(y, x);
 586 }
 587
 588
 589
 590 /*
 591  * Constructs a tunnel between two points
 592  *
 593  * This function must be called BEFORE any streamers are created,
 594  * since we use the special "granite wall" sub-types to keep track
 595  * of legal places for corridors to pierce rooms.
 596  *
 597  * We use "door_flag" to prevent excessive construction of doors
 598  * along overlapping corridors.
 599  *
 600  * We queue the tunnel grids to prevent door creation along a corridor
 601  * which intersects itself.
 602  *
 603  * We queue the wall piercing grids to prevent a corridor from leaving
 604  * a room and then coming back in through the same entrance.
 605  *
 606  * We "pierce" grids which are "outer" walls of rooms, and when we
 607  * do so, we change all adjacent "outer" walls of rooms into "solid"
 608  * walls so that no two corridors may use adjacent grids for exits.
 609  *
 610  * The "solid" wall check prevents corridors from "chopping" the
 611  * corners of rooms off, as well as "silly" door placement, and
 612  * "excessively wide" room entrances.
 613  *
 614  * Kind of walls:
 615  *   extra -- walls
 616  *   inner -- inner room walls
 617  *   outer -- outer room walls
 618  *   solid -- solid room walls
 619  */
 620 bool build_tunnel(int row1, int col1, int row2, int col2)
 621 {
 622         int y, x;
 623         int tmp_row, tmp_col;
 624         int row_dir, col_dir;
 625         int start_row, start_col;
 626         int main_loop_count = 0;
 627
 628         bool door_flag = FALSE;
 629
 630         cave_type *c_ptr;
 631
 632         /* Save the starting location */
 633         start_row = row1;
 634         start_col = col1;
 635
 636         /* Start out in the correct direction */
 637         correct_dir(&row_dir, &col_dir, row1, col1, row2, col2);
 638
 639         /* Keep going until done (or bored) */
 640         while ((row1 != row2) || (col1 != col2))
 641         {
 642                 /* Mega-Hack -- Paranoia -- prevent infinite loops */
 643                 if (main_loop_count++ > 2000) return FALSE;
 644
 645                 /* Allow bends in the tunnel */
 646                 if (randint0(100) < dun_tun_chg)
 647                 {
 648                         /* Acquire the correct direction */
 649                         correct_dir(&row_dir, &col_dir, row1, col1, row2, col2);
 650
 651                         /* Random direction */
 652                         if (randint0(100) < dun_tun_rnd)
 653                         {
 654                                 rand_dir(&row_dir, &col_dir);
 655                         }
 656                 }
 657
 658                 /* Get the next location */
 659                 tmp_row = row1 + row_dir;
 660                 tmp_col = col1 + col_dir;
 661
 662
 663                 /* Extremely Important -- do not leave the dungeon */
 664                 while (!in_bounds(tmp_row, tmp_col))
 665                 {
 666                         /* Acquire the correct direction */
 667                         correct_dir(&row_dir, &col_dir, row1, col1, row2, col2);
 668
 669                         /* Random direction */
 670                         if (randint0(100) < dun_tun_rnd)
 671                         {
 672                                 rand_dir(&row_dir, &col_dir);
 673                         }
 674
 675                         /* Get the next location */
 676                         tmp_row = row1 + row_dir;
 677                         tmp_col = col1 + col_dir;
 678                 }
 679
 680
 681                 /* Access the location */
 682                 c_ptr = &cave[tmp_row][tmp_col];
 683
 684                 /* Avoid "solid" walls */
 685                 if (is_solid_grid(c_ptr)) continue;
 686
 687                 /* Pierce "outer" walls of rooms */
 688                 if (is_outer_grid(c_ptr))
 689                 {
 690                         /* Acquire the "next" location */
 691                         y = tmp_row + row_dir;
 692                         x = tmp_col + col_dir;
 693
 694                         /* Hack -- Avoid outer/solid walls */
 695                         if (is_outer_bold(y, x)) continue;
 696                         if (is_solid_bold(y, x)) continue;
 697
 698                         /* Accept this location */
 699                         row1 = tmp_row;
 700                         col1 = tmp_col;
 701
 702                         /* Save the wall location */
 703                         if (dun->wall_n < WALL_MAX)
 704                         {
 705                                 dun->wall[dun->wall_n].y = row1;
 706                                 dun->wall[dun->wall_n].x = col1;
 707                                 dun->wall_n++;
 708                         }
 709                         else return FALSE;
 710
 711                         /* Forbid re-entry near this piercing */
 712                         for (y = row1 - 1; y <= row1 + 1; y++)
 713                         {
 714                                 for (x = col1 - 1; x <= col1 + 1; x++)
 715                                 {
 716                                         /* Convert adjacent "outer" walls as "solid" walls */
 717                                         if (is_outer_bold(y, x))
 718                                         {
 719                                                 /* Change the wall to a "solid" wall */
 720                                                 place_solid_noperm_bold(y, x);
 721                                         }
 722                                 }
 723                         }
 724                 }
 725
 726                 /* Travel quickly through rooms */
 727                 else if (c_ptr->info & (CAVE_ROOM))
 728                 {
 729                         /* Accept the location */
 730                         row1 = tmp_row;
 731                         col1 = tmp_col;
 732                 }
 733
 734                 /* Tunnel through all other walls */
 735                 else if (is_extra_grid(c_ptr) || is_inner_grid(c_ptr) || is_solid_grid(c_ptr))
 736                 {
 737                         /* Accept this location */
 738                         row1 = tmp_row;
 739                         col1 = tmp_col;
 740
 741                         /* Save the tunnel location */
 742                         if (dun->tunn_n < TUNN_MAX)
 743                         {
 744                                 dun->tunn[dun->tunn_n].y = row1;
 745                                 dun->tunn[dun->tunn_n].x = col1;
 746                                 dun->tunn_n++;
 747                         }
 748                         else return FALSE;
 749
 750                         /* Allow door in next grid */
 751                         door_flag = FALSE;
 752                 }
 753
 754                 /* Handle corridor intersections or overlaps */
 755                 else
 756                 {
 757                         /* Accept the location */
 758                         row1 = tmp_row;
 759                         col1 = tmp_col;
 760
 761                         /* Collect legal door locations */
 762                         if (!door_flag)
 763                         {
 764                                 /* Save the door location */
 765                                 if (dun->door_n < DOOR_MAX)
 766                                 {
 767                                         dun->door[dun->door_n].y = row1;
 768                                         dun->door[dun->door_n].x = col1;
 769                                         dun->door_n++;
 770                                 }
 771                                 else return FALSE;
 772
 773                                 /* No door in next grid */
 774                                 door_flag = TRUE;
 775                         }
 776
 777                         /* Hack -- allow pre-emptive tunnel termination */
 778                         if (randint0(100) >= dun_tun_con)
 779                         {
 780                                 /* Distance between row1 and start_row */
 781                                 tmp_row = row1 - start_row;
 782                                 if (tmp_row < 0) tmp_row = (-tmp_row);
 783
 784                                 /* Distance between col1 and start_col */
 785                                 tmp_col = col1 - start_col;
 786                                 if (tmp_col < 0) tmp_col = (-tmp_col);
 787
 788                                 /* Terminate the tunnel */
 789                                 if ((tmp_row > 10) || (tmp_col > 10)) break;
 790                         }
 791                 }
 792         }
 793
 794         return TRUE;
 795 }
 796
 797
 798 /*
 799  * This routine adds the square to the tunnel
 800  * It also checks for SOLID walls - and returns a nearby
 801  * non-SOLID square in (x,y) so that a simple avoiding
 802  * routine can be used. The returned boolean value reflects
 803  * whether or not this routine hit a SOLID wall.
 804  *
 805  * "affectwall" toggles whether or not this new square affects
 806  * the boundaries of rooms. - This is used by the catacomb
 807  * routine.
 808  */
 809 static bool set_tunnel(int *x, int *y, bool affectwall)
 810 {
 811         int i, j, dx, dy;
 812
 813         cave_type *c_ptr = &cave[*y][*x];
 814
 815         if (!in_bounds(*y, *x)) return TRUE;
 816
 817         if (is_inner_grid(c_ptr))
 818         {
 819                 return TRUE;
 820         }
 821
 822         if (is_extra_bold(*y,*x))
 823         {
 824                 /* Save the tunnel location */
 825                 if (dun->tunn_n < TUNN_MAX)
 826                 {
 827                         dun->tunn[dun->tunn_n].y = *y;
 828                         dun->tunn[dun->tunn_n].x = *x;
 829                         dun->tunn_n++;
 830
 831                         return TRUE;
 832                 }
 833                 else return FALSE;
 834         }
 835
 836         if (is_floor_bold(*y, *x))
 837         {
 838                 /* Don't do anything */
 839                 return TRUE;
 840         }
 841
 842         if (is_outer_grid(c_ptr) && affectwall)
 843         {
 844                 /* Save the wall location */
 845                 if (dun->wall_n < WALL_MAX)
 846                 {
 847                         dun->wall[dun->wall_n].y = *y;
 848                         dun->wall[dun->wall_n].x = *x;
 849                         dun->wall_n++;
 850                 }
 851                 else return FALSE;
 852
 853                 /* Forbid re-entry near this piercing */
 854                 for (j = *y - 1; j <= *y + 1; j++)
 855                 {
 856                         for (i = *x - 1; i <= *x + 1; i++)
 857                         {
 858                                 /* Convert adjacent "outer" walls as "solid" walls */
 859                                 if (is_outer_bold(j, i))
 860                                 {
 861                                         /* Change the wall to a "solid" wall */
 862                                         place_solid_noperm_bold(j, i);
 863                                 }
 864                         }
 865                 }
 866
 867                 /* Clear mimic type */
 868                 cave[*y][*x].mimic = 0;
 869
 870                 place_floor_bold(*y, *x);
 871
 872                 return TRUE;
 873         }
 874
 875         if (is_solid_grid(c_ptr) && affectwall)
 876         {
 877                 /* cannot place tunnel here - use a square to the side */
 878
 879                 /* find usable square and return value in (x,y) */
 880
 881                 i = 50;
 882
 883                 dy = 0;
 884                 dx = 0;
 885                 while ((i > 0) && is_solid_bold(*y + dy, *x + dx))
 886                 {
 887                         dy = randint0(3) - 1;
 888                         dx = randint0(3) - 1;
 889
 890                         if (!in_bounds(*y + dy, *x + dx))
 891                         {
 892                                 dx = 0;
 893                                 dy = 0;
 894                         }
 895
 896                         i--;
 897                 }
 898
 899                 if (i == 0)
 900                 {
 901                         /* Failed for some reason: hack - ignore the solidness */
 902                         place_outer_grid(c_ptr);
 903                         dx = 0;
 904                         dy = 0;
 905                 }
 906
 907                 /* Give new, acceptable coordinate. */
 908                 *x = *x + dx;
 909                 *y = *y + dy;
 910
 911                 return FALSE;
 912         }
 913
 914         return TRUE;
 915 }
 916
 917
 918 /*
 919  * This routine creates the catacomb-like tunnels by removing extra rock.
 920  * Note that this routine is only called on "even" squares - so it gives
 921  * a natural checkerboard pattern.
 922  */
 923 static void create_cata_tunnel(int x, int y)
 924 {
 925         int x1, y1;
 926
 927         /* Build tunnel */
 928         x1 = x - 1;
 929         y1 = y;
 930         set_tunnel(&x1, &y1, FALSE);
 931
 932         x1 = x + 1;
 933         y1 = y;
 934         set_tunnel(&x1, &y1, FALSE);
 935
 936         x1 = x;
 937         y1 = y - 1;
 938         set_tunnel(&x1, &y1, FALSE);
 939
 940         x1 = x;
 941         y1 = y + 1;
 942         set_tunnel(&x1, &y1, FALSE);
 943 }
 944
 945
 946 /*
 947  * This routine does the bulk of the work in creating the new types of tunnels.
 948  * It is designed to use very simple algorithms to go from (x1,y1) to (x2,y2)
 949  * It doesn't need to add any complexity - straight lines are fine.
 950  * The SOLID walls are avoided by a recursive algorithm which tries random ways
 951  * around the obstical until it works.  The number of itterations is counted, and it
 952  * this gets too large the routine exits. This should stop any crashes - but may leave
 953  * small gaps in the tunnel where there are too many SOLID walls.
 954  *
 955  * Type 1 tunnels are extremely simple - straight line from A to B.  This is only used
 956  * as a part of the dodge SOLID walls algorithm.
 957  *
 958  * Type 2 tunnels are made of two straight lines at right angles. When this is used with
 959  * short line segments it gives the "cavelike" tunnels seen deeper in the dungeon.
 960  *
 961  * Type 3 tunnels are made of two straight lines like type 2, but with extra rock removed.
 962  * This, when used with longer line segments gives the "catacomb-like" tunnels seen near
 963  * the surface.
 964  */
 965 static void short_seg_hack(int x1, int y1, int x2, int y2, int type, int count, bool *fail)
 966 {
 967         int i, x, y;
 968         int length;
 969
 970         /* Check for early exit */
 971         if (!(*fail)) return;
 972
 973         length = distance(x1, y1, x2, y2);
 974
 975         count++;
 976
 977         if ((type == 1) && (length != 0))
 978         {
 979
 980                 for (i = 0; i <= length; i++)
 981                 {
 982                         x = x1 + i * (x2 - x1) / length;
 983                         y = y1 + i * (y2 - y1) / length;
 984                         if (!set_tunnel(&x, &y, TRUE))
 985                         {
 986                                 if (count > 50)
 987                                 {
 988                                         /* This isn't working - probably have an infinite loop */
 989                                         *fail = FALSE;
 990                                         return;
 991                                 }
 992
 993                                 /* solid wall - so try to go around */
 994                                 short_seg_hack(x, y, x1 + (i - 1) * (x2 - x1) / length, y1 + (i - 1) * (y2 - y1) / length, 1, count, fail);
 995                                 short_seg_hack(x, y, x1 + (i + 1) * (x2 - x1) / length, y1 + (i + 1) * (y2 - y1) / length, 1, count, fail);
 996                         }
 997                 }
 998         }
 999         else if ((type == 2) || (type == 3))
1000         {
1001                 if (x1 < x2)
1002                 {
1003                         for (i = x1; i <= x2; i++)
1004                         {
1005                                 x = i;
1006                                 y = y1;
1007                                 if (!set_tunnel(&x, &y, TRUE))
1008                                 {
1009                                         /* solid wall - so try to go around */
1010                                         short_seg_hack(x, y, i - 1, y1, 1, count, fail);
1011                                         short_seg_hack(x, y, i + 1, y1, 1, count, fail);
1012                                 }
1013                                 if ((type == 3) && ((x + y) % 2))
1014                                 {
1015                                         create_cata_tunnel(i, y1);
1016                                 }
1017                         }
1018                 }
1019                 else
1020                 {
1021                         for (i = x2; i <= x1; i++)
1022                         {
1023                                 x = i;
1024                                 y = y1;
1025                                 if (!set_tunnel(&x, &y, TRUE))
1026                                 {
1027                                         /* solid wall - so try to go around */
1028                                         short_seg_hack(x, y, i - 1, y1, 1, count, fail);
1029                                         short_seg_hack(x, y, i + 1, y1, 1, count, fail);
1030                                 }
1031                                 if ((type == 3) && ((x + y) % 2))
1032                                 {
1033                                         create_cata_tunnel(i, y1);
1034                                 }
1035                         }
1036
1037                 }
1038                 if (y1 < y2)
1039                 {
1040                         for (i = y1; i <= y2; i++)
1041                         {
1042                                 x = x2;
1043                                 y = i;
1044                                 if (!set_tunnel(&x, &y, TRUE))
1045                                 {
1046                                         /* solid wall - so try to go around */
1047                                         short_seg_hack(x, y, x2, i - 1, 1, count, fail);
1048                                         short_seg_hack(x, y, x2, i + 1, 1, count, fail);
1049                                 }
1050                                 if ((type == 3) && ((x + y) % 2))
1051                                 {
1052                                         create_cata_tunnel(x2, i);
1053                                 }
1054                         }
1055                 }
1056                 else
1057                 {
1058                         for (i = y2; i <= y1; i++)
1059                         {
1060                                 x = x2;
1061                                 y = i;
1062                                 if (!set_tunnel(&x, &y, TRUE))
1063                                 {
1064                                         /* solid wall - so try to go around */
1065                                         short_seg_hack(x, y, x2, i - 1, 1, count, fail);
1066                                         short_seg_hack(x, y, x2, i + 1, 1, count, fail);
1067                                 }
1068                                 if ((type == 3) && ((x + y) % 2))
1069                                 {
1070                                         create_cata_tunnel(x2, i);
1071                                 }
1072                         }
1073                 }
1074         }
1075 }
1076
1077
1078 /*
1079  * This routine maps a path from (x1, y1) to (x2, y2) avoiding SOLID walls.
1080  * Permanent rock is ignored in this path finding- sometimes there is no
1081  * path around anyway -so there will be a crash if we try to find one.
1082  * This routine is much like the river creation routine in Zangband.
1083  * It works by dividing a line segment into two.  The segments are divided
1084  * until they are less than "cutoff" - when the corresponding routine from
1085  * "short_seg_hack" is called.
1086  * Note it is VERY important that the "stop if hit another passage" logic
1087  * stays as is.  Without this the dungeon turns into Swiss Cheese...
1088  */
1089 bool build_tunnel2(int x1, int y1, int x2, int y2, int type, int cutoff)
1090 {
1091         int x3, y3, dx, dy;
1092         int changex, changey;
1093         int length;
1094         int i;
1095         bool retval, firstsuccede;
1096         cave_type *c_ptr;
1097
1098         length = distance(x1, y1, x2, y2);
1099
1100         if (length > cutoff)
1101         {
1102                 /*
1103                 * Divide path in half and call routine twice.
1104                  */
1105                 dx = (x2 - x1) / 2;
1106                 dy = (y2 - y1) / 2;
1107
1108                 /* perturbation perpendicular to path */
1109                 changex = (randint0(abs(dy) + 2) * 2 - abs(dy) - 1) / 2;
1110
1111                 /* perturbation perpendicular to path */
1112                 changey = (randint0(abs(dx) + 2) * 2 - abs(dx) - 1) / 2;
1113
1114                 /* Work out "mid" ponit */
1115                 x3 = x1 + dx + changex;
1116                 y3 = y1 + dy + changey;
1117
1118                 /* See if in bounds - if not - do not perturb point */
1119                 if (!in_bounds(y3, x3))
1120                 {
1121                         x3 = (x1 + x2) / 2;
1122                         y3 = (y1 + y2) / 2;
1123                 }
1124                 /* cache c_ptr */
1125                 c_ptr = &cave[y3][x3];
1126                 if (is_solid_grid(c_ptr))
1127                 {
1128                         /* move midpoint a bit to avoid problem. */
1129
1130                         i = 50;
1131
1132                         dy = 0;
1133                         dx = 0;
1134                         while ((i > 0) && is_solid_bold(y3 + dy, x3 + dx))
1135                         {
1136                                 dy = randint0(3) - 1;
1137                                 dx = randint0(3) - 1;
1138                                 if (!in_bounds(y3 + dy, x3 + dx))
1139                                 {
1140                                         dx = 0;
1141                                         dy = 0;
1142                                 }
1143                                 i--;
1144                         }
1145
1146                         if (i == 0)
1147                         {
1148                                 /* Failed for some reason: hack - ignore the solidness */
1149                                 place_outer_bold(y3, x3);
1150                                 dx = 0;
1151                                 dy = 0;
1152                         }
1153                         y3 += dy;
1154                         x3 += dx;
1155                         c_ptr = &cave[y3][x3];
1156                 }
1157
1158                 if (is_floor_grid(c_ptr))
1159                 {
1160                         if (build_tunnel2(x1, y1, x3, y3, type, cutoff))
1161                         {
1162                                 if ((cave[y3][x3].info & CAVE_ROOM) || (randint1(100) > 95))
1163                                 {
1164                                         /* do second half only if works + if have hit a room */
1165                                         retval = build_tunnel2(x3, y3, x2, y2, type, cutoff);
1166                                 }
1167                                 else
1168                                 {
1169                                         /* have hit another tunnel - make a set of doors here */
1170                                         retval = FALSE;
1171
1172                                         /* Save the door location */
1173                                         if (dun->door_n < DOOR_MAX)
1174                                         {
1175                                                 dun->door[dun->door_n].y = y3;
1176                                                 dun->door[dun->door_n].x = x3;
1177                                                 dun->door_n++;
1178                                         }
1179                                         else return FALSE;
1180                                 }
1181                                 firstsuccede = TRUE;
1182                         }
1183                         else
1184                         {
1185                                 /* false- didn't work all the way */
1186                                 retval = FALSE;
1187                                 firstsuccede = FALSE;
1188                         }
1189                 }
1190                 else
1191                 {
1192                         /* tunnel through walls */
1193                         if (build_tunnel2(x1, y1, x3, y3, type, cutoff))
1194                         {
1195                                 retval = build_tunnel2(x3, y3, x2, y2, type, cutoff);
1196                                 firstsuccede = TRUE;
1197                         }
1198                         else
1199                         {
1200                                 /* false- didn't work all the way */
1201                                 retval = FALSE;
1202                                 firstsuccede = FALSE;
1203                         }
1204                 }
1205                 if (firstsuccede)
1206                 {
1207                         /* only do this if the first half has worked */
1208                         set_tunnel(&x3, &y3, TRUE);
1209                 }
1210                 /* return value calculated above */
1211                 return retval;
1212         }
1213         else
1214         {
1215                 /* Do a short segment */
1216                 retval = TRUE;
1217                 short_seg_hack(x1, y1, x2, y2, type, 0, &retval);
1218
1219                 /* Hack - ignore return value so avoid infinite loops */
1220                 return TRUE;
1221         }
1222 }
1223