static void _set_current_r_idx(int r_idx)
{
if (r_idx == p_ptr->current_r_idx)
return;
disturb(1, 0);
if (r_idx == MON_MIMIC && p_ptr->current_r_idx)
msg_format("You stop mimicking %s.", r_name + r_info[p_ptr->current_r_idx].name);
possessor_set_current_r_idx(r_idx);
if (r_idx != MON_MIMIC)
msg_format("You start mimicking %s.", r_name + r_info[p_ptr->current_r_idx].name);
/* Mimics shift forms often enough to be annoying if shapes
have dramatically different body types (e.g. dragons vs humanoids).
Inscribe gear with @mimic to autoequip on shifing. */
equip_shuffle("@mimic1");
equip_shuffle("@mimic2");
equip_shuffle("@mimic3");
equip_shuffle("@mimic4");
equip_shuffle("@mimic");
}
static void _cyber_move_player(void)
{
/* Cyberdemons move erratically (cf get_rep_dir()) and make a lot of noise */
if (one_in_(66))
{
int i;
cmsg_print(TERM_RED, "The dungeon trembles!");
if (disturb_minor)
disturb(0, 0);
for (i = 1; i < m_max; i++)
{
monster_type *m_ptr = &m_list[i];
if (!m_ptr->r_idx) continue;
if (m_ptr->cdis < MAX_SIGHT * 2 && MON_CSLEEP(m_ptr))
(void)set_monster_csleep(i, 0);
}
}
}
void wild_weapon_strike(void)
{
/* Note, if we get a counter slot first, then you can just regain what you lost.
So getting the power first assures you are getting something new */
int power = _get_random_power();
int slot = _get_counter();
int info = _find_type(power);
if (info >= 0)
_types[info].on_fn();
p_ptr->wild_counters[slot].type = power;
p_ptr->wild_counters[slot].counter = 2;
if (info >= 0)
{
p_ptr->redraw |= _types[info].redraw_flags;
p_ptr->update |= _types[info].update_flags;
if (disturb_state) disturb(0, 0);
handle_stuff();
}
}
/*
* Modify the current panel to the given coordinates, adjusting only to
* ensure the coordinates are legal, and return TRUE if anything done.
*
* The town should never be scrolled around.
*
* Note that monsters are no longer affected in any way by panel changes.
*
* As a total hack, whenever the current panel changes, we assume that
* the "overhead view" window should be updated.
*/
bool modify_panel(term *t, int wy, int wx)
{
int dungeon_hgt = DUNGEON_HGT;
int dungeon_wid = DUNGEON_WID;
/* Adjust for town */
if (p_ptr->depth == 0) town_adjust(&dungeon_hgt, &dungeon_wid);
/* Verify wy, adjust if needed */
if (wy > dungeon_hgt - SCREEN_HGT) wy = dungeon_hgt - SCREEN_HGT;
if (wy < 0) wy = 0;
/* Verify wx, adjust if needed */
if (wx > dungeon_wid - SCREEN_WID) wx = dungeon_wid - SCREEN_WID;
if (wx < 0) wx = 0;
/* React to changes */
if ((t->offset_y != wy) || (t->offset_x != wx))
{
/* Save wy, wx */
t->offset_y = wy;
t->offset_x = wx;
/* Redraw map */
p_ptr->redraw |= (PR_MAP);
/* Redraw for big graphics */
if ((tile_width > 1) || (tile_height > 1)) redraw_stuff();
/* Hack -- optional disturb on "panel change" */
if (OPT(disturb_panel) && !OPT(center_player)) disturb(0, 0);
/* Changed */
return (TRUE);
}
/* No change */
return (FALSE);
}
/**
* Manipulate an adjacent grid in some way
*
* Attack monsters, tunnel through walls, disarm traps, open doors.
*
* This command must always take energy, to prevent free detection
* of invisible monsters.
*
* The "semantics" of this command must be chosen before the player
* is confused, and it must be verified against the new grid.
*/
void do_cmd_alter_aux(int dir)
{
int y, x;
bool more = false;
/* Get location */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
/* Take a turn */
player->upkeep->energy_use = z_info->move_energy;
/* Apply confusion */
if (player_confuse_dir(player, &dir, false)) {
/* Get location */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
}
/* Action depends on what's there */
if (cave->squares[y][x].mon > 0)
/* Attack monsters */
py_attack(y, x);
else if (square_isdiggable(cave, y, x))
/* Tunnel through walls and rubble */
more = do_cmd_tunnel_aux(y, x);
else if (square_iscloseddoor(cave, y, x))
/* Open closed doors */
more = do_cmd_open_aux(y, x);
else if (square_isknowntrap(cave, y, x))
/* Disarm traps */
more = do_cmd_disarm_aux(y, x);
else
/* Oops */
msg("You spin around.");
/* Cancel repetition unless we can continue */
if (!more) disturb(player, 0);
}
/**
* Process a monster spell
*
* \param index is the monster spell flag (RSF_FOO)
* \param mon is the attacking monster
* \param seen is whether the player can see the monster at this moment
*/
void do_mon_spell(int index, struct monster *mon, bool seen)
{
char m_name[80];
bool ident, hits = FALSE;
/* Extract the monster level */
int rlev = ((mon->race->level >= 1) ? mon->race->level : 1);
const struct monster_spell *spell = monster_spell_by_index(index);
/* Get the monster name (or "it") */
monster_desc(m_name, sizeof(m_name), mon, MDESC_STANDARD);
/* See if it hits */
if (spell->hit == 100)
hits = TRUE;
else if (spell->hit == 0)
hits = FALSE;
else
hits = check_hit(player, spell->hit, rlev);
/* Tell the player what's going on */
disturb(player, 1);
spell_message(mon, spell, seen, hits);
if (!hits) return;
/* Try a saving throw if available */
if (spell->save_message &&
randint0(100) < player->state.skills[SKILL_SAVE]) {
msg("%s", spell->save_message);
return;
}
/* Do effects */
effect_do(spell->effect, NULL, &ident, TRUE, 0, 0, 0);
return;
}
/**
* Pick up everything on the floor that requires no player action
*/
int do_autopickup(void)
{
int py = player->py;
int px = player->px;
struct object *obj, *next;
/* Objects picked up. Used to determine time cost of command. */
byte objs_picked_up = 0;
/* Nothing to pick up -- return */
if (!square_object(cave, py, px))
return 0;
/* Always pickup gold, effortlessly */
player_pickup_gold();
/* Scan the remaining objects */
obj = square_object(cave, py, px);
while (obj) {
next = obj->next;
/* Ignore all hidden objects and non-objects */
if (!ignore_item_ok(obj)) {
/* Hack -- disturb */
disturb(player, 0);
/* Automatically pick up items into the backpack */
if (auto_pickup_okay(obj)) {
/* Pick up the object with message */
player_pickup_aux(obj, TRUE);
objs_picked_up++;
}
}
obj = next;
}
return objs_picked_up;
}
/**
* Allow for user abort during repeated commands, running and resting.
*
* This will only check during every 128th game turn while resting.
*/
void check_for_player_interrupt(game_event_type type, game_event_data *data,
void *user)
{
/* Check for "player abort" */
if (player->upkeep->running ||
cmd_get_nrepeats() > 0 ||
(player_is_resting(player) && !(turn & 0x7F))) {
ui_event e;
/* Do not wait */
inkey_scan = SCAN_INSTANT;
/* Check for a key */
e = inkey_ex();
if (e.type != EVT_NONE) {
/* Flush and disturb */
event_signal(EVENT_INPUT_FLUSH);
disturb(player, 0);
msg("Cancelled.");
}
}
}
static void _water_process_world(void)
{
int inven_ct = 0;
int equip_ct = 0;
int chance = 15;
int i;
for (i = 0; i < INVEN_TOTAL; i++)
{
object_type *o_ptr = &inventory[i];
u32b flgs[TR_FLAG_SIZE];
char o_name[MAX_NLEN];
if (!o_ptr->k_idx) continue;
if (!object_is_armour(o_ptr)) continue;
if (randint0(1000) >= chance) continue;
if (o_ptr->ac + o_ptr->to_a <= 0) continue;
object_flags(o_ptr, flgs);
if (have_flag(flgs, TR_IGNORE_ACID)) continue;
object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
msg_format("Your watery touch corrodes your %s!", o_name);
o_ptr->to_a--;
if (i >= EQUIP_BEGIN) ++equip_ct;
else ++inven_ct;
}
if (equip_ct)
{
p_ptr->update |= PU_BONUS;
p_ptr->window |= PW_EQUIP | PW_PLAYER;
}
if (equip_ct + inven_ct)
disturb(1, 0);
}
/*
* Stay still. Search. Enter stores.
* Pick up treasure if "pickup" is true.
*/
void do_cmd_hold(cmd_code code, cmd_arg args[])
{
/* Take a turn */
p_ptr->energy_use = 100;
/* Spontaneous Searching */
if ((p_ptr->state.skills[SKILL_SEARCH_FREQUENCY] >= 50) ||
one_in_(50 - p_ptr->state.skills[SKILL_SEARCH_FREQUENCY]))
{
search(FALSE);
}
/* Continuous Searching */
if (p_ptr->searching)
{
search(FALSE);
}
/* Pick things up, not using extra energy */
do_autopickup();
/* Hack -- enter a store if we are on one */
if ((cave->feat[p_ptr->py][p_ptr->px] >= FEAT_SHOP_HEAD) &&
(cave->feat[p_ptr->py][p_ptr->px] <= FEAT_SHOP_TAIL))
{
/* Disturb */
disturb(p_ptr, 0, 0);
cmd_insert(CMD_ENTER_STORE);
/* Free turn XXX XXX XXX */
p_ptr->energy_use = 0;
}
else
{
event_signal(EVENT_SEEFLOOR);
}
}
/*
* Save the game
*/
void save_game(void)
{
/* Disturb the player */
disturb(p_ptr, 1, 0);
/* Clear messages */
message_flush();
/* Handle stuff */
handle_stuff(p_ptr);
/* Message */
prt("Saving game...", 0, 0);
/* Refresh */
Term_fresh();
/* The player is not dead */
my_strcpy(p_ptr->died_from, "(saved)", sizeof(p_ptr->died_from));
/* Forbid suspend */
signals_ignore_tstp();
/* Save the player */
if (savefile_save(savefile))
prt("Saving game... done.", 0, 0);
else
prt("Saving game... failed!", 0, 0);
/* Allow suspend again */
signals_handle_tstp();
/* Refresh */
Term_fresh();
/* Note that the player is not dead */
my_strcpy(p_ptr->died_from, "(alive and well)", sizeof(p_ptr->died_from));
}
/*
* Handle abrupt death of the visual system
*
* This routine is called only in very rare situations, and only
* by certain visual systems, when they experience fatal errors.
*
* XXX XXX Hack -- clear the death flag when creating a HANGUP
* save file so that player can see tombstone when restart.
*
* TODO: Hookify
*/
void exit_game_panic(void)
{
#ifndef AVT_HOOKIFY_EXIT
/* If nothing important has happened, just quit */
if (!character_generated || character_saved) quit("panic");
#endif
/* Mega-Hack -- see "msg_print()" */
msg_flag = FALSE;
/* Clear the top line */
prt("", 0, 0);
#ifndef AVT_HOOKIFY_EXIT
/* Hack -- turn off some things */
disturb(1, 0);
/* Hack -- Delay death XXX XXX XXX */
if (p_ptr->chp < 0) p_ptr->is_dead = FALSE;
/* Hardcode panic save */
p_ptr->panic_save = 1;
#endif
/* Forbid suspend */
signals_ignore_tstp();
#ifndef AVT_HOOKIFY_EXIT
/* Indicate panic save */
strcpy(p_ptr->died_from, "(panic save)");
/* Panic save, or get worried */
if (!save_player()) quit("panic save failed!");
#endif
/* Successful panic save */
quit("panic save succeeded!");
}
/**
* Hit a trap.
*/
extern void hit_trap(int y, int x)
{
bool ident;
struct trap *trap;
struct effect *effect;
/* Count the hidden traps here */
int num = num_traps(cave, y, x, -1);
/* Oops. We've walked right into trouble. */
if (num == 1) msg("You stumble upon a trap!");
else if (num > 1) msg("You stumble upon some traps!");
/* Look at the traps in this grid */
for (trap = square_trap(cave, y, x); trap; trap = trap->next) {
/* Require that trap be capable of affecting the character */
if (!trf_has(trap->kind->flags, TRF_TRAP)) continue;
/* Disturb the player */
disturb(player, 0);
/* Fire off the trap */
effect = trap->kind->effect;
effect_do(effect, NULL, &ident, false, 0, 0, 0);
/* Trap may have gone */
if (!square_trap(cave, y, x)) break;
/* Trap becomes visible (always XXX) */
trf_on(trap->flags, TRF_VISIBLE);
square_memorize(cave, y, x);
}
/* Verify traps (remove marker if appropriate) */
(void)square_verify_trap(cave, y, x, 0);
}
/*
* Set "p_ptr->food", notice observable changes
*
* The "p_ptr->food" variable can get as large as 20000, allowing the
* addition of the most "filling" item, Elvish Waybread, which adds
* 7500 food units, without overflowing the 32767 maximum limit.
*
* Perhaps we should disturb the player with various messages,
* especially messages about hunger status changes. XXX XXX XXX
*
* Digestion of food is handled in "dungeon.c", in which, normally,
* the player digests about 20 food units per 100 game turns, more
* when "fast", more when "regenerating", less with "slow digestion".
*/
bool player_set_food(struct player *p, int v)
{
int old_aux, new_aux;
bool notice = FALSE;
/* Hack -- Force good values */
v = MIN(v, PY_FOOD_MAX);
v = MAX(v, 0);
/* Current value */
if (p->food < PY_FOOD_FAINT) old_aux = 0;
else if (p->food < PY_FOOD_WEAK) old_aux = 1;
else if (p->food < PY_FOOD_ALERT) old_aux = 2;
else if (p->food < PY_FOOD_FULL) old_aux = 3;
else old_aux = 4;
/* New value */
if (v < PY_FOOD_FAINT) new_aux = 0;
else if (v < PY_FOOD_WEAK) new_aux = 1;
else if (v < PY_FOOD_ALERT) new_aux = 2;
else if (v < PY_FOOD_FULL) new_aux = 3;
else new_aux = 4;
/* Food increase */
if (new_aux > old_aux) {
switch (new_aux) {
case 1:
msg("You are still weak.");
break;
case 2:
msg("You are still hungry.");
break;
case 3:
msg("You are no longer hungry.");
break;
case 4:
msg("You are full!");
break;
}
/* Change */
notice = TRUE;
}
/* Food decrease */
else if (new_aux < old_aux) {
switch (new_aux) {
case 0:
msgt(MSG_NOTICE, "You are getting faint from hunger!");
break;
case 1:
msgt(MSG_NOTICE, "You are getting weak from hunger!");
break;
case 2:
msgt(MSG_HUNGRY, "You are getting hungry.");
break;
case 3:
msgt(MSG_NOTICE, "You are no longer full.");
break;
}
/* Change */
notice = TRUE;
}
/* Use the value */
p->food = v;
/* Nothing to notice */
if (!notice) return (FALSE);
/* Disturb */
disturb(p_ptr, 0, 0);
/* Recalculate bonuses */
p->update |= (PU_BONUS);
/* Redraw hunger */
p->redraw |= (PR_STATUS);
/* Handle stuff */
handle_stuff(p_ptr);
/* Result */
return (TRUE);
}
/**
* 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;
}
/**
* Open a closed/locked/jammed door or a closed/locked chest.
*
* Unlocking a locked chest is worth one experience point; since doors are
* player lockable, there is no experience for unlocking doors.
*/
void do_cmd_open(struct command *cmd)
{
int y, x, dir;
struct object *obj;
bool more = false;
int err;
struct monster *m;
/* Get arguments */
err = cmd_get_arg_direction(cmd, "direction", &dir);
if (err || dir == DIR_UNKNOWN) {
int y2, x2;
int n_closed_doors, n_locked_chests;
n_closed_doors = count_feats(&y2, &x2, square_iscloseddoor, false);
n_locked_chests = count_chests(&y2, &x2, CHEST_OPENABLE);
if (n_closed_doors + n_locked_chests == 1) {
dir = coords_to_dir(y2, x2);
cmd_set_arg_direction(cmd, "direction", dir);
} else if (cmd_get_direction(cmd, "direction", &dir, false)) {
return;
}
}
/* Get location */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
/* Check for chest */
obj = chest_check(y, x, CHEST_OPENABLE);
/* Check for door */
if (!obj && !do_cmd_open_test(y, x)) {
/* Cancel repeat */
disturb(player, 0);
return;
}
/* Take a turn */
player->upkeep->energy_use = z_info->move_energy;
/* Apply confusion */
if (player_confuse_dir(player, &dir, false)) {
/* Get location */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
/* Check for chest */
obj = chest_check(y, x, CHEST_OPENABLE);
}
/* Monster */
m = square_monster(cave, y, x);
if (m) {
/* Mimics surprise the player */
if (is_mimicking(m)) {
become_aware(m);
/* Mimic wakes up */
mon_clear_timed(m, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE, false);
} else {
/* Message */
msg("There is a monster in the way!");
/* Attack */
py_attack(y, x);
}
} else if (obj) {
/* Chest */
more = do_cmd_open_chest(y, x, obj);
} else {
/* Door */
more = do_cmd_open_aux(y, x);
}
/* Cancel repeat unless we may continue */
if (!more) disturb(player, 0);
}
/**
* Disarms a trap, or a chest
*
* Traps must be visible, chests must be known trapped
*/
void do_cmd_disarm(struct command *cmd)
{
int y, x, dir;
int err;
struct object *obj;
bool more = false;
/* Get arguments */
err = cmd_get_arg_direction(cmd, "direction", &dir);
if (err || dir == DIR_UNKNOWN) {
int y2, x2;
int n_traps, n_chests;
n_traps = count_feats(&y2, &x2, square_isknowntrap, true);
n_chests = count_chests(&y2, &x2, CHEST_TRAPPED);
if (n_traps + n_chests == 1) {
dir = coords_to_dir(y2, x2);
cmd_set_arg_direction(cmd, "direction", dir);
} else if (cmd_get_direction(cmd, "direction", &dir, n_chests > 0)) {
/* If there are chests to disarm, 5 is allowed as a direction */
return;
}
}
/* Get location */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
/* Check for chests */
obj = chest_check(y, x, CHEST_TRAPPED);
/* Verify legality */
if (!obj && !do_cmd_disarm_test(y, x)) {
/* Cancel repeat */
disturb(player, 0);
return;
}
/* Take a turn */
player->upkeep->energy_use = z_info->move_energy;
/* Apply confusion */
if (player_confuse_dir(player, &dir, false)) {
/* Get location */
y = player->py + ddy[dir];
x = player->px + ddx[dir];
/* Check for chests */
obj = chest_check(y, x, CHEST_TRAPPED);
}
/* Monster */
if (cave->squares[y][x].mon > 0) {
msg("There is a monster in the way!");
py_attack(y, x);
} else if (obj)
/* Chest */
more = do_cmd_disarm_chest(y, x, obj);
else if (square_iscloseddoor(cave, y, x) &&
!square_islockeddoor(cave, y, x))
/* Door to lock */
more = do_cmd_lock_door(y, x);
else
/* Disarm trap */
more = do_cmd_disarm_aux(y, x);
/* Cancel repeat unless told not to */
if (!more) disturb(player, 0);
}
/*
* Search for hidden things. Returns true if a search was attempted, returns
* false when the player has a 0% chance of finding anything. Prints messages
* for negative confirmation when verbose mode is requested.
*/
bool search(bool verbose)
{
int py = p_ptr->py;
int px = p_ptr->px;
int y, x, chance;
bool found = FALSE;
object_type *o_ptr;
/* Start with base search ability */
chance = p_ptr->state.skills[SKILL_SEARCH];
/* Penalize various conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) chance = chance / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) chance = chance / 10;
/* Prevent fruitless searches */
if (chance <= 0)
{
if (verbose)
{
msg("You can't make out your surroundings well enough to search.");
/* Cancel repeat */
disturb(p_ptr, 0, 0);
}
return FALSE;
}
/* Search the nearby grids, which are always in bounds */
for (y = (py - 1); y <= (py + 1); y++)
{
for (x = (px - 1); x <= (px + 1); x++)
{
/* Sometimes, notice things */
if (randint0(100) < chance)
{
/* Invisible trap */
if (cave->feat[y][x] == FEAT_INVIS)
{
found = TRUE;
/* Pick a trap */
pick_trap(y, x);
/* Message */
msg("You have found a trap.");
/* Disturb */
disturb(p_ptr, 0, 0);
}
/* Secret door */
if (cave->feat[y][x] == FEAT_SECRET)
{
found = TRUE;
/* Message */
msg("You have found a secret door.");
/* Pick a door */
place_closed_door(cave, y, x);
/* Disturb */
disturb(p_ptr, 0, 0);
}
/* Scan all objects in the grid */
for (o_ptr = get_first_object(y, x); o_ptr; o_ptr = get_next_object(o_ptr))
{
/* Skip non-chests */
if (o_ptr->tval != TV_CHEST) continue;
/* Skip disarmed chests */
if (o_ptr->pval[DEFAULT_PVAL] <= 0) continue;
/* Skip non-trapped chests */
if (!chest_traps[o_ptr->pval[DEFAULT_PVAL]]) continue;
/* Identify once */
if (!object_is_known(o_ptr))
{
found = TRUE;
/* Message */
msg("You have discovered a trap on the chest!");
/* Know the trap */
object_notice_everything(o_ptr);
/* Notice it */
disturb(p_ptr, 0, 0);
}
}
}
}
}
if (verbose && !found)
{
if (chance >= 100)
msg("There are no secrets here.");
else
msg("You found nothing.");
}
return TRUE;
}
/*
* 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 = p_ptr->py;
int px = p_ptr->px;
int y = py + ddy[dir];
int x = px + ddx[dir];
int m_idx = cave->m_idx[y][x];
/* Attack monsters */
if (m_idx > 0) {
/* Mimics surprise the player */
if (is_mimicking(m_idx)) {
become_aware(m_idx);
/* Mimic wakes up */
mon_clear_timed(m_idx, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE);
} else {
py_attack(y, x);
}
}
/* Optionally alter traps/doors on movement */
else if (disarm && (cave->info[y][x] & CAVE_MARK) &&
(cave_isknowntrap(cave, y, x) ||
cave_iscloseddoor(cave, y, x)))
{
/* Auto-repeat if not already repeating */
if (cmd_get_nrepeats() == 0)
cmd_set_repeat(99);
do_cmd_alter_aux(dir);
}
/* Cannot walk through walls */
else if (!cave_floor_bold(y, x))
{
/* Disturb the player */
disturb(p_ptr, 0, 0);
/* Notice unknown obstacles */
if (!(cave->info[y][x] & CAVE_MARK))
{
/* Rubble */
if (cave->feat[y][x] == FEAT_RUBBLE)
{
msgt(MSG_HITWALL, "You feel a pile of rubble blocking your way.");
cave->info[y][x] |= (CAVE_MARK);
cave_light_spot(cave, y, x);
}
/* Closed door */
else if (cave->feat[y][x] < FEAT_SECRET)
{
msgt(MSG_HITWALL, "You feel a door blocking your way.");
cave->info[y][x] |= (CAVE_MARK);
cave_light_spot(cave, y, x);
}
/* Wall (or secret door) */
else
{
msgt(MSG_HITWALL, "You feel a wall blocking your way.");
cave->info[y][x] |= (CAVE_MARK);
cave_light_spot(cave, y, x);
}
}
/* Mention known obstacles */
else
{
if (cave->feat[y][x] == FEAT_RUBBLE)
msgt(MSG_HITWALL, "There is a pile of rubble blocking your way.");
else if (cave->feat[y][x] < FEAT_SECRET)
msgt(MSG_HITWALL, "There is a door blocking your way.");
else
msgt(MSG_HITWALL, "There is a wall blocking your way.");
}
}
/* Normal movement */
else
{
/* See if trap detection status will change */
bool old_dtrap = ((cave->info2[py][px] & (CAVE2_DTRAP)) != 0);
bool new_dtrap = ((cave->info2[y][x] & (CAVE2_DTRAP)) != 0);
/* Note the change in the detect status */
if (old_dtrap != new_dtrap)
p_ptr->redraw |= (PR_DTRAP);
/* Disturb player if the player is about to leave the area */
if (OPT(disturb_detect) && p_ptr->running &&
!p_ptr->running_firststep && old_dtrap && !new_dtrap)
{
disturb(p_ptr, 0, 0);
return;
}
/* Move player */
monster_swap(py, px, y, x);
/* New location */
y = py = p_ptr->py;
x = px = p_ptr->px;
/* Searching */
if (p_ptr->searching ||
(p_ptr->state.skills[SKILL_SEARCH_FREQUENCY] >= 50) ||
one_in_(50 - p_ptr->state.skills[SKILL_SEARCH_FREQUENCY]))
search(FALSE);
/* Handle "store doors" */
if ((cave->feat[p_ptr->py][p_ptr->px] >= FEAT_SHOP_HEAD) &&
(cave->feat[p_ptr->py][p_ptr->px] <= FEAT_SHOP_TAIL))
{
/* Disturb */
disturb(p_ptr, 0, 0);
cmd_insert(CMD_ENTER_STORE);
}
/* All other grids (including traps) */
else
{
/* Handle objects (later) */
p_ptr->notice |= (PN_PICKUP);
}
/* Discover invisible traps */
if (cave->feat[y][x] == FEAT_INVIS)
{
/* Disturb */
disturb(p_ptr, 0, 0);
/* Message */
msg("You found a trap!");
/* Pick a trap */
pick_trap(y, x);
/* Hit the trap */
hit_trap(y, x);
}
/* Set off an visible trap */
else if (cave_isknowntrap(cave, y, x))
{
/* Disturb */
disturb(p_ptr, 0, 0);
/* Hit the trap */
hit_trap(y, x);
}
}
p_ptr->running_firststep = FALSE;
}
/**
* Called from project() to affect the player
*
* Called for projections with the PROJECT_PLAY flag set, which includes
* bolt, beam, ball and breath effects.
*
* \param who is the monster list index of the caster
* \param r is the distance from the centre of the effect
* \param y
* \param x the coordinates of the grid being handled
* \param dam is the "damage" from the effect at distance r from the centre
* \param typ is the projection (GF_) type
* \return whether the effects were obvious
*
* If "r" is non-zero, then the blast was centered elsewhere; the damage
* is reduced in project() before being passed in here. This can happen if a
* monster breathes at the player and hits a wall instead.
*
* We assume the player is aware of some effect, and always return "TRUE".
*/
bool project_p(int who, int r, int y, int x, int dam, int typ)
{
bool blind, seen;
bool obvious = TRUE;
/* Source monster */
monster_type *m_ptr;
/* Monster name (for damage) */
char killer[80];
project_player_handler_f player_handler = player_handlers[typ];
project_player_handler_context_t context = {
who,
r,
y,
x,
dam,
typ,
obvious,
};
/* No player here */
if (!(cave->squares[y][x].mon < 0)) return (FALSE);
/* Never affect projector */
if (cave->squares[y][x].mon == who) return (FALSE);
/* Source monster */
m_ptr = cave_monster(cave, who);
/* Player blind-ness */
blind = (player->timed[TMD_BLIND] ? TRUE : FALSE);
/* Extract the "see-able-ness" */
seen = (!blind && mflag_has(m_ptr->mflag, MFLAG_VISIBLE));
/* Get the monster's real name */
monster_desc(killer, sizeof(killer), m_ptr, MDESC_DIED_FROM);
/* Let player know what is going on */
if (!seen)
msg("You are hit by %s!", gf_blind_desc(typ));
/* Adjust damage for resistance, immunity or vulnerability, and apply it */
dam = adjust_dam(player, typ, dam, RANDOMISE,
player->state.el_info[typ].res_level);
if (dam)
take_hit(player, dam, killer);
/* Handle side effects */
if (player_handler != NULL)
player_handler(&context);
obvious = context.obvious;
/* Disturb */
disturb(player, 1);
/* Return "Anything seen?" */
return (obvious);
}
/*
* Manipulate an adjacent grid in some way
*
* Attack monsters, tunnel through walls, disarm traps, open doors.
*
* This command must always take energy, to prevent free detection
* of invisible monsters.
*
* The "semantics" of this command must be chosen before the player
* is confused, and it must be verified against the new grid.
*/
void do_cmd_alter_aux(int dir)
{
int y, x;
int feat;
bool more = FALSE;
/* Get location */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
/* Original feature */
feat = cave_feat[y][x];
/* Must have knowledge to know feature XXX XXX */
if (!(cave_info[y][x] & (CAVE_MARK))) feat = FEAT_NONE;
/* Take a turn */
p_ptr->energy_use = 100;
/* Apply confusion */
if (confuse_dir(&dir))
{
/* Get location */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
}
/* Attack monsters */
if (cave_m_idx[y][x] > 0)
{
if (mon_list[cave_m_idx[y][x]].align & (AL_PET_MASK))
{
msg_print("There is a friendly monster in the way!");
}
else
{
/* Attack */
py_attack(y, x);
}
}
/* Tunnel through walls */
else if (feat >= FEAT_SECRET)
{
more = do_cmd_tunnel_aux(y, x);
}
#if 0
/* Bash jammed doors */
else if (feat >= FEAT_DOOR_HEAD + 0x08)
{
more = do_cmd_bash_aux(y, x);
}
#endif
/* Open closed doors */
else if (feat >= FEAT_DOOR_HEAD)
{
more = do_cmd_open_aux(y, x);
}
/* Disarm traps */
else if (feat >= FEAT_TRAP_HEAD)
{
more = do_cmd_disarm_aux(y, x);
}
#if 0
/* Close open doors */
else if (feat == FEAT_OPEN)
{
more = do_cmd_close_aux(y, x);
}
#endif
/* Oops */
else
{
msg_print("You spin around.");
}
/* Cancel repetition unless we can continue */
if (!more) disturb(0, 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;
}
/**
* Process a monster
*
* In several cases, we directly update the monster lore
*
* Note that a monster is only allowed to "reproduce" if there
* are a limited number of "reproducing" monsters on the current
* level. This should prevent the level from being "swamped" by
* reproducing monsters. It also allows a large mass of mice to
* prevent a louse from multiplying, but this is a small price to
* pay for a simple multiplication method.
*
* XXX Monster fear is slightly odd, in particular, monsters will
* fixate on opening a door even if they cannot open it. Actually,
* the same thing happens to normal monsters when they hit a door
*
* In addition, monsters which *cannot* open or bash down a door
* will still stand there trying to open it... XXX XXX XXX
*
* Technically, need to check for monster in the way combined
* with that monster being in a wall (or door?) XXX
*/
static void process_monster(struct chunk *c, struct monster *mon)
{
struct monster_lore *lore = get_lore(mon->race);
bool did_something = false;
int i;
int dir = 0;
bool stagger = false;
char m_name[80];
/* Get the monster name */
monster_desc(m_name, sizeof(m_name), mon, MDESC_CAPITAL | MDESC_IND_HID);
/* Try to multiply - this can use up a turn */
if (process_monster_multiply(c, mon))
return;
/* Attempt to cast a spell */
if (make_attack_spell(mon)) return;
/* Work out what kind of movement to use - AI or staggered movement */
if (!process_monster_should_stagger(mon)) {
if (!get_moves(c, mon, &dir)) return;
} else {
stagger = true;
}
/* Process moves */
for (i = 0; i < 5 && !did_something; i++) {
int oy = mon->fy;
int ox = mon->fx;
/* Get the direction (or stagger) */
int d = (stagger ? ddd[randint0(8)] : side_dirs[dir][i]);
/* Get the destination */
int ny = oy + ddy[d];
int nx = ox + ddx[d];
/* Check if we can move */
if (!process_monster_can_move(c, mon, m_name, nx, ny, &did_something))
continue;
/* Try to break the glyph if there is one. This can happen multiple
* times per turn because failure does not break the loop */
if (square_iswarded(c, ny, nx) &&
!process_monster_glyph(c, mon, nx, ny))
continue;
/* The player is in the way. */
if (square_isplayer(c, ny, nx)) {
/* Learn about if the monster attacks */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
rf_on(lore->flags, RF_NEVER_BLOW);
/* Some monsters never attack */
if (rf_has(mon->race->flags, RF_NEVER_BLOW))
continue;
/* Otherwise, attack the player */
make_attack_normal(mon, player);
did_something = true;
break;
} else {
/* Some monsters never move */
if (rf_has(mon->race->flags, RF_NEVER_MOVE)) {
/* Learn about lack of movement */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
rf_on(lore->flags, RF_NEVER_MOVE);
return;
}
}
/* A monster is in the way, try to push past/kill */
if (square_monster(c, ny, nx)) {
did_something = process_monster_try_push(c, mon, m_name, nx, ny);
} else {
/* Otherwise we can just move */
monster_swap(oy, ox, ny, nx);
did_something = true;
}
/* Scan all objects in the grid, if we reached it */
if (mon == square_monster(c, ny, nx)) {
monster_desc(m_name, sizeof(m_name), mon,
MDESC_CAPITAL | MDESC_IND_HID);
process_monster_grab_objects(c, mon, m_name, nx, ny);
}
}
if (did_something) {
/* Learn about no lack of movement */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
rf_on(lore->flags, RF_NEVER_MOVE);
/* Possible disturb */
if (mflag_has(mon->mflag, MFLAG_VISIBLE) &&
mflag_has(mon->mflag, MFLAG_VIEW) && OPT(player, disturb_near))
disturb(player, 0);
}
/* Hack -- get "bold" if out of options */
if (!did_something && mon->m_timed[MON_TMD_FEAR])
mon_clear_timed(mon, MON_TMD_FEAR, MON_TMD_FLG_NOTIFY, false);
/* If we see an unaware monster do something, become aware of it */
if (did_something && mflag_has(mon->mflag, MFLAG_UNAWARE))
become_aware(mon);
}
/**
* 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 run */
if (dir) {
/* Paranoia */
p_ptr->running_withpathfind = 0;
/* Initialize */
run_init(dir);
/* Hack -- Set the run counter */
p_ptr->running = (p_ptr->command_arg ? p_ptr->command_arg : 1000);
/* Calculate torch radius */
p_ptr->update |= (PU_TORCH);
}
/* Continue run */
else {
if (!p_ptr->running_withpathfind) {
/* Update run */
if (run_test()) {
/* Disturb */
disturb(0, 0);
/* Done */
return;
}
}
else {
/* Abort if we have finished */
if (pf_result_index < 0) {
disturb(0, 0);
p_ptr->running_withpathfind = FALSE;
return;
}
/* Abort if we would hit a wall */
else if (pf_result_index == 0) {
int y, x;
/* Get next step */
y = p_ptr->py + ddy[pf_result[pf_result_index] - '0'];
x = p_ptr->px + ddx[pf_result[pf_result_index] - '0'];
/* Known wall */
if ((cave_info[y][x] & (CAVE_MARK)) && !is_valid_pf(y, x)) {
disturb(0, 0);
p_ptr->running_withpathfind = FALSE;
return;
}
}
/* Hack -- walking stick lookahead. 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. */
else if (pf_result_index > 0) {
int y, x;
/* Get next step */
y = p_ptr->py + ddy[pf_result[pf_result_index] - '0'];
x = p_ptr->px + ddx[pf_result[pf_result_index] - '0'];
/* Known wall */
if ((cave_info[y][x] & (CAVE_MARK)) && !is_valid_pf(y, x)) {
disturb(0, 0);
p_ptr->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 */
if ((cave_info[y][x] & (CAVE_MARK)) && !is_valid_pf(y, x)) {
p_ptr->running_withpathfind = FALSE;
run_init(pf_result[pf_result_index] - '0');
}
}
if (!player_is_crossing)
p_ptr->run_cur_dir = pf_result[pf_result_index--] - '0';
}
}
/* Decrease counter */
p_ptr->running--;
/* Take time */
p_ptr->energy_use = 100;
/* Move the player */
move_player(p_ptr->run_cur_dir);
}
/**
* Handle things that need updating once every 10 game turns
*/
void process_world(struct chunk *c)
{
int i, y, x;
/* Compact the monster list if we're approaching the limit */
if (cave_monster_count(cave) + 32 > z_info->level_monster_max)
compact_monsters(64);
/* Too many holes in the monster list - compress */
if (cave_monster_count(cave) + 32 < cave_monster_max(cave))
compact_monsters(0);
/*** Check the Time ***/
/* Play an ambient sound at regular intervals. */
if (!(turn % ((10L * z_info->day_length) / 4)))
play_ambient_sound();
/*** Handle stores and sunshine ***/
if (!player->depth) {
/* Daybreak/Nighfall in town */
if (!(turn % ((10L * z_info->day_length) / 2))) {
bool dawn;
/* Check for dawn */
dawn = (!(turn % (10L * z_info->day_length)));
/* Day breaks */
if (dawn)
msg("The sun has risen.");
/* Night falls */
else
msg("The sun has fallen.");
/* Illuminate */
cave_illuminate(c, dawn);
}
} else {
/* Update the stores once a day (while in the dungeon).
The changes are not actually made until return to town,
to avoid giving details away in the knowledge menu. */
if (!(turn % (10L * z_info->store_turns))) daycount++;
}
/* Check for creature generation */
if (one_in_(z_info->alloc_monster_chance))
(void)pick_and_place_distant_monster(cave, player,
z_info->max_sight + 5, true,
player->depth);
/*** Damage over Time ***/
/* Take damage from poison */
if (player->timed[TMD_POISONED])
take_hit(player, 1, "poison");
/* Take damage from cuts */
if (player->timed[TMD_CUT]) {
/* Mortal wound or Deep Gash */
if (player->timed[TMD_CUT] > TMD_CUT_SEVERE)
i = 3;
/* Severe cut */
else if (player->timed[TMD_CUT] > TMD_CUT_NASTY)
i = 2;
/* Other cuts */
else
i = 1;
/* Take damage */
take_hit(player, i, "a fatal wound");
}
/*** Check the Food, and Regenerate ***/
/* Digest normally */
if (!(turn % 100)) {
/* Basic digestion rate based on speed */
i = turn_energy(player->state.speed) * 2;
/* Regeneration takes more food */
if (player_of_has(player, OF_REGEN)) i += 30;
/* Slow digestion takes less food */
if (player_of_has(player, OF_SLOW_DIGEST)) i /= 5;
/* Minimal digestion */
if (i < 1) i = 1;
/* Digest some food */
player_set_food(player, player->food - i);
}
/* Getting Faint */
if (player->food < PY_FOOD_FAINT) {
/* Faint occasionally */
if (!player->timed[TMD_PARALYZED] && one_in_(10)) {
/* Message */
msg("You faint from the lack of food.");
disturb(player, 1);
/* Faint (bypass free action) */
(void)player_inc_timed(player, TMD_PARALYZED, 1 + randint0(5),
true, false);
}
}
/* Starve to death (slowly) */
if (player->food < PY_FOOD_STARVE) {
/* Calculate damage */
i = (PY_FOOD_STARVE - player->food) / 10;
/* Take damage */
take_hit(player, i, "starvation");
}
/* Regenerate Hit Points if needed */
if (player->chp < player->mhp)
player_regen_hp(player);
/* Regenerate mana if needed */
if (player->csp < player->msp)
player_regen_mana(player);
/* Timeout various things */
decrease_timeouts();
/* Process light */
player_update_light(player);
/*** Process Inventory ***/
/* Handle experience draining */
if (player_of_has(player, OF_DRAIN_EXP)) {
if ((player->exp > 0) && one_in_(10)) {
s32b d = damroll(10, 6) +
(player->exp / 100) * z_info->life_drain_percent;
player_exp_lose(player, d / 10, false);
}
equip_learn_flag(player, OF_DRAIN_EXP);
}
/* Recharge activatable objects and rods */
recharge_objects();
/* Notice things after time */
if (!(turn % 100))
equip_learn_after_time(player);
/* Decrease trap timeouts */
for (y = 0; y < cave->height; y++) {
for (x = 0; x < cave->width; x++) {
struct trap *trap = cave->squares[y][x].trap;
while (trap) {
if (trap->timeout) {
trap->timeout--;
if (!trap->timeout)
square_light_spot(cave, y, x);
}
trap = trap->next;
}
}
}
/*** Involuntary Movement ***/
/* Delayed Word-of-Recall */
if (player->word_recall) {
/* Count down towards recall */
player->word_recall--;
/* Activate the recall */
if (!player->word_recall) {
/* Disturbing! */
disturb(player, 0);
/* Determine the level */
if (player->depth) {
msgt(MSG_TPLEVEL, "You feel yourself yanked upwards!");
dungeon_change_level(player, 0);
} else {
msgt(MSG_TPLEVEL, "You feel yourself yanked downwards!");
/* Force descent to a lower level if allowed */
if (OPT(player, birth_force_descend) &&
player->max_depth < z_info->max_depth - 1 &&
!is_quest(player->max_depth)) {
player->max_depth = dungeon_get_next_level(player->max_depth, 1);
}
/* New depth - back to max depth or 1, whichever is deeper */
dungeon_change_level(player, player->max_depth < 1 ? 1: player->max_depth);
}
}
}
/* Delayed Deep Descent */
if (player->deep_descent) {
/* Count down towards recall */
player->deep_descent--;
/* Activate the recall */
if (player->deep_descent == 0) {
int target_increment;
int target_depth = player->max_depth;
/* Calculate target depth */
target_increment = (4 / z_info->stair_skip) + 1;
target_depth = dungeon_get_next_level(player->max_depth, target_increment);
disturb(player, 0);
/* Determine the level */
if (target_depth > player->depth) {
msgt(MSG_TPLEVEL, "The floor opens beneath you!");
dungeon_change_level(player, target_depth);
} else {
/* Otherwise do something disastrous */
msgt(MSG_TPLEVEL, "You are thrown back in an explosion!");
effect_simple(EF_DESTRUCTION, "0", 0, 5, 0, NULL);
}
}
}
}
/*
* Disarms a trap, or a chest
*/
void do_cmd_disarm(cmd_code code, cmd_arg args[])
{
int y, x, dir;
s16b o_idx;
bool more = FALSE;
dir = args[0].direction;
/* Get location */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
/* Check for chests */
o_idx = chest_check(y, x);
/* Verify legality */
if (!o_idx && !do_cmd_disarm_test(y, x))
{
/* Cancel repeat */
disturb(0, 0);
return;
}
/* Take a turn */
p_ptr->energy_use = 100;
/* Apply confusion */
if (confuse_dir(&dir))
{
/* Get location */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
/* Check for chests */
o_idx = chest_check(y, x);
}
/* Monster */
if (cave_m_idx[y][x] > 0)
{
/* Message */
msg_print("There is a monster in the way!");
/* Attack */
py_attack(y, x);
}
/* Chest */
else if (o_idx)
{
/* Disarm the chest */
more = do_cmd_disarm_chest(y, x, o_idx);
}
/* Disarm trap */
else
{
/* Disarm the trap */
more = do_cmd_disarm_aux(y, x);
}
/* Cancel repeat unless told not to */
if (!more) disturb(0, 0);
}
/**
* Called from project() to affect the player
*
* Called for projections with the PROJECT_PLAY flag set, which includes
* bolt, beam, ball and breath effects.
*
* \param src is the origin of the effect
* \param r is the distance from the centre of the effect
* \param y the coordinates of the grid being handled
* \param x the coordinates of the grid being handled
* \param dam is the "damage" from the effect at distance r from the centre
* \param typ is the projection (PROJ_) type
* \return whether the effects were obvious
*
* If "r" is non-zero, then the blast was centered elsewhere; the damage
* is reduced in project() before being passed in here. This can happen if a
* monster breathes at the player and hits a wall instead.
*
* We assume the player is aware of some effect, and always return "true".
*/
bool project_p(struct source origin, int r, int y, int x, int dam, int typ)
{
bool blind = (player->timed[TMD_BLIND] ? true : false);
bool seen = !blind;
bool obvious = true;
/* Monster or trap name (for damage) */
char killer[80];
project_player_handler_f player_handler = player_handlers[typ];
project_player_handler_context_t context = {
origin,
r,
y,
x,
dam,
typ,
obvious,
};
/* No player here */
if (!square_isplayer(cave, y, x)) {
return false;
}
switch (origin.what) {
case SRC_PLAYER:
/* Never affect projector */
return false;
case SRC_MONSTER: {
struct monster *mon = cave_monster(cave, origin.which.monster);
/* Check it is visible */
if (!monster_is_visible(mon))
seen = false;
/* Get the monster's real name */
monster_desc(killer, sizeof(killer), mon, MDESC_DIED_FROM);
break;
}
case SRC_TRAP: {
struct trap *trap = origin.which.trap;
/* Get the trap name */
strnfmt(killer, sizeof(killer), "a %s", trap->kind->desc);
break;
}
case SRC_OBJECT: {
struct object *obj = origin.which.object;
object_desc(killer, sizeof(killer), obj, ODESC_PREFIX | ODESC_BASE);
break;
}
case SRC_NONE: {
/* Assume the caller has set the killer variable */
break;
}
}
/* Let player know what is going on */
if (!seen) {
msg("You are hit by %s!", projections[typ].blind_desc);
}
/* Adjust damage for resistance, immunity or vulnerability, and apply it */
dam = adjust_dam(player,
typ,
dam,
RANDOMISE,
player->state.el_info[typ].res_level,
true);
if (dam) {
take_hit(player, dam, killer);
}
/* Handle side effects */
if (player_handler != NULL && player->is_dead == false) {
player_handler(&context);
}
/* Disturb */
disturb(player, 1);
/* Return "Anything seen?" */
return context.obvious;
}
int do_autopickup(void)
{
int py = p_ptr->py;
int px = p_ptr->px;
s16b this_o_idx, next_o_idx = 0;
object_type *o_ptr;
/* Objects picked up. Used to determine time cost of command. */
byte objs_picked_up = 0;
size_t floor_num = 0;
int floor_list[MAX_FLOOR_STACK + 1];
/* Nothing to pick up -- return */
if (!cave->o_idx[py][px]) return (0);
/* Always pickup gold, effortlessly */
py_pickup_gold();
/* Scan the remaining objects */
for (this_o_idx = cave->o_idx[py][px]; this_o_idx; this_o_idx = next_o_idx)
{
/* Get the object and the next object */
o_ptr = object_byid(this_o_idx);
next_o_idx = o_ptr->next_o_idx;
/* Ignore all hidden objects and non-objects */
if (squelch_item_ok(o_ptr) || !o_ptr->kind) continue;
/* XXX Hack -- Enforce limit */
if (floor_num >= N_ELEMENTS(floor_list)) break;
/* Hack -- disturb */
disturb(p_ptr, 0, 0);
/* Automatically pick up items into the backpack */
if (auto_pickup_okay(o_ptr))
{
/* Pick up the object with message */
py_pickup_aux(this_o_idx, TRUE);
objs_picked_up++;
continue;
}
/* Tally objects and store them in an array. */
/* Remember this object index */
floor_list[floor_num] = this_o_idx;
/* Count non-gold objects that remain on the floor. */
floor_num++;
}
return objs_picked_up;
}
/*
* Attack the player via physical attacks.
*/
bool make_attack_normal(int m_idx)
{
monster_type *m_ptr = &mon_list[m_idx];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
monster_lore *l_ptr = &l_list[m_ptr->r_idx];
int ap_cnt;
int i, k, tmp, ac, rlev;
int do_cut, do_stun;
s32b gold;
object_type *o_ptr;
char o_name[80];
char m_name[80];
char ddesc[80];
bool blinked;
/* Not allowed to attack */
if (r_ptr->flags1 & (RF1_NEVER_BLOW)) return (FALSE);
/* Total armor */
ac = p_ptr->ac + p_ptr->to_a;
/* Extract the effective monster level */
rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
/* Get the monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Get the "died from" information (i.e. "a kobold") */
monster_desc(ddesc, sizeof(ddesc), m_ptr, 0x88);
/* Assume no blink */
blinked = FALSE;
/* Scan through all blows */
for (ap_cnt = 0; ap_cnt < MONSTER_BLOW_MAX; ap_cnt++)
{
bool visible = FALSE;
bool obvious = FALSE;
int power = 0;
int damage = 0;
cptr act = NULL;
/* Extract the attack infomation */
int effect = r_ptr->blow[ap_cnt].effect;
int method = r_ptr->blow[ap_cnt].method;
int d_dice = r_ptr->blow[ap_cnt].d_dice;
int d_side = r_ptr->blow[ap_cnt].d_side;
/* Hack -- no more attacks */
if (!method) break;
/* Handle "leaving" */
if (p_ptr->leaving) break;
/* Extract visibility (before blink) */
if (m_ptr->ml) visible = TRUE;
/* Extract the attack "power" */
switch (effect)
{
case RBE_HURT: power = 60; break;
case RBE_POISON: power = 5; break;
case RBE_UN_BONUS: power = 20; break;
case RBE_UN_POWER: power = 15; break;
case RBE_EAT_GOLD: power = 5; break;
case RBE_EAT_ITEM: power = 5; break;
case RBE_EAT_FOOD: power = 5; break;
case RBE_EAT_LITE: power = 5; break;
case RBE_ACID: power = 0; break;
case RBE_ELEC: power = 10; break;
case RBE_FIRE: power = 10; break;
case RBE_COLD: power = 10; break;
case RBE_BLIND: power = 2; break;
case RBE_CONFUSE: power = 10; break;
case RBE_TERRIFY: power = 10; break;
case RBE_PARALYZE: power = 2; break;
case RBE_LOSE_STR: power = 0; break;
case RBE_LOSE_DEX: power = 0; break;
case RBE_LOSE_CON: power = 0; break;
case RBE_LOSE_INT: power = 0; break;
case RBE_LOSE_WIS: power = 0; break;
case RBE_LOSE_CHR: power = 0; break;
case RBE_LOSE_ALL: power = 2; break;
case RBE_SHATTER: power = 60; break;
case RBE_EXP_10: power = 5; break;
case RBE_EXP_20: power = 5; break;
case RBE_EXP_40: power = 5; break;
case RBE_EXP_80: power = 5; break;
case RBE_HALLU: power = 10; break;
}
/* Monster hits player */
if (!effect || check_hit(power, rlev))
{
/* Always disturbing */
disturb(1, 0);
/* Hack -- Apply "protection from evil" */
if ((p_ptr->protevil > 0) &&
(r_ptr->flags3 & (RF3_EVIL)) &&
(p_ptr->lev >= rlev) &&
((rand_int(100) + p_ptr->lev) > 50))
{
/* Remember the Evil-ness */
if (m_ptr->ml)
{
l_ptr->flags3 |= (RF3_EVIL);
}
/* Message */
msg_format("%^s is repelled.", m_name);
/* Hack -- Next attack */
continue;
}
/* Assume no cut or stun */
do_cut = do_stun = 0;
/* Describe the attack method */
switch (method)
{
case RBM_HIT:
{
act = "hits you.";
do_cut = do_stun = 1;
break;
}
case RBM_TOUCH:
{
act = "touches you.";
break;
}
case RBM_PUNCH:
{
act = "punches you.";
do_stun = 1;
break;
}
case RBM_KICK:
{
act = "kicks you.";
do_stun = 1;
break;
}
case RBM_CLAW:
{
act = "claws you.";
do_cut = 1;
break;
}
case RBM_BITE:
{
act = "bites you.";
do_cut = 1;
break;
}
case RBM_STING:
{
act = "stings you.";
break;
}
case RBM_XXX1:
{
act = "XXX1's you.";
break;
}
case RBM_BUTT:
{
act = "butts you.";
do_stun = 1;
break;
}
case RBM_CRUSH:
{
act = "crushes you.";
do_stun = 1;
break;
}
case RBM_ENGULF:
{
act = "engulfs you.";
break;
}
case RBM_XXX2:
{
act = "XXX2's you.";
break;
}
case RBM_CRAWL:
{
act = "crawls on you.";
break;
}
case RBM_DROOL:
{
act = "drools on you.";
break;
}
case RBM_SPIT:
{
act = "spits on you.";
break;
}
case RBM_XXX3:
{
act = "XXX3's on you.";
break;
}
case RBM_GAZE:
{
act = "gazes at you.";
break;
}
case RBM_WAIL:
{
act = "wails at you.";
break;
}
case RBM_SPORE:
{
act = "releases spores at you.";
break;
}
case RBM_XXX4:
{
act = "projects XXX4's at you.";
break;
}
case RBM_BEG:
{
act = "begs you for money.";
break;
}
case RBM_INSULT:
{
act = desc_insult[rand_int(MAX_DESC_INSULT)];
break;
}
case RBM_MOAN:
{
act = desc_moan[rand_int(MAX_DESC_MOAN)];
break;
}
case RBM_XXX5:
{
act = "XXX5's you.";
break;
}
}
/* Message */
if (act) msg_format("%^s %s", m_name, act);
/* Hack -- assume all attacks are obvious */
obvious = TRUE;
/* Roll out the damage */
damage = damroll(d_dice, d_side);
/* Apply appropriate damage */
switch (effect)
{
case 0:
{
/* Hack -- Assume obvious */
obvious = TRUE;
/* Hack -- No damage */
damage = 0;
break;
}
case RBE_HURT:
{
/* Obvious */
obvious = TRUE;
/* Hack -- Player armor reduces total damage */
damage -= (damage * ((ac < 150) ? ac : 150) / 250);
/* Take damage */
take_hit(damage, ddesc);
break;
}
case RBE_POISON:
{
/* Take damage */
take_hit(damage, ddesc);
/* Take "poison" effect */
if (!(p_ptr->resist_pois || p_ptr->oppose_pois))
{
if (set_poisoned(p_ptr->poisoned + randint(rlev) + 5))
{
obvious = TRUE;
}
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_POIS);
break;
}
case RBE_UN_BONUS:
{
/* Take damage */
take_hit(damage, ddesc);
/* Allow complete resist */
if (!p_ptr->resist_disen)
{
/* Apply disenchantment */
if (apply_disenchant(0)) obvious = TRUE;
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_DISEN);
break;
}
case RBE_UN_POWER:
{
/* Take damage */
take_hit(damage, ddesc);
/* Find an item */
for (k = 0; k < 10; k++)
{
/* Pick an item */
i = rand_int(INVEN_PACK);
/* Obtain the item */
o_ptr = &inventory[i];
/* Skip non-objects */
if (!o_ptr->k_idx) continue;
/* Drain charged wands/staffs */
if (((o_ptr->tval == TV_STAFF) ||
(o_ptr->tval == TV_WAND)) &&
(o_ptr->pval > 0))
{
/* Calculate healed hitpoints */
int heal = rlev * o_ptr->pval * o_ptr->number;
/* Don't heal more than max hp */
heal = MIN(heal, m_ptr->maxhp - m_ptr->hp);
/* Message */
msg_print("Energy drains from your pack!");
/* Obvious */
obvious = TRUE;
/* Heal */
m_ptr->hp += heal;
/* Redraw (later) if needed */
if (p_ptr->health_who == m_idx)
p_ptr->redraw |= (PR_HEALTH);
/* Uncharge */
o_ptr->pval = 0;
/* Combine / Reorder the pack */
p_ptr->notice |= (PN_COMBINE | PN_REORDER);
/* Window stuff */
p_ptr->window |= (PW_INVEN);
/* Done */
break;
}
}
break;
}
case RBE_EAT_GOLD:
{
/* Take damage */
take_hit(damage, ddesc);
/* Obvious */
obvious = TRUE;
/* Saving throw (unless paralyzed) based on dex and level */
if (!p_ptr->paralyzed &&
(rand_int(100) < (adj_dex_safe[p_ptr->stat_ind[A_DEX]] +
p_ptr->lev)))
{
/* Saving throw message */
msg_print("You quickly protect your money pouch!");
/* Occasional blink anyway */
if (rand_int(3)) blinked = TRUE;
}
/* Eat gold */
else
{
gold = (p_ptr->au / 10) + randint(25);
if (gold < 2) gold = 2;
if (gold > 5000) gold = (p_ptr->au / 20) + randint(3000);
if (gold > p_ptr->au) gold = p_ptr->au;
p_ptr->au -= gold;
if (gold <= 0)
{
msg_print("Nothing was stolen.");
}
else if (p_ptr->au)
{
msg_print("Your purse feels lighter.");
msg_format("%ld coins were stolen!", (long)gold);
}
else
{
msg_print("Your purse feels lighter.");
msg_print("All of your coins were stolen!");
}
/* Redraw gold */
p_ptr->redraw |= (PR_GOLD);
/* Window stuff */
p_ptr->window |= (PW_PLAYER_0 | PW_PLAYER_1);
/* Blink away */
blinked = TRUE;
}
break;
}
case RBE_EAT_ITEM:
{
/* Take damage */
take_hit(damage, ddesc);
/* Saving throw (unless paralyzed) based on dex and level */
if (!p_ptr->paralyzed &&
(rand_int(100) < (adj_dex_safe[p_ptr->stat_ind[A_DEX]] +
p_ptr->lev)))
{
/* Saving throw message */
msg_print("You grab hold of your backpack!");
/* Occasional "blink" anyway */
blinked = TRUE;
/* Obvious */
obvious = TRUE;
/* Done */
break;
}
/* Find an item */
for (k = 0; k < 10; k++)
{
object_type *i_ptr;
object_type object_type_body;
/* Pick an item */
i = rand_int(INVEN_PACK);
/* Obtain the item */
o_ptr = &inventory[i];
/* Skip non-objects */
if (!o_ptr->k_idx) continue;
/* Skip artifacts */
if (artifact_p(o_ptr)) continue;
/* Get a description */
object_desc(o_name, sizeof(o_name), o_ptr, FALSE, 3);
/* Message */
msg_format("%sour %s (%c) was stolen!",
((o_ptr->number > 1) ? "One of y" : "Y"),
o_name, index_to_label(i));
/* Get local object */
i_ptr = &object_type_body;
/* Obtain local object */
object_copy(i_ptr, o_ptr);
/* Modify number */
i_ptr->number = 1;
/* Carry the object */
(void)monster_carry(m_idx, i_ptr);
/* Steal the items */
inven_item_increase(i, -1);
inven_item_optimize(i);
/* Obvious */
obvious = TRUE;
/* Blink away */
blinked = TRUE;
/* Done */
break;
}
break;
}
case RBE_EAT_FOOD:
{
/* Take damage */
take_hit(damage, ddesc);
/* Steal some food */
for (k = 0; k < 10; k++)
{
/* Pick an item from the pack */
i = rand_int(INVEN_PACK);
/* Get the item */
o_ptr = &inventory[i];
/* Skip non-objects */
if (!o_ptr->k_idx) continue;
/* Skip non-food objects */
if (o_ptr->tval != TV_FOOD) continue;
/* Get a description */
object_desc(o_name, sizeof(o_name), o_ptr, FALSE, 0);
/* Message */
msg_format("%sour %s (%c) was eaten!",
((o_ptr->number > 1) ? "One of y" : "Y"),
o_name, index_to_label(i));
/* Steal the items */
inven_item_increase(i, -1);
inven_item_optimize(i);
/* Obvious */
obvious = TRUE;
/* Done */
break;
}
break;
}
case RBE_EAT_LITE:
{
/* Take damage */
take_hit(damage, ddesc);
/* Get the lite */
o_ptr = &inventory[INVEN_LITE];
/* Drain fuel */
if ((o_ptr->pval > 0) && (!artifact_p(o_ptr)))
{
/* Reduce fuel */
o_ptr->pval -= (250 + randint(250));
if (o_ptr->pval < 1) o_ptr->pval = 1;
/* Notice */
if (!p_ptr->blind)
{
msg_print("Your light dims.");
obvious = TRUE;
}
/* Window stuff */
p_ptr->window |= (PW_EQUIP);
}
break;
}
case RBE_ACID:
{
/* Obvious */
obvious = TRUE;
/* Message */
msg_print("You are covered in acid!");
/* Special damage */
acid_dam(damage, ddesc);
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_ACID);
break;
}
case RBE_ELEC:
{
/* Obvious */
obvious = TRUE;
/* Message */
msg_print("You are struck by electricity!");
/* Take damage (special) */
elec_dam(damage, ddesc);
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_ELEC);
break;
}
case RBE_FIRE:
{
/* Obvious */
obvious = TRUE;
/* Message */
msg_print("You are enveloped in flames!");
/* Take damage (special) */
fire_dam(damage, ddesc);
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_FIRE);
break;
}
case RBE_COLD:
{
/* Obvious */
obvious = TRUE;
/* Message */
msg_print("You are covered with frost!");
/* Take damage (special) */
cold_dam(damage, ddesc);
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_COLD);
break;
}
case RBE_BLIND:
{
/* Take damage */
take_hit(damage, ddesc);
/* Increase "blind" */
if (!p_ptr->resist_blind)
{
if (set_blind(p_ptr->blind + 10 + randint(rlev)))
{
obvious = TRUE;
}
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_BLIND);
break;
}
case RBE_CONFUSE:
{
/* Take damage */
take_hit(damage, ddesc);
/* Increase "confused" */
if (!p_ptr->resist_confu)
{
if (set_confused(p_ptr->confused + 3 + randint(rlev)))
{
obvious = TRUE;
}
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_CONFU);
break;
}
case RBE_TERRIFY:
{
/* Take damage */
take_hit(damage, ddesc);
/* Increase "afraid" */
if (p_ptr->resist_fear)
{
msg_print("You stand your ground!");
obvious = TRUE;
}
else if (rand_int(100) < p_ptr->skill_sav)
{
msg_print("You stand your ground!");
obvious = TRUE;
}
else
{
if (set_afraid(p_ptr->afraid + 3 + randint(rlev)))
{
obvious = TRUE;
}
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_FEAR);
break;
}
case RBE_PARALYZE:
{
/* Hack -- Prevent perma-paralysis via damage */
if (p_ptr->paralyzed && (damage < 1)) damage = 1;
/* Take damage */
take_hit(damage, ddesc);
/* Increase "paralyzed" */
if (p_ptr->free_act)
{
msg_print("You are unaffected!");
obvious = TRUE;
}
else if (rand_int(100) < p_ptr->skill_sav)
{
msg_print("You resist the effects!");
obvious = TRUE;
}
else
{
if (set_paralyzed(p_ptr->paralyzed + 3 + randint(rlev)))
{
obvious = TRUE;
}
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_FREE);
break;
}
case RBE_LOSE_STR:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stat) */
if (do_dec_stat(A_STR)) obvious = TRUE;
break;
}
case RBE_LOSE_INT:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stat) */
if (do_dec_stat(A_INT)) obvious = TRUE;
break;
}
case RBE_LOSE_WIS:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stat) */
if (do_dec_stat(A_WIS)) obvious = TRUE;
break;
}
case RBE_LOSE_DEX:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stat) */
if (do_dec_stat(A_DEX)) obvious = TRUE;
break;
}
case RBE_LOSE_CON:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stat) */
if (do_dec_stat(A_CON)) obvious = TRUE;
break;
}
case RBE_LOSE_CHR:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stat) */
if (do_dec_stat(A_CHR)) obvious = TRUE;
break;
}
case RBE_LOSE_ALL:
{
/* Take damage */
take_hit(damage, ddesc);
/* Damage (stats) */
if (do_dec_stat(A_STR)) obvious = TRUE;
if (do_dec_stat(A_DEX)) obvious = TRUE;
if (do_dec_stat(A_CON)) obvious = TRUE;
if (do_dec_stat(A_INT)) obvious = TRUE;
if (do_dec_stat(A_WIS)) obvious = TRUE;
if (do_dec_stat(A_CHR)) obvious = TRUE;
break;
}
case RBE_SHATTER:
{
/* Obvious */
obvious = TRUE;
/* Hack -- Reduce damage based on the player armor class */
damage -= (damage * ((ac < 150) ? ac : 150) / 250);
/* Take damage */
take_hit(damage, ddesc);
/* Radius 8 earthquake centered at the monster */
if (damage > 23) earthquake(m_ptr->fy, m_ptr->fx, 8);
break;
}
case RBE_EXP_10:
{
/* Obvious */
obvious = TRUE;
/* Take damage */
take_hit(damage, ddesc);
if (p_ptr->hold_life && (rand_int(100) < 95))
{
msg_print("You keep hold of your life force!");
}
else
{
s32b d = damroll(10, 6) + (p_ptr->exp/100) * MON_DRAIN_LIFE;
if (p_ptr->hold_life)
{
msg_print("You feel your life slipping away!");
lose_exp(d/10);
}
else
{
msg_print("You feel your life draining away!");
lose_exp(d);
}
}
break;
}
case RBE_EXP_20:
{
/* Obvious */
obvious = TRUE;
/* Take damage */
take_hit(damage, ddesc);
if (p_ptr->hold_life && (rand_int(100) < 90))
{
msg_print("You keep hold of your life force!");
}
else
{
s32b d = damroll(20, 6) + (p_ptr->exp / 100) * MON_DRAIN_LIFE;
if (p_ptr->hold_life)
{
msg_print("You feel your life slipping away!");
lose_exp(d / 10);
}
else
{
msg_print("You feel your life draining away!");
lose_exp(d);
}
}
break;
}
case RBE_EXP_40:
{
/* Obvious */
obvious = TRUE;
/* Take damage */
take_hit(damage, ddesc);
if (p_ptr->hold_life && (rand_int(100) < 75))
{
msg_print("You keep hold of your life force!");
}
else
{
s32b d = damroll(40, 6) + (p_ptr->exp / 100) * MON_DRAIN_LIFE;
if (p_ptr->hold_life)
{
msg_print("You feel your life slipping away!");
lose_exp(d / 10);
}
else
{
msg_print("You feel your life draining away!");
lose_exp(d);
}
}
break;
}
case RBE_EXP_80:
{
/* Obvious */
obvious = TRUE;
/* Take damage */
take_hit(damage, ddesc);
if (p_ptr->hold_life && (rand_int(100) < 50))
{
msg_print("You keep hold of your life force!");
}
else
{
s32b d = damroll(80, 6) + (p_ptr->exp / 100) * MON_DRAIN_LIFE;
if (p_ptr->hold_life)
{
msg_print("You feel your life slipping away!");
lose_exp(d / 10);
}
else
{
msg_print("You feel your life draining away!");
lose_exp(d);
}
}
break;
}
case RBE_HALLU:
{
/* Take damage */
take_hit(damage, ddesc);
/* Increase "image" */
if (!p_ptr->resist_chaos)
{
if (set_image(p_ptr->image + 3 + randint(rlev / 2)))
{
obvious = TRUE;
}
}
/* Learn about the player */
update_smart_learn(m_idx, DRS_RES_CHAOS);
break;
}
}
/* Hack -- only one of cut or stun */
if (do_cut && do_stun)
{
/* Cancel cut */
if (rand_int(100) < 50)
{
do_cut = 0;
}
/* Cancel stun */
else
{
do_stun = 0;
}
}
/* Handle cut */
if (do_cut)
{
int k;
/* Critical hit (zero if non-critical) */
tmp = monster_critical(d_dice, d_side, damage);
/* Roll for damage */
switch (tmp)
{
case 0: k = 0; break;
case 1: k = randint(5); break;
case 2: k = randint(5) + 5; break;
case 3: k = randint(20) + 20; break;
case 4: k = randint(50) + 50; break;
case 5: k = randint(100) + 100; break;
case 6: k = 300; break;
default: k = 500; break;
}
/* Apply the cut */
if (k) (void)set_cut(p_ptr->cut + k);
}
/* Handle stun */
if (do_stun)
{
int k;
/* Critical hit (zero if non-critical) */
tmp = monster_critical(d_dice, d_side, damage);
/* Roll for damage */
switch (tmp)
{
case 0: k = 0; break;
case 1: k = randint(5); break;
case 2: k = randint(10) + 10; break;
case 3: k = randint(20) + 20; break;
case 4: k = randint(30) + 30; break;
case 5: k = randint(40) + 40; break;
case 6: k = 100; break;
default: k = 200; break;
}
/* Apply the stun */
if (k) (void)set_stun(p_ptr->stun + k);
}
}
/* Monster missed player */
else
{
/* Analyze failed attacks */
switch (method)
{
case RBM_HIT:
case RBM_TOUCH:
case RBM_PUNCH:
case RBM_KICK:
case RBM_CLAW:
case RBM_BITE:
case RBM_STING:
case RBM_XXX1:
case RBM_BUTT:
case RBM_CRUSH:
case RBM_ENGULF:
case RBM_XXX2:
/* Visible monsters */
if (m_ptr->ml)
{
/* Disturbing */
disturb(1, 0);
/* Message */
msg_format("%^s misses you.", m_name);
}
break;
}
}
/* Analyze "visible" monsters only */
if (visible)
{
/* Count "obvious" attacks (and ones that cause damage) */
if (obvious || damage || (l_ptr->blows[ap_cnt] > 10))
{
/* Count attacks of this type */
if (l_ptr->blows[ap_cnt] < MAX_UCHAR)
{
l_ptr->blows[ap_cnt]++;
}
}
}
}
/* Blink away */
if (blinked)
{
msg_print("There is a puff of smoke!");
teleport_away(m_idx, MAX_SIGHT * 2 + 5);
}
/* Always notice cause of death */
if (p_ptr->is_dead && (l_ptr->deaths < MAX_SHORT))
{
l_ptr->deaths++;
}
/* Assume we attacked */
return (TRUE);
}
/*
* Open a closed/locked/jammed door or a closed/locked chest.
*
* Unlocking a locked door/chest is worth one experience point.
*/
void do_cmd_open(cmd_code code, cmd_arg args[])
{
int y, x, dir;
s16b o_idx;
bool more = FALSE;
dir = args[0].direction;
/* Get location */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
/* Check for chests */
o_idx = chest_check(y, x);
/* Verify legality */
if (!o_idx && !do_cmd_open_test(y, x))
{
/* Cancel repeat */
disturb(0, 0);
return;
}
/* Take a turn */
p_ptr->energy_use = 100;
/* Apply confusion */
if (confuse_dir(&dir))
{
/* Get location */
y = p_ptr->py + ddy[dir];
x = p_ptr->px + ddx[dir];
/* Check for chest */
o_idx = chest_check(y, x);
}
/* Monster */
if (cave_m_idx[y][x] > 0)
{
if (mon_list[cave_m_idx[y][x]].align & (AL_PET_MASK))
msg_print("There is a friendly monster in the way!");
else
{
/* Message */
msg_print("There is a monster in the way!");
/* Attack */
py_attack(y, x);
}
}
/* Chest */
else if (o_idx)
{
/* Open the chest */
more = do_cmd_open_chest(y, x, o_idx);
}
/* Door */
else
{
/* Open the door */
more = do_cmd_open_aux(y, x);
}
/* Cancel repeat unless we may continue */
if (!more) disturb(0, 0);
}
