-/*
- * File: grid.c
- * Purpose: low-level dungeon creation primitives
- */
-
-/*
- * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
- *
- * This software may be copied and distributed for educational, research,
- * and not for profit purposes provided that this copyright and statement
- * are included in all such copies. Other copyrights may also apply.
+/*!
+ * @file grid.c
+ * @brief ¥À¥ó¥¸¥ç¥ó¤ÎÀ¸À®½èÍý¤Î´ð´´Éôʬ / low-level dungeon creation primitives
+ * @date 2014/01/04
+ * @author
+ * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
+ *\n
+ * This software may be copied and distributed for educational, research,\n
+ * and not for profit purposes provided that this copyright and statement\n
+ * are included in all such copies. Other copyrights may also apply.\n
+ * \n
+ * 2014 Deskull Doxygen¸þ¤±¤Î¥³¥á¥ó¥ÈÀ°Íý\n
*/
#include "angband.h"
#include "grid.h"
-/*
- * Returns random co-ordinates for player/monster/object
+/*!
+ * @brief ¿·µ¬¥Õ¥í¥¢¤ËÆþ¤ê¤¿¤Æ¤Î¥×¥ì¥¤¥ä¡¼¤ò¥é¥ó¥À¥à¤Ê¾ì½ê¤ËÇÛÃÖ¤¹¤ë / Returns random co-ordinates for player/monster/object
+ * @return ÇÛÃÖ¤ËÀ®¸ù¤·¤¿¤éTRUE¤òÊÖ¤¹
*/
bool new_player_spot(void)
{
int y, x;
- int max_attempts = 5000;
+ int max_attempts = 10000;
cave_type *c_ptr;
+ feature_type *f_ptr;
/* Place the player */
while (max_attempts--)
/* Must be a "naked" floor grid */
if (c_ptr->m_idx) continue;
- if (!have_flag(f_flags_grid(c_ptr), FF_MOVE) && !have_flag(f_flags_grid(c_ptr), FF_CAN_FLY)) continue;
+ if (dun_level)
+ {
+ f_ptr = &f_info[c_ptr->feat];
+
+ if (max_attempts > 5000) /* Rule 1 */
+ {
+ if (!have_flag(f_ptr->flags, FF_FLOOR)) continue;
+ }
+ else /* Rule 2 */
+ {
+ if (!have_flag(f_ptr->flags, FF_MOVE)) continue;
+ if (have_flag(f_ptr->flags, FF_HIT_TRAP)) continue;
+ }
+
+ /* Refuse to start on anti-teleport grids in dungeon */
+ if (!have_flag(f_ptr->flags, FF_TELEPORTABLE)) continue;
+ }
if (!player_can_enter(c_ptr->feat, 0)) continue;
if (!in_bounds(y, x)) continue;
}
-/*
- * Place an up/down staircase at given location
+
+/*!
+ * @brief ½êÄê¤Î°ÌÃ֤˾å¤ê³¬Ãʤ«²¼¤ê³¬ÃʤòÇÛÃÖ¤¹¤ë / Place an up/down staircase at given location
+ * @param y ÇÛÃÖ¤ò»î¤ß¤¿¤¤¥Þ¥¹¤ÎYºÂɸ
+ * @param x ÇÛÃÖ¤ò»î¤ß¤¿¤¤¥Þ¥¹¤ÎXºÂɸ
+ * @return ¤Ê¤·
*/
void place_random_stairs(int y, int x)
{
place_down_stairs(y, x);
}
-
-/*
- * Place a random type of door at the given location
+/*!
+ * @brief ½êÄê¤Î°ÌÃ֤ˤµ¤Þ¤¶¤Þ¤Ê¾õÂÖ¤ä¼ïÎà¤Î¥É¥¢¤òÇÛÃÖ¤¹¤ë / Place a random type of door at the given location
+ * @param y ¥É¥¢¤ÎÇÛÃÖ¤ò»î¤ß¤¿¤¤¥Þ¥¹¤ÎYºÂɸ
+ * @param x ¥É¥¢¤ÎÇÛÃÖ¤ò»î¤ß¤¿¤¤¥Þ¥¹¤ÎXºÂɸ
+ * @param room Éô²°¤ËÀܤ·¤Æ¤¤¤ë¾ì¹ç¸þ¤±¤Î¥É¥¢À¸À®¤«Èݤ«
+ * @return ¤Ê¤·
*/
void place_random_door(int y, int x, bool room)
{
- int tmp;
+ int tmp, type;
+ s16b feat = feat_none;
cave_type *c_ptr = &cave[y][x];
/* Initialize mimic info */
c_ptr->mimic = 0;
-
+
if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
{
place_floor_bold(y, x);
return;
}
+ type = ((d_info[dungeon_type].flags1 & DF1_CURTAIN) &&
+ one_in_((d_info[dungeon_type].flags1 & DF1_NO_CAVE) ? 16 : 256)) ? DOOR_CURTAIN :
+ ((d_info[dungeon_type].flags1 & DF1_GLASS_DOOR) ? DOOR_GLASS_DOOR : DOOR_DOOR);
+
/* Choose an object */
tmp = randint0(1000);
if (tmp < 300)
{
/* Create open door */
- set_cave_feat(y, x, FEAT_OPEN);
+ feat = feat_door[type].open;
}
/* Broken doors (100/1000) */
else if (tmp < 400)
{
/* Create broken door */
- set_cave_feat(y, x, FEAT_BROKEN);
+ feat = feat_door[type].broken;
}
/* Secret doors (200/1000) */
else if (tmp < 600)
{
/* Create secret door */
- place_closed_door(y, x);
-
- /* Hide. If on the edge of room, use outer wall. */
- c_ptr->mimic = room ? feat_wall_outer : fill_type[randint0(100)];
+ place_closed_door(y, x, type);
- /* Floor type terrain cannot hide a door */
- if (feat_supports_los(c_ptr->mimic) && !feat_supports_los(c_ptr->feat))
+ if (type != DOOR_CURTAIN)
{
- if (have_flag(f_info[c_ptr->mimic].flags, FF_MOVE)) c_ptr->feat = c_ptr->mimic;
- c_ptr->mimic = 0;
+ /* Hide. If on the edge of room, use outer wall. */
+ c_ptr->mimic = room ? feat_wall_outer : fill_type[randint0(100)];
+
+ /* Floor type terrain cannot hide a door */
+ if (feat_supports_los(c_ptr->mimic) && !feat_supports_los(c_ptr->feat))
+ {
+ if (have_flag(f_info[c_ptr->mimic].flags, FF_MOVE) || have_flag(f_info[c_ptr->mimic].flags, FF_CAN_FLY))
+ {
+ c_ptr->feat = one_in_(2) ? c_ptr->mimic : floor_type[randint0(100)];
+ }
+ c_ptr->mimic = 0;
+ }
}
}
/* Closed, locked, or stuck doors (400/1000) */
- else place_closed_door(y, x);
-}
+ else place_closed_door(y, x, type);
+
+ if (tmp < 400)
+ {
+ if (feat != feat_none)
+ {
+ set_cave_feat(y, x, feat);
+ }
+ else
+ {
+ place_floor_bold(y, x);
+ }
+ }
+ delete_monster(y, x);
+}
-/*
- * Place a random type of normal door at the given location.
+/*!
+ * @brief ½êÄê¤Î°ÌÃ֤˳Ƽï¤ÎÊĤ¸¤¿¥É¥¢¤òÇÛÃÖ¤¹¤ë / Place a random type of normal door at the given location.
+ * @param y ¥É¥¢¤ÎÇÛÃÖ¤ò»î¤ß¤¿¤¤¥Þ¥¹¤ÎYºÂɸ
+ * @param x ¥É¥¢¤ÎÇÛÃÖ¤ò»î¤ß¤¿¤¤¥Þ¥¹¤ÎXºÂɸ
+ * @param type ¥É¥¢¤ÎÃÏ·ÁID
+ * @return ¤Ê¤·
*/
-void place_closed_door(int y, int x)
+void place_closed_door(int y, int x, int type)
{
int tmp;
+ s16b feat = feat_none;
if (d_info[dungeon_type].flags1 & DF1_NO_DOORS)
{
if (tmp < 300)
{
/* Create closed door */
- cave_set_feat(y, x, FEAT_DOOR_HEAD + 0x00);
+ feat = feat_door[type].closed;
}
/* Locked doors (99/400) */
else if (tmp < 399)
{
/* Create locked door */
- cave_set_feat(y, x, FEAT_DOOR_HEAD + randint1(7));
+ feat = feat_locked_door_random(type);
}
/* Stuck doors (1/400) */
else
{
/* Create jammed door */
- cave_set_feat(y, x, FEAT_DOOR_HEAD + 0x08 + randint0(8));
+ feat = feat_jammed_door_random(type);
}
- /* Now it is not floor */
- cave[y][x].info &= ~(CAVE_MASK);
-}
+ if (feat != feat_none)
+ {
+ cave_set_feat(y, x, feat);
+ /* Now it is not floor */
+ cave[y][x].info &= ~(CAVE_MASK);
+ }
+ else
+ {
+ place_floor_bold(y, x);
+ }
+}
-/*
- * Make an empty square floor, for the middle of rooms
+/*!
+ * @brief ĹÊý·Á¤Î¶õƶ¤òÀ¸À®¤¹¤ë / Make an empty square floor, for the middle of rooms
+ * @param x1 ĹÊý·Á¤Îº¸Ã¼XºÂɸ(-1)
+ * @param x2 ĹÊý·Á¤Î±¦Ã¼XºÂɸ(+1)
+ * @param y1 ĹÊý·Á¤Î¾åüYºÂɸ(-1)
+ * @param y2 ĹÊý·Á¤Î²¼Ã¼YºÂɸ(+1)
+ * @param light ¾ÈÌÀ¤ÎÍ̵
+ * @return ¤Ê¤·
*/
void place_floor(int x1, int x2, int y1, int y2, bool light)
{
}
-/*
- * Make an empty square room, only floor and wall grids
+/*!
+ * @brief ĹÊý·Á¤ÎÉô²°¤òÀ¸À®¤¹¤ë / Make an empty square room, only floor and wall grids
+ * @param x1 ĹÊý·Á¤Îº¸Ã¼XºÂɸ(-1)
+ * @param x2 ĹÊý·Á¤Î±¦Ã¼XºÂɸ(+1)
+ * @param y1 ĹÊý·Á¤Î¾åüYºÂɸ(-1)
+ * @param y2 ĹÊý·Á¤Î²¼Ã¼YºÂɸ(+1)
+ * @param light ¾ÈÌÀ¤ÎÍ̵
+ * @return ¤Ê¤·
*/
void place_room(int x1, int x2, int y1, int y2, bool light)
{
}
-/*
- * Create up to "num" objects near the given coordinates
+/*!
+ * @brief Æüì¤ÊÉô²°¸þ¤±¤Ë³Æ¼ï¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤¹¤ë / Create up to "num" objects near the given coordinates
+ * @param y ÇÛÃÖ¤·¤¿¤¤Ãæ¿´¥Þ¥¹¤ÎYºÂɸ
+ * @param x ÇÛÃÖ¤·¤¿¤¤Ãæ¿´¥Þ¥¹¤ÎXºÂɸ
+ * @param num ÇÛÃÖ¤·¤¿¤¤¿ô
+ * @return ¤Ê¤·
+ * @details
* Only really called by some of the "vault" routines.
*/
void vault_objects(int y, int x, int num)
}
}
-
-/*
- * Place a trap with a given displacement of point
+/*!
+ * @brief Æüì¤ÊÉô²°¸þ¤±¤Ë³Æ¼ï¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤¹¤ë(vault_trap¤Î¥µ¥Ö¥»¥Ã¥È) / Place a trap with a given displacement of point
+ * @param y ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´YºÂɸ
+ * @param x ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´XºÂɸ
+ * @param yd YÊý¸þ¤ÎÇÛÃÖʬ»¶¥Þ¥¹¿ô
+ * @param xd XÊý¸þ¤ÎÇÛÃÖʬ»¶¥Þ¥¹¿ô
+ * @return ¤Ê¤·
+ * @details
+ * Only really called by some of the "vault" routines.
*/
void vault_trap_aux(int y, int x, int yd, int xd)
{
}
}
-
-/*
- * Place some traps with a given displacement of given location
+/*!
+ * @brief Æüì¤ÊÉô²°¸þ¤±¤Ë³Æ¼ï¥¢¥¤¥Æ¥à¤òÇÛÃÖ¤¹¤ë(¥á¥¤¥ó¥ë¡¼¥Á¥ó) / Place some traps with a given displacement of given location
+ * @param y ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´YºÂɸ
+ * @param x ¥È¥é¥Ã¥×¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´XºÂɸ
+ * @param yd YÊý¸þ¤ÎÇÛÃÖʬ»¶¥Þ¥¹¿ô
+ * @param xd XÊý¸þ¤ÎÇÛÃÖʬ»¶¥Þ¥¹¿ô
+ * @param num ÇÛÃÖ¤·¤¿¤¤¥È¥é¥Ã¥×¤Î¿ô
+ * @return ¤Ê¤·
+ * @details
+ * Only really called by some of the "vault" routines.
*/
void vault_traps(int y, int x, int yd, int xd, int num)
{
}
}
-
-/*
- * Hack -- Place some sleeping monsters near the given location
+/*!
+ * @brief Æüì¤ÊÉô²°ÃÏ·Á¸þ¤±¤Ë¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤¹¤ë / Hack -- Place some sleeping monsters near the given location
+ * @param y1 ¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´YºÂɸ
+ * @param x1 ¥â¥ó¥¹¥¿¡¼¤òÇÛÃÖ¤·¤¿¤¤¥Þ¥¹¤ÎÃæ¿´XºÂɸ
+ * @param num ÇÛÃÖ¤·¤¿¤¤¥â¥ó¥¹¥¿¡¼¤Î¿ô
+ * @return ¤Ê¤·
+ * @details
+ * Only really called by some of the "vault" routines.
*/
void vault_monsters(int y1, int x1, int num)
{
}
-/*
- * Count the number of walls adjacent to the given grid.
- *
- * Note -- Assumes "in_bounds(y, x)"
- *
- * We count only granite walls and permanent walls.
- */
-int next_to_walls(int y, int x)
-{
- int k = 0;
-
- if (cave_floor_grid(&cave[y + 1][x])) k++;
- if (cave_floor_grid(&cave[y - 1][x])) k++;
- if (cave_floor_grid(&cave[y][x + 1])) k++;
- if (cave_floor_grid(&cave[y][x - 1])) k++;
-
- return (k);
-}
-
-
-/*
- * Always picks a correct direction
+/*!
+ * @brief build_tunnelÍѤËÄÌÏ©¤ò·¡¤ë¤¿¤á¤ÎÊý¸þ¤ò°ÌÃÖ´Ø·¸Ä̤ê¤Ë·è¤á¤ë / Always picks a correct direction
+ * @param rdir YÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃͤòÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
+ * @param cdir XÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃͤòÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
+ * @param y1 »ÏÅÀYºÂɸ
+ * @param x1 »ÏÅÀXºÂɸ
+ * @param y2 ½ªÅÀYºÂɸ
+ * @param x2 ½ªÅÀXºÂɸ
+ * @return ¤Ê¤·
*/
void correct_dir(int *rdir, int *cdir, int y1, int x1, int y2, int x2)
{
}
}
-
-/*
- * Pick a random direction
+/*!
+ * @brief build_tunnelÍѤËÄÌÏ©¤ò·¡¤ë¤¿¤á¤ÎÊý¸þ¤ò¥é¥ó¥À¥à¤Ë·è¤á¤ë / Pick a random direction
+ * @param rdir YÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃͤòÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
+ * @param cdir XÊý¸þ¤Ë¼è¤ë¤Ù¤¥Ù¥¯¥È¥ëÃͤòÊÖ¤¹»²¾È¥Ý¥¤¥ó¥¿
+ * @return ¤Ê¤·
*/
void rand_dir(int *rdir, int *cdir)
{
*cdir = ddx_ddd[i];
}
-
-/* Function that sees if a square is a floor. (Includes range checking.) */
+/*!
+ * @brief »ØÄê¤Î¥Þ¥¹¤¬¾²·ÏÃÏ·Á¤Ç¤¢¤ë¤«¤òÊÖ¤¹ / Function that sees if a square is a floor. (Includes range checking.)
+ * @param x ¥Á¥§¥Ã¥¯¤¹¤ë¥Þ¥¹¤ÎXºÂɸ
+ * @param y ¥Á¥§¥Ã¥¯¤¹¤ë¥Þ¥¹¤ÎYºÂɸ
+ * @return ¾²·ÏÃÏ·Á¤Ê¤é¤ÐTRUE
+ */
bool get_is_floor(int x, int y)
{
if (!in_bounds(y, x))
return (FALSE);
}
-
-/* Set a square to be floor. (Includes range checking.) */
+/*!
+ * @brief »ØÄê¤Î¥Þ¥¹¤ò¾²ÃÏ·Á¤ËÊѤ¨¤ë / Set a square to be floor. (Includes range checking.)
+ * @param x ÃÏ·Á¤òÊѤ¨¤¿¤¤¥Þ¥¹¤ÎXºÂɸ
+ * @param y ÃÏ·Á¤òÊѤ¨¤¿¤¤¥Þ¥¹¤ÎYºÂɸ
+ * @return ¤Ê¤·
+ */
void set_floor(int x, int y)
{
if (!in_bounds(y, x))
}
-
-/*
- * Constructs a tunnel between two points
- *
- * This function must be called BEFORE any streamers are created,
- * since we use the special "granite wall" sub-types to keep track
- * of legal places for corridors to pierce rooms.
- *
- * We use "door_flag" to prevent excessive construction of doors
- * along overlapping corridors.
- *
- * We queue the tunnel grids to prevent door creation along a corridor
- * which intersects itself.
- *
- * We queue the wall piercing grids to prevent a corridor from leaving
- * a room and then coming back in through the same entrance.
- *
- * We "pierce" grids which are "outer" walls of rooms, and when we
- * do so, we change all adjacent "outer" walls of rooms into "solid"
- * walls so that no two corridors may use adjacent grids for exits.
- *
- * The "solid" wall check prevents corridors from "chopping" the
- * corners of rooms off, as well as "silly" door placement, and
- * "excessively wide" room entrances.
- *
- * Kind of walls:
- * extra -- walls
- * inner -- inner room walls
- * outer -- outer room walls
- * solid -- solid room walls
+/*!
+ * @brief Éô²°´Ö¤Î¥È¥ó¥Í¥ë¤òÀ¸À®¤¹¤ë / Constructs a tunnel between two points
+ * @param row1 »ÏÅÀYºÂɸ
+ * @param col1 »ÏÅÀXºÂɸ
+ * @param row2 ½ªÅÀYºÂɸ
+ * @param col2 ½ªÅÀXºÂɸ
+ * @return À¸À®¤ËÀ®¸ù¤·¤¿¤éTRUE¤òÊÖ¤¹
+ * @details
+ * This function must be called BEFORE any streamers are created,\n
+ * since we use the special "granite wall" sub-types to keep track\n
+ * of legal places for corridors to pierce rooms.\n
+ *\n
+ * We use "door_flag" to prevent excessive construction of doors\n
+ * along overlapping corridors.\n
+ *\n
+ * We queue the tunnel grids to prevent door creation along a corridor\n
+ * which intersects itself.\n
+ *\n
+ * We queue the wall piercing grids to prevent a corridor from leaving\n
+ * a room and then coming back in through the same entrance.\n
+ *\n
+ * We "pierce" grids which are "outer" walls of rooms, and when we\n
+ * do so, we change all adjacent "outer" walls of rooms into "solid"\n
+ * walls so that no two corridors may use adjacent grids for exits.\n
+ *\n
+ * The "solid" wall check prevents corridors from "chopping" the\n
+ * corners of rooms off, as well as "silly" door placement, and\n
+ * "excessively wide" room entrances.\n
+ *\n
+ * Kind of walls:\n
+ * extra -- walls\n
+ * inner -- inner room walls\n
+ * outer -- outer room walls\n
+ * solid -- solid room walls\n
*/
-void build_tunnel(int row1, int col1, int row2, int col2)
+bool build_tunnel(int row1, int col1, int row2, int col2)
{
int y, x;
int tmp_row, tmp_col;
bool door_flag = FALSE;
cave_type *c_ptr;
- feature_type *f_ptr;
/* Save the starting location */
start_row = row1;
while ((row1 != row2) || (col1 != col2))
{
/* Mega-Hack -- Paranoia -- prevent infinite loops */
- if (main_loop_count++ > 2000) break;
+ if (main_loop_count++ > 2000) return FALSE;
/* Allow bends in the tunnel */
if (randint0(100) < dun_tun_chg)
/* Access the location */
c_ptr = &cave[tmp_row][tmp_col];
- f_ptr = &f_info[c_ptr->feat];
-
- if (have_flag(f_ptr->flags, FF_WALL) && have_flag(f_ptr->flags, FF_PERMANENT))
- {
- /* Avoid the edge of vaults */
- if (is_inner_grid(c_ptr)) continue;
- }
/* Avoid "solid" walls */
if (is_solid_grid(c_ptr)) continue;
/* Pierce "outer" walls of rooms */
if (is_outer_grid(c_ptr))
{
- feature_type *ff_ptr;
-
/* Acquire the "next" location */
y = tmp_row + row_dir;
x = tmp_col + col_dir;
- ff_ptr = &f_info[cave[y][x].feat];
-
/* Hack -- Avoid outer/solid walls */
if (is_outer_bold(y, x)) continue;
if (is_solid_bold(y, x)) continue;
dun->wall[dun->wall_n].x = col1;
dun->wall_n++;
}
+ else return FALSE;
/* Forbid re-entry near this piercing */
for (y = row1 - 1; y <= row1 + 1; y++)
dun->tunn[dun->tunn_n].x = col1;
dun->tunn_n++;
}
+ else return FALSE;
/* Allow door in next grid */
door_flag = FALSE;
dun->door[dun->door_n].x = col1;
dun->door_n++;
}
+ else return FALSE;
/* No door in next grid */
door_flag = TRUE;
}
}
}
+
+ return TRUE;
}
-/*
- * This routine adds the square to the tunnel
- * It also checks for SOLID walls - and returns a nearby
- * non-SOLID square in (x,y) so that a simple avoiding
- * routine can be used. The returned boolean value reflects
- * whether or not this routine hit a SOLID wall.
- *
- * "affectwall" toggles whether or not this new square affects
- * the boundaries of rooms. - This is used by the catacomb
- * routine.
+/*!
+ * @brief ¥È¥ó¥Í¥ëÀ¸À®¤Î¤¿¤á¤Î´ð½àÅÀ¤ò»ØÄꤹ¤ë¡£
+ * @param x ´ð½àÅÀ¤ò»ØÄꤹ¤ëXºÂɸ¤Î»²¾È¥Ý¥¤¥ó¥¿¡¢Å¬»þÃͤ¬½¤Àµ¤µ¤ì¤ë¡£
+ * @param y ´ð½àÅÀ¤ò»ØÄꤹ¤ëYºÂɸ¤Î»²¾È¥Ý¥¤¥ó¥¿¡¢Å¬»þÃͤ¬½¤Àµ¤µ¤ì¤ë¡£
+ * @param affectwall (Ä´ººÃæ)
+ * @return ¤Ê¤·
+ * @details
+ * This routine adds the square to the tunnel\n
+ * It also checks for SOLID walls - and returns a nearby\n
+ * non-SOLID square in (x,y) so that a simple avoiding\n
+ * routine can be used. The returned boolean value reflects\n
+ * whether or not this routine hit a SOLID wall.\n
+ *\n
+ * "affectwall" toggles whether or not this new square affects\n
+ * the boundaries of rooms. - This is used by the catacomb\n
+ * routine.\n
+ * @todo Æä˾ܺ٤ʽèÍý¤Î°ÕÌ£¤òÄ´ºº¤¹¤Ù¤·
*/
static bool set_tunnel(int *x, int *y, bool affectwall)
{
- int feat, i, j, dx, dy;
+ int i, j, dx, dy;
cave_type *c_ptr = &cave[*y][*x];
- feature_type *f_ptr;
if (!in_bounds(*y, *x)) return TRUE;
- feat = c_ptr->feat;
- f_ptr = &f_info[feat];
-
if (is_inner_grid(c_ptr))
{
return TRUE;
dun->tunn[dun->tunn_n].y = *y;
dun->tunn[dun->tunn_n].x = *x;
dun->tunn_n++;
- }
- return TRUE;
+ return TRUE;
+ }
+ else return FALSE;
}
if (is_floor_bold(*y, *x))
dun->wall[dun->wall_n].x = *x;
dun->wall_n++;
}
+ else return FALSE;
/* Forbid re-entry near this piercing */
for (j = *y - 1; j <= *y + 1; j++)
}
-/*
- * This routine creates the catacomb-like tunnels by removing extra rock.
+/*!
+ * @brief ³°Êɤòºï¤Ã¤Æ¡Ö¥«¥¿¥³¥ó¥Ù¾õ¡×¤ÎÄÌÏ©¤òºîÀ®¤¹¤ë / This routine creates the catacomb-like tunnels by removing extra rock.
+ * @param x ´ð½àÅÀ¤ÎXºÂɸ
+ * @param y ´ð½àÅÀ¤ÎYºÂɸ
+ * @return ¤Ê¤·
+ * @details
* Note that this routine is only called on "even" squares - so it gives
* a natural checkerboard pattern.
*/
}
-/*
- * This routine does the bulk of the work in creating the new types of tunnels.
- * It is designed to use very simple algorithms to go from (x1,y1) to (x2,y2)
- * It doesn't need to add any complexity - straight lines are fine.
- * The SOLID walls are avoided by a recursive algorithm which tries random ways
- * around the obstical until it works. The number of itterations is counted, and it
- * this gets too large the routine exits. This should stop any crashes - but may leave
- * small gaps in the tunnel where there are too many SOLID walls.
- *
- * Type 1 tunnels are extremely simple - straight line from A to B. This is only used
- * as a part of the dodge SOLID walls algorithm.
- *
- * Type 2 tunnels are made of two straight lines at right angles. When this is used with
- * short line segments it gives the "cavelike" tunnels seen deeper in the dungeon.
- *
- * Type 3 tunnels are made of two straight lines like type 2, but with extra rock removed.
- * This, when used with longer line segments gives the "catacomb-like" tunnels seen near
- * the surface.
+/*!
+ * @brief ¥È¥ó¥Í¥ëÀ¸À®½èÍý¡Ê¾ÜºÙÄ´ººÃæ¡Ë/ This routine does the bulk of the work in creating the new types of tunnels.
+ * @return ¤Ê¤·
+ * @todo ¾ÜºÙÍÑÄ´ºº
+ * @details
+ * It is designed to use very simple algorithms to go from (x1,y1) to (x2,y2)\n
+ * It doesn't need to add any complexity - straight lines are fine.\n
+ * The SOLID walls are avoided by a recursive algorithm which tries random ways\n
+ * around the obstical until it works. The number of itterations is counted, and it\n
+ * this gets too large the routine exits. This should stop any crashes - but may leave\n
+ * small gaps in the tunnel where there are too many SOLID walls.\n
+ *\n
+ * Type 1 tunnels are extremely simple - straight line from A to B. This is only used\n
+ * as a part of the dodge SOLID walls algorithm.\n
+ *\n
+ * Type 2 tunnels are made of two straight lines at right angles. When this is used with\n
+ * short line segments it gives the "cavelike" tunnels seen deeper in the dungeon.\n
+ *\n
+ * Type 3 tunnels are made of two straight lines like type 2, but with extra rock removed.\n
+ * This, when used with longer line segments gives the "catacomb-like" tunnels seen near\n
+ * the surface.\n
*/
static void short_seg_hack(int x1, int y1, int x2, int y2, int type, int count, bool *fail)
{
}
-/*
- * This routine maps a path from (x1, y1) to (x2, y2) avoiding SOLID walls.
- * Permanent rock is ignored in this path finding- sometimes there is no
- * path around anyway -so there will be a crash if we try to find one.
- * This routine is much like the river creation routine in Zangband.
- * It works by dividing a line segment into two. The segments are divided
- * until they are less than "cutoff" - when the corresponding routine from
- * "short_seg_hack" is called.
- * Note it is VERY important that the "stop if hit another passage" logic
- * stays as is. Without this the dungeon turns into Swiss Cheese...
+/*!
+ * @brief ÆÃÄê¤ÎÊÉ(±Êµ×ÊɤʤÉ)¤òÈò¤±¤Ê¤¬¤éÉô²°´Ö¤ÎÄÌÏ©¤òºîÀ®¤¹¤ë / This routine maps a path from (x1, y1) to (x2, y2) avoiding SOLID walls.
+ * @return ¤Ê¤·
+ * @todo ¾ÜºÙÍÑÄ´ºº
+ * @details
+ * Permanent rock is ignored in this path finding- sometimes there is no\n
+ * path around anyway -so there will be a crash if we try to find one.\n
+ * This routine is much like the river creation routine in Zangband.\n
+ * It works by dividing a line segment into two. The segments are divided\n
+ * until they are less than "cutoff" - when the corresponding routine from\n
+ * "short_seg_hack" is called.\n
+ * Note it is VERY important that the "stop if hit another passage" logic\n
+ * stays as is. Without this the dungeon turns into Swiss Cheese...\n
*/
bool build_tunnel2(int x1, int y1, int x2, int y2, int type, int cutoff)
{
dun->door[dun->door_n].x = x3;
dun->door_n++;
}
+ else return FALSE;
}
firstsuccede = TRUE;
}
OSDN Git Service
