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;
*/
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);
+ place_closed_door(y, x, type);
- /* 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 (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.
*/
-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);
+ }
}
/*
- * 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
*/
void correct_dir(int *rdir, int *cdir, int y1, int x1, int y2, int x2)
* outer -- outer room walls
* solid -- solid room walls
*/
-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 (permanent_wall(f_ptr))
- {
- /* 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;
}
*/
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++)
dun->door[dun->door_n].x = x3;
dun->door_n++;
}
+ else return FALSE;
}
firstsuccede = TRUE;
}
OSDN Git Service
