static bool is_valid_pf(int y, int x)
{
/* Unvisited means allowed */
if (!square_isknown(cave, y, x)) return (true);
/* No lava */
if (!square_isfiery(cave, y, x)) return (true);
/* Require open space */
return (square_ispassable(cave, y, x));
}
/**
* Determine if a given grid may be "walked"
*/
static bool do_cmd_walk_test(int y, int x)
{
int m_idx = cave->squares[y][x].mon;
struct monster *mon = cave_monster(cave, m_idx);
/* Allow attack on visible monsters if unafraid */
if (m_idx > 0 && mflag_has(mon->mflag, MFLAG_VISIBLE) &&
!is_mimicking(mon)) {
/* Handle player fear */
if (player_of_has(player, OF_AFRAID)) {
/* Extract monster name (or "it") */
char m_name[80];
monster_desc(m_name, sizeof(m_name), mon, MDESC_DEFAULT);
/* Message */
msgt(MSG_AFRAID, "You are too afraid to attack %s!", m_name);
/* Nope */
return (false);
}
return (true);
}
/* If we don't know the grid, allow attempts to walk into it */
if (!square_isknown(cave, y, x))
return true;
/* Require open space */
if (!square_ispassable(cave, y, x)) {
if (square_isrubble(cave, y, x))
/* Rubble */
msgt(MSG_HITWALL, "There is a pile of rubble in the way!");
else if (square_iscloseddoor(cave, y, x))
/* Door */
return true;
else if (square_isbright(cave, y, x))
/* Lava */
msgt(MSG_HITWALL, "The heat of the lava turns you away!");
else
/* Wall */
msgt(MSG_HITWALL, "There is a wall in the way!");
/* Cancel repeat */
disturb(player, 0);
/* Nope */
return (false);
}
/* Okay */
return (true);
}
/**
* Try to push past / kill another monster. Returns true on success.
*/
static bool process_monster_try_push(struct chunk *c, struct monster *mon,
const char *m_name, int nx, int ny)
{
struct monster *mon1 = square_monster(c, ny, nx);
struct monster_lore *lore = get_lore(mon->race);
/* Kill weaker monsters */
int kill_ok = rf_has(mon->race->flags, RF_KILL_BODY);
/* Move weaker monsters if they can swap places */
/* (not in a wall) */
int move_ok = (rf_has(mon->race->flags, RF_MOVE_BODY) &&
square_ispassable(c, mon->fy, mon->fx));
if (compare_monsters(mon, mon1) > 0) {
/* Learn about pushing and shoving */
if (mflag_has(mon->mflag, MFLAG_VISIBLE)) {
rf_on(lore->flags, RF_KILL_BODY);
rf_on(lore->flags, RF_MOVE_BODY);
}
if (kill_ok || move_ok) {
/* Get the names of the monsters involved */
char n_name[80];
monster_desc(n_name, sizeof(n_name), mon1, MDESC_IND_HID);
/* Reveal mimics */
if (is_mimicking(mon1))
become_aware(mon1);
/* Note if visible */
if (mflag_has(mon->mflag, MFLAG_VISIBLE) &&
mflag_has(mon->mflag, MFLAG_VIEW))
msg("%s %s %s.", m_name,
kill_ok ? "tramples over" : "pushes past", n_name);
/* Monster ate another monster */
if (kill_ok)
delete_monster(ny, nx);
monster_swap(mon->fy, mon->fx, ny, nx);
return true;
}
}
return false;
}
void square_earthquake(struct chunk *c, int y, int x) {
int t = randint0(100);
int f;
if (!square_ispassable(c, y, x)) {
square_set_feat(c, y, x, FEAT_FLOOR);
return;
}
if (t < 20)
f = FEAT_GRANITE;
else if (t < 70)
f = FEAT_QUARTZ;
else
f = FEAT_MAGMA;
square_set_feat(c, y, x, f);
}
/**
* Move player in the given direction.
*
* This routine should only be called when energy has been expended.
*
* Note that this routine handles monsters in the destination grid,
* and also handles attempting to move into walls/doors/rubble/etc.
*/
void move_player(int dir, bool disarm)
{
int y = player->py + ddy[dir];
int x = player->px + ddx[dir];
int m_idx = cave->squares[y][x].mon;
struct monster *mon = cave_monster(cave, m_idx);
bool alterable = (square_isknowntrap(cave, y, x) ||
square_iscloseddoor(cave, y, x));
/* Attack monsters, alter traps/doors on movement, hit obstacles or move */
if (m_idx > 0) {
/* Mimics surprise the player */
if (is_mimicking(mon)) {
become_aware(mon);
/* Mimic wakes up */
mon_clear_timed(mon, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE, false);
} else {
py_attack(y, x);
}
} else if (disarm && square_isknown(cave, y, x) && alterable) {
/* Auto-repeat if not already repeating */
if (cmd_get_nrepeats() == 0)
cmd_set_repeat(99);
do_cmd_alter_aux(dir);
} else if (player->upkeep->running && square_isknowntrap(cave, y, x)) {
/* Stop running before known traps */
disturb(player, 0);
} else if (!square_ispassable(cave, y, x)) {
disturb(player, 0);
/* Notice unknown obstacles, mention known obstacles */
if (!square_isknown(cave, y, x)) {
if (square_isrubble(cave, y, x)) {
msgt(MSG_HITWALL,
"You feel a pile of rubble blocking your way.");
square_memorize(cave, y, x);
square_light_spot(cave, y, x);
} else if (square_iscloseddoor(cave, y, x)) {
msgt(MSG_HITWALL, "You feel a door blocking your way.");
square_memorize(cave, y, x);
square_light_spot(cave, y, x);
} else {
msgt(MSG_HITWALL, "You feel a wall blocking your way.");
square_memorize(cave, y, x);
square_light_spot(cave, y, x);
}
} else {
if (square_isrubble(cave, y, x))
msgt(MSG_HITWALL,
"There is a pile of rubble blocking your way.");
else if (square_iscloseddoor(cave, y, x))
msgt(MSG_HITWALL, "There is a door blocking your way.");
else
msgt(MSG_HITWALL, "There is a wall blocking your way.");
}
} else {
/* Move player */
monster_swap(player->py, player->px, y, x);
/* Handle store doors, or notice objects */
if (square_isshop(cave, y, x)) {
disturb(player, 0);
event_signal(EVENT_ENTER_STORE);
event_remove_handler_type(EVENT_ENTER_STORE);
event_signal(EVENT_USE_STORE);
event_remove_handler_type(EVENT_USE_STORE);
event_signal(EVENT_LEAVE_STORE);
event_remove_handler_type(EVENT_LEAVE_STORE);
} else {
square_know_pile(cave, y, x);
cmdq_push(CMD_AUTOPICKUP);
}
/* Discover invisible traps, set off visible ones */
if (square_issecrettrap(cave, y, x)) {
disturb(player, 0);
hit_trap(y, x);
} else if (square_isknowntrap(cave, y, x)) {
disturb(player, 0);
hit_trap(y, x);
}
/* Update view and search */
update_view(cave, player);
search();
}
player->upkeep->running_firststep = false;
}
/*
* Choose a "safe" location near a monster for it to run toward.
*
* A location is "safe" if it can be reached quickly and the player
* is not able to fire into it (it isn't a "clean shot"). So, this will
* cause monsters to "duck" behind walls. Hopefully, monsters will also
* try to run towards corridor openings if they are in a room.
*
* This function may take lots of CPU time if lots of monsters are fleeing.
*
* Return TRUE if a safe location is available.
*/
static bool find_safety(struct chunk *c, struct monster *m_ptr)
{
int fy = m_ptr->fy;
int fx = m_ptr->fx;
int py = player->py;
int px = player->px;
int i, y, x, dy, dx, d, dis;
int gy = 0, gx = 0, gdis = 0;
const int *y_offsets;
const int *x_offsets;
/* Start with adjacent locations, spread further */
for (d = 1; d < 10; d++)
{
/* Get the lists of points with a distance d from (fx, fy) */
y_offsets = dist_offsets_y[d];
x_offsets = dist_offsets_x[d];
/* Check the locations */
for (i = 0, dx = x_offsets[0], dy = y_offsets[0];
dx != 0 || dy != 0;
i++, dx = x_offsets[i], dy = y_offsets[i])
{
y = fy + dy;
x = fx + dx;
/* Skip illegal locations */
if (!square_in_bounds_fully(cave, y, x)) continue;
/* Skip locations in a wall */
if (!square_ispassable(cave, y, x)) continue;
/* Ignore grids very far from the player */
if (c->squares[y][x].when < c->squares[py][px].when) continue;
/* Ignore too-distant grids */
if (c->squares[y][x].cost > c->squares[fy][fx].cost + 2 * d) continue;
/* Check for absence of shot (more or less) */
if (!player_has_los_bold(y,x))
{
/* Calculate distance from player */
dis = distance(y, x, py, px);
/* Remember if further than previous */
if (dis > gdis)
{
gy = y;
gx = x;
gdis = dis;
}
}
}
/* Check for success */
if (gdis > 0)
{
/* Good location */
m_ptr->ty = gy;
m_ptr->tx = gx;
/* Found safe place */
return (TRUE);
}
}
/* No safe place */
return (FALSE);
}
/**
* Choose "logical" directions for monster movement
*/
static bool get_moves(struct chunk *c, struct monster *mon, int *dir)
{
int py = player->py;
int px = player->px;
int y, x;
/* Monsters will run up to z_info->flee_range grids out of sight */
int flee_range = z_info->max_sight + z_info->flee_range;
bool done = false;
/* Calculate range */
find_range(mon);
/* Flow towards the player */
if (get_moves_flow(c, mon)) {
/* Extract the "pseudo-direction" */
y = mon->ty - mon->fy;
x = mon->tx - mon->fx;
} else {
/* Head straight for the player */
y = player->py - mon->fy;
x = player->px - mon->fx;
}
/* Normal animal packs try to get the player out of corridors. */
if (rf_has(mon->race->flags, RF_GROUP_AI) &&
!flags_test(mon->race->flags, RF_SIZE, RF_PASS_WALL, RF_KILL_WALL,
FLAG_END)) {
int i, open = 0;
/* Count empty grids next to player */
for (i = 0; i < 8; i++) {
int ry = py + ddy_ddd[i];
int rx = px + ddx_ddd[i];
/* Check grid around the player for room interior (room walls count)
* or other empty space */
if (square_ispassable(c, ry, rx) || square_isroom(c, ry, rx)) {
/* One more open grid */
open++;
}
}
/* Not in an empty space and strong player */
if ((open < 7) && (player->chp > player->mhp / 2)) {
/* Find hiding place */
if (find_hiding(c, mon)) {
done = true;
y = mon->ty - mon->fy;
x = mon->tx - mon->fx;
}
}
}
/* Apply fear */
if (!done && (mon->min_range == flee_range)) {
/* Try to find safe place */
if (!find_safety(c, mon)) {
/* Just leg it away from the player */
y = (-y);
x = (-x);
} else {
/* Set a course for the safe place */
get_moves_fear(c, mon);
y = mon->ty - mon->fy;
x = mon->tx - mon->fx;
}
done = true;
}
/* Monster groups try to surround the player */
if (!done && rf_has(mon->race->flags, RF_GROUP_AI)) {
int i, yy = mon->ty, xx = mon->tx;
/* If we are not already adjacent */
if (mon->cdis > 1) {
/* Find an empty square near the player to fill */
int tmp = randint0(8);
for (i = 0; i < 8; i++) {
/* Pick squares near player (pseudo-randomly) */
yy = py + ddy_ddd[(tmp + i) & 7];
xx = px + ddx_ddd[(tmp + i) & 7];
/* Ignore filled grids */
if (!square_isempty(cave, yy, xx)) continue;
/* Try to fill this hole */
break;
}
}
/* Extract the new "pseudo-direction" */
y = yy - mon->fy;
x = xx - mon->fx;
}
/* Check for no move */
if (!x && !y) return (false);
/* Pick the correct direction */
*dir = choose_direction(y, x);
/* Want to move */
return (true);
}
/**
* Choose "logical" directions for monster movement
*/
static bool get_move(struct chunk *c, struct monster *mon, int *dir, bool *good)
{
struct loc decoy = cave_find_decoy(c);
struct loc target = (decoy.y && decoy.x) ? decoy :
loc(player->px, player->py);
int y, x;
/* Monsters will run up to z_info->flee_range grids out of sight */
int flee_range = z_info->max_sight + z_info->flee_range;
bool done = false;
/* Calculate range */
get_move_find_range(mon);
/* Assume we're heading towards the player */
if (get_move_advance(c, mon)) {
/* Extract the "pseudo-direction" */
y = mon->target.grid.y - mon->fy;
x = mon->target.grid.x - mon->fx;
*good = true;
} else {
/* Head blindly straight for the "player" if there's no better idea */
y = target.y - mon->fy;
x = target.x - mon->fx;
}
/* Normal animal packs try to get the player out of corridors. */
if (rf_has(mon->race->flags, RF_GROUP_AI) &&
!flags_test(mon->race->flags, RF_SIZE, RF_PASS_WALL, RF_KILL_WALL,
FLAG_END)) {
int i, open = 0;
/* Count empty grids next to player */
for (i = 0; i < 8; i++) {
int ry = target.y + ddy_ddd[i];
int rx = target.x + ddx_ddd[i];
/* Check grid around the player for room interior (room walls count)
* or other empty space */
if (square_ispassable(c, ry, rx) || square_isroom(c, ry, rx)) {
/* One more open grid */
open++;
}
}
/* Not in an empty space and strong player */
if ((open < 5) && (player->chp > player->mhp / 2)) {
/* Find hiding place */
if (get_move_find_hiding(c, mon)) {
done = true;
y = mon->target.grid.y - mon->fy;
x = mon->target.grid.x - mon->fx;
}
}
}
/* Apply fear */
if (!done && (mon->min_range == flee_range)) {
/* Try to find safe place */
if (!get_move_find_safety(c, mon)) {
/* Just leg it away from the player */
y = (-y);
x = (-x);
} else {
/* Set a course for the safe place */
get_move_flee(c, mon);
y = mon->target.grid.y - mon->fy;
x = mon->target.grid.x - mon->fx;
}
done = true;
}
/* Monster groups try to surround the player */
if (!done && rf_has(mon->race->flags, RF_GROUP_AI) &&
square_isview(c, mon->fy, mon->fx)) {
int i, yy = mon->target.grid.y, xx = mon->target.grid.x;
/* If we are not already adjacent */
if (mon->cdis > 1) {
/* Find an empty square near the player to fill */
int tmp = randint0(8);
for (i = 0; i < 8; i++) {
/* Pick squares near player (pseudo-randomly) */
yy = target.y + ddy_ddd[(tmp + i) & 7];
xx = target.x + ddx_ddd[(tmp + i) & 7];
/* Ignore filled grids */
if (!square_isempty(c, yy, xx)) continue;
/* Try to fill this hole */
break;
}
}
/* Extract the new "pseudo-direction" */
y = yy - mon->fy;
x = xx - mon->fx;
}
/* Check if the monster has already reached its target */
if (!x && !y) return (false);
/* Pick the correct direction */
*dir = get_move_choose_direction(y, x);
/* Want to move */
return (true);
}
/**
* Work out if a monster can move through the grid, if necessary bashing
* down doors in the way.
*
* Returns true if the monster is able to move through the grid.
*/
static bool monster_turn_can_move(struct chunk *c, struct monster *mon,
const char *m_name, int nx, int ny, bool *did_something)
{
struct monster_lore *lore = get_lore(mon->race);
/* Dangerous terrain in the way */
if (monster_hates_grid(c, mon, ny, nx)) {
return false;
}
/* Floor is open? */
if (square_ispassable(c, ny, nx)) {
return true;
}
/* Permanent wall in the way */
if (square_iswall(c, ny, nx) && square_isperm(c, ny, nx)) {
return false;
}
/* Normal wall, door, or secret door in the way */
/* There's some kind of feature in the way, so learn about
* kill-wall and pass-wall now */
if (monster_is_visible(mon)) {
rf_on(lore->flags, RF_PASS_WALL);
rf_on(lore->flags, RF_KILL_WALL);
}
/* Monster may be able to deal with walls and doors */
if (rf_has(mon->race->flags, RF_PASS_WALL)) {
return true;
} else if (rf_has(mon->race->flags, RF_KILL_WALL)) {
/* Remove the wall */
square_destroy_wall(c, ny, nx);
/* Note changes to viewable region */
if (square_isview(c, ny, nx))
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
return true;
} else if (square_iscloseddoor(c, ny, nx) ||
square_issecretdoor(c, ny, nx)) {
bool can_open = rf_has(mon->race->flags, RF_OPEN_DOOR);
bool can_bash = rf_has(mon->race->flags, RF_BASH_DOOR);
bool will_bash = false;
/* Take a turn */
*did_something = true;
/* Learn about door abilities */
if (monster_is_visible(mon)) {
rf_on(lore->flags, RF_OPEN_DOOR);
rf_on(lore->flags, RF_BASH_DOOR);
}
/* If creature can open or bash doors, make a choice */
if (can_open) {
/* Sometimes bash anyway (impatient) */
if (can_bash) {
will_bash = one_in_(2) ? true : false;
}
} else if (can_bash) {
/* Only choice */
will_bash = true;
} else {
/* Door is an insurmountable obstacle */
return false;
}
/* Now outcome depends on type of door */
if (square_islockeddoor(c, ny, nx)) {
/* Locked door -- test monster strength against door strength */
int k = square_door_power(c, ny, nx);
if (randint0(mon->hp / 10) > k) {
if (will_bash) {
msg("%s slams against the door.", m_name);
} else {
msg("%s fiddles with the lock.", m_name);
}
/* Reduce the power of the door by one */
square_set_door_lock(c, ny, nx, k - 1);
}
} else {
/* Closed or secret door -- always open or bash */
if (square_isview(c, ny, nx))
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
if (will_bash) {
square_smash_door(c, ny, nx);
msg("You hear a door burst open!");
disturb(player, 0);
/* Fall into doorway */
return true;
} else {
square_open_door(c, ny, nx);
}
}
}
return false;
}
/**
* Choose a "safe" location near a monster for it to run toward.
*
* A location is "safe" if it can be reached quickly and the player
* is not able to fire into it (it isn't a "clean shot"). So, this will
* cause monsters to "duck" behind walls. Hopefully, monsters will also
* try to run towards corridor openings if they are in a room.
*
* This function may take lots of CPU time if lots of monsters are fleeing.
*
* Return true if a safe location is available.
*/
static bool find_safety(struct chunk *c, struct monster *mon)
{
int fy = mon->fy;
int fx = mon->fx;
int py = player->py;
int px = player->px;
int i, y, x, dy, dx, d, dis;
int gy = 0, gx = 0, gdis = 0;
const int *y_offsets;
const int *x_offsets;
/* Start with adjacent locations, spread further */
for (d = 1; d < 10; d++) {
/* Get the lists of points with a distance d from (fx, fy) */
y_offsets = dist_offsets_y[d];
x_offsets = dist_offsets_x[d];
/* Check the locations */
for (i = 0, dx = x_offsets[0], dy = y_offsets[0];
dx != 0 || dy != 0;
i++, dx = x_offsets[i], dy = y_offsets[i]) {
y = fy + dy;
x = fx + dx;
/* Skip illegal locations */
if (!square_in_bounds_fully(c, y, x)) continue;
/* Skip locations in a wall */
if (!square_ispassable(c, y, x)) continue;
/* Ignore grids very far from the player */
if (c->squares[y][x].scent < c->squares[py][px].scent) continue;
/* Ignore too-distant grids */
if (c->squares[y][x].noise > c->squares[fy][fx].noise + 2 * d)
continue;
/* Ignore lava if they can't handle the heat */
if (square_isfiery(c, y, x) &&
!rf_has(mon->race->flags, RF_IM_FIRE))
continue;
/* Check for absence of shot (more or less) */
if (!square_isview(c, y, x)) {
/* Calculate distance from player */
dis = distance(y, x, py, px);
/* Remember if further than previous */
if (dis > gdis) {
gy = y;
gx = x;
gdis = dis;
}
}
}
/* Check for success */
if (gdis > 0) {
/* Good location */
mon->ty = gy;
mon->tx = gx;
/* Found safe place */
return (true);
}
}
/* No safe place */
return (false);
}
/**
* Take one step along the current "run" path
*
* Called with a real direction to begin a new run, and with zero
* to continue a run in progress.
*/
void run_step(int dir)
{
int x, y;
/* Start or continue run */
if (dir) {
/* Initialize */
run_init(dir);
/* Hack -- Set the run counter */
player->upkeep->running = 1000;
/* Calculate torch radius */
player->upkeep->update |= (PU_TORCH);
} else {
/* Continue running */
if (!player->upkeep->running_withpathfind) {
/* Update regular running */
if (run_test()) {
/* Disturb */
disturb(player, 0);
return;
}
} else {
/* Pathfinding */
if (pf_result_index < 0) {
/* Abort if the path is finished */
disturb(player, 0);
player->upkeep->running_withpathfind = FALSE;
return;
} else if (pf_result_index == 0) {
/* Abort if we would hit a wall */
y = player->py + ddy[pf_result[pf_result_index] - '0'];
x = player->px + ddx[pf_result[pf_result_index] - '0'];
/* Known wall */
if (square_ismark(cave, y, x) &&
!square_ispassable(cave, y, x)) {
disturb(player, 0);
player->upkeep->running_withpathfind = FALSE;
return;
}
} else if (pf_result_index > 0) {
/* If the player has computed a path that is going to end up
* in a wall, we notice this and convert to a normal run. This
* allows us to click on unknown areas to explore the map.
*
* We have to look ahead two, otherwise we don't know which is
* the last direction moved and don't initialise the run
* properly. */
y = player->py + ddy[pf_result[pf_result_index] - '0'];
x = player->px + ddx[pf_result[pf_result_index] - '0'];
/* Known wall */
if (square_ismark(cave, y, x) &&
!square_ispassable(cave, y, x)) {
disturb(player, 0);
player->upkeep->running_withpathfind = FALSE;
return;
}
/* Get step after */
y = y + ddy[pf_result[pf_result_index - 1] - '0'];
x = x + ddx[pf_result[pf_result_index - 1] - '0'];
/* Known wall, so run the direction we were going */
if (square_ismark(cave, y, x) &&
!square_ispassable(cave, y, x)) {
player->upkeep->running_withpathfind = FALSE;
run_init(pf_result[pf_result_index] - '0');
}
}
/* Now actually run the step if we're still going */
run_cur_dir = pf_result[pf_result_index--] - '0';
}
}
/* Decrease counter if it hasn't been cancelled */
if (player->upkeep->running)
player->upkeep->running--;
/* Take time */
player->upkeep->energy_use = z_info->move_energy;
/* Move the player */
move_player(run_cur_dir, TRUE);
/* Prepare the next step */
if (player->upkeep->running) {
cmdq_push(CMD_RUN);
cmd_set_arg_direction(cmdq_peek(), "direction", 0);
}
}
/**
* Work out if a monster can move through the grid, if necessary bashing
* down doors in the way.
*
* Returns true if the monster is able to move through the grid.
*/
static bool process_monster_can_move(struct chunk *c, struct monster *mon,
const char *m_name, int nx, int ny, bool *did_something)
{
struct monster_lore *lore = get_lore(mon->race);
/* Only fiery creatures can handle lava */
if (square_isfiery(c, ny, nx) && !rf_has(mon->race->flags, RF_IM_FIRE))
return false;
/* Floor is open? */
if (square_ispassable(c, ny, nx))
return true;
/* Permanent wall in the way */
if (square_iswall(c, ny, nx) && square_isperm(c, ny, nx))
return false;
/* Normal wall, door, or secret door in the way */
/* There's some kind of feature in the way, so learn about
* kill-wall and pass-wall now */
if (mflag_has(mon->mflag, MFLAG_VISIBLE)) {
rf_on(lore->flags, RF_PASS_WALL);
rf_on(lore->flags, RF_KILL_WALL);
}
/* Monster may be able to deal with walls and doors */
if (rf_has(mon->race->flags, RF_PASS_WALL)) {
return true;
} else if (rf_has(mon->race->flags, RF_KILL_WALL)) {
/* Remove the wall */
square_destroy_wall(c, ny, nx);
/* Note changes to viewable region */
if (square_isview(c, ny, nx))
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
/* Fully update the flow since terrain changed */
player->upkeep->update |= (PU_FORGET_FLOW | PU_UPDATE_FLOW);
return true;
} else if (square_iscloseddoor(c, ny, nx) ||
square_issecretdoor(c, ny, nx)) {
bool may_bash = rf_has(mon->race->flags, RF_BASH_DOOR) && one_in_(2);
/* Take a turn */
*did_something = true;
/* Learn about door abilities */
if (mflag_has(mon->mflag, MFLAG_VISIBLE)) {
rf_on(lore->flags, RF_OPEN_DOOR);
rf_on(lore->flags, RF_BASH_DOOR);
}
/* Creature can open or bash doors */
if (!rf_has(mon->race->flags, RF_OPEN_DOOR) &&
!rf_has(mon->race->flags, RF_BASH_DOOR))
return false;
/* Stuck door -- try to unlock it */
if (square_islockeddoor(c, ny, nx)) {
int k = square_door_power(c, ny, nx);
if (randint0(mon->hp / 10) > k) {
if (may_bash)
msg("%s slams against the door.", m_name);
else
msg("%s fiddles with the lock.", m_name);
/* Reduce the power of the door by one */
square_set_door_lock(c, ny, nx, k - 1);
}
} else {
/* Handle viewable doors */
if (square_isview(c, ny, nx))
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
/* Closed or secret door -- open or bash if allowed */
if (may_bash) {
square_smash_door(c, ny, nx);
msg("You hear a door burst open!");
disturb(player, 0);
/* Fall into doorway */
return true;
} else if (rf_has(mon->race->flags, RF_OPEN_DOOR)) {
square_open_door(c, ny, nx);
}
}
}
return false;
}
/**
* Choose a "safe" location near a monster for it to run toward.
*
* A location is "safe" if it can be reached quickly and the player
* is not able to fire into it (it isn't a "clean shot"). So, this will
* cause monsters to "duck" behind walls. Hopefully, monsters will also
* try to run towards corridor openings if they are in a room.
*
* This function may take lots of CPU time if lots of monsters are fleeing.
*
* Return true if a safe location is available.
*/
static bool get_move_find_safety(struct chunk *c, struct monster *mon)
{
int fy = mon->fy;
int fx = mon->fx;
int py = player->py;
int px = player->px;
int i, y, x, dy, dx, d, dis;
int gy = 0, gx = 0, gdis = 0;
const int *y_offsets;
const int *x_offsets;
/* Start with adjacent locations, spread further */
for (d = 1; d < 10; d++) {
/* Get the lists of points with a distance d from (fx, fy) */
y_offsets = dist_offsets_y[d];
x_offsets = dist_offsets_x[d];
/* Check the locations */
for (i = 0, dx = x_offsets[0], dy = y_offsets[0];
dx != 0 || dy != 0;
i++, dx = x_offsets[i], dy = y_offsets[i]) {
y = fy + dy;
x = fx + dx;
/* Skip illegal locations */
if (!square_in_bounds_fully(c, y, x)) continue;
/* Skip locations in a wall */
if (!square_ispassable(c, y, x)) continue;
/* Ignore too-distant grids */
if (c->noise.grids[y][x] > c->noise.grids[fy][fx] + 2 * d)
continue;
/* Ignore damaging terrain if they can't handle it */
if (square_isdamaging(c, y, x) &&
!rf_has(mon->race->flags, square_feat(c, y, x)->resist_flag))
continue;
/* Check for absence of shot (more or less) */
if (!square_isview(c, y, x)) {
/* Calculate distance from player */
dis = distance(loc(x, y), loc(px, py));
/* Remember if further than previous */
if (dis > gdis) {
gy = y;
gx = x;
gdis = dis;
}
}
}
/* Check for success */
if (gdis > 0) {
/* Good location */
mon->target.grid = loc(gx, gy);
return (true);
}
}
/* No safe place */
return (false);
}
/**
* Update the current "run" path
*
* Return TRUE if the running should be stopped
*/
static bool run_test(void)
{
int py = player->py;
int px = player->px;
int prev_dir;
int new_dir;
int row, col;
int i, max, inv;
int option, option2;
/* No options yet */
option = 0;
option2 = 0;
/* Where we came from */
prev_dir = run_old_dir;
/* Range of newly adjacent grids */
max = (prev_dir & 0x01) + 1;
/* Look at every newly adjacent square. */
for (i = -max; i <= max; i++) {
struct object *obj;
/* New direction */
new_dir = cycle[chome[prev_dir] + i];
/* New location */
row = py + ddy[new_dir];
col = px + ddx[new_dir];
/* Visible monsters abort running */
if (cave->squares[row][col].mon > 0) {
monster_type *m_ptr = square_monster(cave, row, col);
/* Visible monster */
if (mflag_has(m_ptr->mflag, MFLAG_VISIBLE)) return (TRUE);
}
/* Visible objects abort running */
for (obj = square_object(cave, row, col); obj; obj = obj->next)
/* Visible object */
if (obj->marked && !ignore_item_ok(obj)) return (TRUE);
/* Assume unknown */
inv = TRUE;
/* Check memorized grids */
if (square_ismark(cave, row, col)) {
bool notice = square_noticeable(cave, row, col);
/* Interesting feature */
if (notice) return (TRUE);
/* The grid is "visible" */
inv = FALSE;
}
/* Analyze unknown grids and floors */
if (inv || square_ispassable(cave, row, col)) {
/* Looking for open area */
if (run_open_area) {
/* Nothing */
} else if (!option) {
/* The first new direction. */
option = new_dir;
} else if (option2) {
/* Three new directions. Stop running. */
return (TRUE);
} else if (option != cycle[chome[prev_dir] + i - 1]) {
/* Two non-adjacent new directions. Stop running. */
return (TRUE);
} else if (new_dir & 0x01) {
/* Two new (adjacent) directions (case 1) */
option2 = new_dir;
} else {
/* Two new (adjacent) directions (case 2) */
option2 = option;
option = new_dir;
}
} else { /* Obstacle, while looking for open area */
if (run_open_area) {
if (i < 0) {
/* Break to the right */
run_break_right = TRUE;
} else if (i > 0) {
/* Break to the left */
run_break_left = TRUE;
}
}
}
}
/* Look at every soon to be newly adjacent square. */
for (i = -max; i <= max; i++) {
/* New direction */
new_dir = cycle[chome[prev_dir] + i];
/* New location */
row = py + ddy[prev_dir] + ddy[new_dir];
col = px + ddx[prev_dir] + ddx[new_dir];
/* HACK: Ugh. Sometimes we come up with illegal bounds. This will
* treat the symptom but not the disease. */
if (row >= cave->height || col >= cave->width) continue;
if (row < 0 || col < 0) continue;
/* Visible monsters abort running */
if (cave->squares[row][col].mon > 0) {
monster_type *m_ptr = square_monster(cave, row, col);
/* Visible monster */
if (mflag_has(m_ptr->mflag, MFLAG_VISIBLE) && !is_mimicking(m_ptr))
return (TRUE);
}
}
/* Looking for open area */
if (run_open_area) {
/* Hack -- look again */
for (i = -max; i < 0; i++) {
new_dir = cycle[chome[prev_dir] + i];
row = py + ddy[new_dir];
col = px + ddx[new_dir];
/* Unknown grid or non-wall */
/* Was: square_ispassable(cave, row, col) */
if (!square_ismark(cave, row, col) ||
(square_ispassable(cave, row, col))) {
/* Looking to break right */
if (run_break_right) {
return (TRUE);
}
} else { /* Obstacle */
/* Looking to break left */
if (run_break_left) {
return (TRUE);
}
}
}
/* Hack -- look again */
for (i = max; i > 0; i--) {
new_dir = cycle[chome[prev_dir] + i];
row = py + ddy[new_dir];
col = px + ddx[new_dir];
/* Unknown grid or non-wall */
/* Was: square_ispassable(cave, row, col) */
if (!square_ismark(cave, row, col) ||
(square_ispassable(cave, row, col))) {
/* Looking to break left */
if (run_break_left) {
return (TRUE);
}
} else { /* Obstacle */
/* Looking to break right */
if (run_break_right) {
return (TRUE);
}
}
}
} else { /* Not looking for open area */
/* No options */
if (!option) {
return (TRUE);
} else if (!option2) { /* One option */
/* Primary option */
run_cur_dir = option;
/* No other options */
run_old_dir = option;
} else { /* Two options, examining corners */
/* Primary option */
run_cur_dir = option;
/* Hack -- allow curving */
run_old_dir = option2;
}
}
/* About to hit a known wall, stop */
if (see_wall(run_cur_dir, py, px))
return (TRUE);
/* Failure */
return (FALSE);
}
/**
* Work out if a monster can move through the grid, if necessary bashing
* down doors in the way.
*
* Returns TRUE if the monster is able to move through the grid.
*/
static bool process_monster_can_move(struct chunk *c, struct monster *m_ptr,
const char *m_name, int nx, int ny, bool *did_something)
{
monster_lore *l_ptr = get_lore(m_ptr->race);
/* Floor is open? */
if (square_ispassable(c, ny, nx))
return TRUE;
/* Permanent wall in the way */
if (square_iswall(c, ny, nx) && square_isperm(c, ny, nx))
return FALSE;
/* Normal wall, door, or secret door in the way */
/* There's some kind of feature in the way, so learn about
* kill-wall and pass-wall now */
if (mflag_has(m_ptr->mflag, MFLAG_VISIBLE)) {
rf_on(l_ptr->flags, RF_PASS_WALL);
rf_on(l_ptr->flags, RF_KILL_WALL);
}
/* Monster moves through walls (and doors) */
if (rf_has(m_ptr->race->flags, RF_PASS_WALL))
return TRUE;
/* Monster destroys walls (and doors) */
else if (rf_has(m_ptr->race->flags, RF_KILL_WALL)) {
/* Forget the wall */
sqinfo_off(c->squares[ny][nx].info, SQUARE_MARK);
/* Notice */
square_destroy_wall(c, ny, nx);
/* Note changes to viewable region */
if (player_has_los_bold(ny, nx))
player->upkeep->update |= PU_UPDATE_VIEW;
/* Update the flow, since walls affect flow */
player->upkeep->update |= PU_UPDATE_FLOW;
return TRUE;
}
/* Handle doors and secret doors */
else if (square_iscloseddoor(c, ny, nx) || square_issecretdoor(c, ny, nx)) {
bool may_bash = rf_has(m_ptr->race->flags, RF_BASH_DOOR) && one_in_(2);
/* Take a turn */
*did_something = TRUE;
/* Learn about door abilities */
if (mflag_has(m_ptr->mflag, MFLAG_VISIBLE)) {
rf_on(l_ptr->flags, RF_OPEN_DOOR);
rf_on(l_ptr->flags, RF_BASH_DOOR);
}
/* Creature can open or bash doors */
if (!rf_has(m_ptr->race->flags, RF_OPEN_DOOR) && !rf_has(m_ptr->race->flags, RF_BASH_DOOR))
return FALSE;
/* Stuck door -- try to unlock it */
if (square_islockeddoor(c, ny, nx)) {
int k = square_door_power(c, ny, nx);
if (randint0(m_ptr->hp / 10) > k) {
if (may_bash)
msg("%s slams against the door.", m_name);
else
msg("%s fiddles with the lock.", m_name);
/* Reduce the power of the door by one */
square_set_door_lock(c, ny, nx, k - 1);
}
} else {
/* Handle viewable doors */
if (player_has_los_bold(ny, nx))
player->upkeep->update |= PU_UPDATE_VIEW;
/* Closed or secret door -- open or bash if allowed */
if (may_bash) {
square_smash_door(c, ny, nx);
msg("You hear a door burst open!");
disturb(player, 0);
/* Fall into doorway */
return TRUE;
} else if (rf_has(m_ptr->race->flags, RF_OPEN_DOOR)) {
square_open_door(c, ny, nx);
}
}
}
return FALSE;
}
/* Destroy walls (and doors) */
static void project_feature_handler_KILL_WALL(project_feature_handler_context_t *context)
{
const int x = context->x;
const int y = context->y;
/* Non-walls (etc) */
if (square_ispassable(cave, y, x)) return;
/* Permanent walls */
if (square_isperm(cave, y, x)) return;
/* Different treatment for different walls */
if (square_iswall(cave, y, x) && !square_hasgoldvein(cave, y, x)) {
/* Message */
if (square_isseen(cave, y, x)) {
msg("The wall turns into mud!");
context->obvious = true;
/* Forget the wall */
square_forget(cave, y, x);
}
/* Destroy the wall */
square_destroy_wall(cave, y, x);
} else if (square_iswall(cave, y, x) && square_hasgoldvein(cave, y, x)) {
/* Message */
if (square_isseen(cave, y, x)) {
msg("The vein turns into mud!");
msg("You have found something!");
context->obvious = true;
/* Forget the wall */
square_forget(cave, y, x);
}
/* Destroy the wall */
square_destroy_wall(cave, y, x);
/* Place some gold */
place_gold(cave, y, x, player->depth, ORIGIN_FLOOR);
} else if (square_ismagma(cave, y, x) || square_isquartz(cave, y, x)) {
/* Message */
if (square_isseen(cave, y, x)) {
msg("The vein turns into mud!");
context->obvious = true;
/* Forget the wall */
square_forget(cave, y, x);
}
/* Destroy the wall */
square_destroy_wall(cave, y, x);
} else if (square_isrubble(cave, y, x)) {
/* Message */
if (square_isseen(cave, y, x)) {
msg("The rubble turns into mud!");
context->obvious = true;
/* Forget the wall */
square_forget(cave, y, x);
}
/* Destroy the rubble */
square_destroy_rubble(cave, y, x);
/* Hack -- place an object */
if (randint0(100) < 10){
if (square_isseen(cave, y, x)) {
msg("There was something buried in the rubble!");
context->obvious = true;
}
place_object(cave, y, x, player->depth, false, false,
ORIGIN_RUBBLE, 0);
}
} else if (square_isdoor(cave, y, x)) {
/* Hack -- special message */
if (square_isseen(cave, y, x)) {
msg("The door turns into mud!");
context->obvious = true;
/* Forget the wall */
square_forget(cave, y, x);
}
/* Destroy the feature */
square_destroy_door(cave, y, x);
}
/* Update the visuals */
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
/* Fully update the flow */
player->upkeep->update |= (PU_FORGET_FLOW | PU_UPDATE_FLOW);
}
/**
* This is a helper function used by do_cmd_throw and do_cmd_fire.
*
* It abstracts out the projectile path, display code, identify and clean up
* logic, while using the 'attack' parameter to do work particular to each
* kind of attack.
*/
static void ranged_helper(struct object *obj, int dir, int range, int shots,
ranged_attack attack)
{
int i, j;
char o_name[80];
int path_n;
struct loc path_g[256];
/* Start at the player */
int x = player->px;
int y = player->py;
/* Predict the "target" location */
int ty = y + 99 * ddy[dir];
int tx = x + 99 * ddx[dir];
bool hit_target = FALSE;
bool none_left = FALSE;
struct object *missile;
/* Check for target validity */
if ((dir == 5) && target_okay()) {
int taim;
target_get(&tx, &ty);
taim = distance(y, x, ty, tx);
if (taim > range) {
char msg[80];
strnfmt(msg, sizeof(msg),
"Target out of range by %d squares. Fire anyway? ",
taim - range);
if (!get_check(msg)) return;
}
}
/* Sound */
sound(MSG_SHOOT);
/* Describe the object */
object_desc(o_name, sizeof(o_name), obj, ODESC_FULL | ODESC_SINGULAR);
/* Actually "fire" the object -- Take a partial turn */
player->upkeep->energy_use = (z_info->move_energy / shots);
/* Calculate the path */
path_n = project_path(path_g, range, y, x, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff(player);
/* Start at the player */
x = player->px;
y = player->py;
/* Project along the path */
for (i = 0; i < path_n; ++i) {
struct monster *mon = NULL;
int ny = path_g[i].y;
int nx = path_g[i].x;
bool see = square_isseen(cave, ny, nx);
/* Stop before hitting walls */
if (!(square_ispassable(cave, ny, nx)) &&
!(square_isprojectable(cave, ny, nx)))
break;
/* Advance */
x = nx;
y = ny;
/* Tell the UI to display the missile */
event_signal_missile(EVENT_MISSILE, obj, see, y, x);
/* Try the attack on the monster at (x, y) if any */
mon = square_monster(cave, y, x);
if (mon) {
int visible = mflag_has(mon->mflag, MFLAG_VISIBLE);
bool fear = FALSE;
const char *note_dies = monster_is_unusual(mon->race) ?
" is destroyed." : " dies.";
struct attack_result result = attack(obj, y, x);
int dmg = result.dmg;
u32b msg_type = result.msg_type;
char hit_verb[20];
my_strcpy(hit_verb, result.hit_verb, sizeof(hit_verb));
mem_free(result.hit_verb);
if (result.success) {
hit_target = TRUE;
object_notice_attack_plusses(obj);
/* Learn by use for other equipped items */
equip_notice_to_hit_on_attack(player);
/* No negative damage; change verb if no damage done */
if (dmg <= 0) {
dmg = 0;
msg_type = MSG_MISS;
my_strcpy(hit_verb, "fails to harm", sizeof(hit_verb));
}
if (!visible) {
/* Invisible monster */
msgt(MSG_SHOOT_HIT, "The %s finds a mark.", o_name);
} else {
for (j = 0; j < (int)N_ELEMENTS(ranged_hit_types); j++) {
char m_name[80];
const char *dmg_text = "";
if (msg_type != ranged_hit_types[j].msg)
continue;
if (OPT(show_damage))
dmg_text = format(" (%d)", dmg);
monster_desc(m_name, sizeof(m_name), mon, MDESC_OBJE);
if (ranged_hit_types[j].text)
msgt(msg_type, "Your %s %s %s%s. %s", o_name,
hit_verb, m_name, dmg_text,
ranged_hit_types[j].text);
else
msgt(msg_type, "Your %s %s %s%s.", o_name, hit_verb,
m_name, dmg_text);
}
/* Track this monster */
if (mflag_has(mon->mflag, MFLAG_VISIBLE)) {
monster_race_track(player->upkeep, mon->race);
health_track(player->upkeep, mon);
}
}
/* Hit the monster, check for death */
if (!mon_take_hit(mon, dmg, &fear, note_dies)) {
message_pain(mon, dmg);
if (fear && mflag_has(mon->mflag, MFLAG_VISIBLE)) {
char m_name[80];
monster_desc(m_name, sizeof(m_name), mon,
MDESC_DEFAULT);
add_monster_message(m_name, mon,
MON_MSG_FLEE_IN_TERROR, TRUE);
}
}
}
/* Stop the missile */
break;
}
/* Stop if non-projectable but passable */
if (!(square_isprojectable(cave, ny, nx)))
break;
}
/* Get the missile */
if (object_is_carried(player, obj))
missile = gear_object_for_use(obj, 1, TRUE, &none_left);
else
missile = floor_object_for_use(obj, 1, TRUE, &none_left);
/* Drop (or break) near that location */
drop_near(cave, missile, breakage_chance(missile, hit_target), y, x, TRUE);
}
/**
* Take one step along the current "run" path
*
* Called with a real direction to begin a new run, and with zero
* to continue a run in progress.
*/
void run_step(int dir)
{
/* Start or continue run */
if (dir) {
/* Initialize */
run_init(dir);
/* Hack -- Set the run counter */
player->upkeep->running = 1000;
/* Calculate torch radius */
player->upkeep->update |= (PU_TORCH);
} else {
/* Continue running */
if (!player->upkeep->running_withpathfind) {
/* Update regular running */
if (run_test()) {
/* Disturb */
disturb(player, 0);
return;
}
} else if (pf_result_index < 0) {
/* Pathfinding, and the path is finished */
disturb(player, 0);
player->upkeep->running_withpathfind = false;
return;
} else {
int y = player->py + ddy[pf_result[pf_result_index] - '0'];
int x = player->px + ddx[pf_result[pf_result_index] - '0'];
if (pf_result_index == 0) {
/* Known wall */
if (square_isknown(cave, y, x) &&
!square_ispassable(cave, y, x)) {
disturb(player, 0);
player->upkeep->running_withpathfind = false;
return;
}
} else if (pf_result_index > 0) {
struct object *obj;
/* If the player has computed a path that is going to end up
* in a wall, we notice this and convert to a normal run. This
* allows us to click on unknown areas to explore the map.
*
* We have to look ahead two, otherwise we don't know which is
* the last direction moved and don't initialise the run
* properly. */
y = player->py + ddy[pf_result[pf_result_index] - '0'];
x = player->px + ddx[pf_result[pf_result_index] - '0'];
/* Known wall */
if (square_isknown(cave, y, x) &&
!square_ispassable(cave, y, x)) {
disturb(player, 0);
player->upkeep->running_withpathfind = false;
return;
}
/* Visible monsters abort running */
if (cave->squares[y][x].mon > 0) {
struct monster *mon = square_monster(cave, y, x);
/* Visible monster */
if (mflag_has(mon->mflag, MFLAG_VISIBLE)) {
disturb(player, 0);
player->upkeep->running_withpathfind = false;
return;
}
}
/* Visible objects abort running */
for (obj = square_object(cave, y, x); obj; obj = obj->next)
/* Visible object */
if (obj->known && !ignore_item_ok(obj)) {
disturb(player, 0);
player->upkeep->running_withpathfind = false;
return;
}
/* Get step after */
y = y + ddy[pf_result[pf_result_index - 1] - '0'];
x = x + ddx[pf_result[pf_result_index - 1] - '0'];
/* Known wall, so run the direction we were going */
if (square_isknown(cave, y, x) &&
!square_ispassable(cave, y, x)) {
player->upkeep->running_withpathfind = false;
run_init(pf_result[pf_result_index] - '0');
}
}
/* Now actually run the step if we're still going */
run_cur_dir = pf_result[pf_result_index--] - '0';
}
}
/* Decrease counter if it hasn't been cancelled */
if (player->upkeep->running)
player->upkeep->running--;
else if (!player->upkeep->running_withpathfind)
return;
/* Take time */
player->upkeep->energy_use = z_info->move_energy;
/* Move the player; running straight into a trap == trying to disarm */
move_player(run_cur_dir, dir ? true : false);
/* Prepare the next step */
if (player->upkeep->running) {
cmdq_push(CMD_RUN);
cmd_set_arg_direction(cmdq_peek(), "direction", 0);
}
}
/**
* Move player in the given direction.
*
* This routine should only be called when energy has been expended.
*
* Note that this routine handles monsters in the destination grid,
* and also handles attempting to move into walls/doors/rubble/etc.
*/
void move_player(int dir, bool disarm)
{
int py = player->py;
int px = player->px;
int y = py + ddy[dir];
int x = px + ddx[dir];
int m_idx = cave->squares[y][x].mon;
struct monster *mon = cave_monster(cave, m_idx);
bool alterable = (square_isknowntrap(cave, y, x) ||
square_iscloseddoor(cave, y, x));
/* Attack monsters, alter traps/doors on movement, hit obstacles or move */
if (m_idx > 0) {
/* Mimics surprise the player */
if (is_mimicking(mon)) {
become_aware(mon);
/* Mimic wakes up */
mon_clear_timed(mon, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE, false);
} else {
py_attack(y, x);
}
} else if (disarm && square_isknown(cave, y, x) && alterable) {
/* Auto-repeat if not already repeating */
if (cmd_get_nrepeats() == 0)
cmd_set_repeat(99);
do_cmd_alter_aux(dir);
} else if (player->upkeep->running && square_isknowntrap(cave, y, x)) {
/* Stop running before known traps */
disturb(player, 0);
} else if (!square_ispassable(cave, y, x)) {
/* Disturb the player */
disturb(player, 0);
/* Notice unknown obstacles, mention known obstacles */
if (!square_isknown(cave, y, x)) {
if (square_isrubble(cave, y, x)) {
msgt(MSG_HITWALL,
"You feel a pile of rubble blocking your way.");
square_memorize(cave, y, x);
square_light_spot(cave, y, x);
} else if (square_iscloseddoor(cave, y, x)) {
msgt(MSG_HITWALL, "You feel a door blocking your way.");
square_memorize(cave, y, x);
square_light_spot(cave, y, x);
} else {
msgt(MSG_HITWALL, "You feel a wall blocking your way.");
square_memorize(cave, y, x);
square_light_spot(cave, y, x);
}
} else {
if (square_isrubble(cave, y, x))
msgt(MSG_HITWALL,
"There is a pile of rubble blocking your way.");
else if (square_iscloseddoor(cave, y, x))
msgt(MSG_HITWALL, "There is a door blocking your way.");
else
msgt(MSG_HITWALL, "There is a wall blocking your way.");
}
} else {
/* See if trap detection status will change */
bool old_dtrap = square_isdtrap(cave, py, px);
bool new_dtrap = square_isdtrap(cave, y, x);
/* Note the change in the detect status */
if (old_dtrap != new_dtrap)
player->upkeep->redraw |= (PR_DTRAP);
/* Disturb player if the player is about to leave the area */
if (player->upkeep->running && !player->upkeep->running_firststep &&
old_dtrap && !new_dtrap) {
disturb(player, 0);
return;
}
/* Move player */
monster_swap(py, px, y, x);
/* New location */
y = py = player->py;
x = px = player->px;
/* Searching */
if (player->searching ||
(player->state.skills[SKILL_SEARCH_FREQUENCY] >= 50) ||
one_in_(50 - player->state.skills[SKILL_SEARCH_FREQUENCY]))
search(false);
/* Handle store doors, or notice objects */
if (square_isshop(cave, player->py, player->px)) {
/* Disturb */
disturb(player, 0);
event_signal(EVENT_ENTER_STORE);
event_remove_handler_type(EVENT_ENTER_STORE);
event_signal(EVENT_USE_STORE);
event_remove_handler_type(EVENT_USE_STORE);
event_signal(EVENT_LEAVE_STORE);
event_remove_handler_type(EVENT_LEAVE_STORE);
} else {
/* Know objects, queue autopickup */
floor_pile_know(cave, player->py, player->px);
cmdq_push(CMD_AUTOPICKUP);
}
/* Discover invisible traps, set off visible ones */
if (square_issecrettrap(cave, y, x)) {
/* Disturb */
disturb(player, 0);
/* Hit the trap. */
hit_trap(y, x);
} else if (square_isknowntrap(cave, y, x)) {
/* Disturb */
disturb(player, 0);
/* Hit the trap */
hit_trap(y, x);
}
}
player->upkeep->running_firststep = false;
}