/**
* Attack the monster at the given location
*
* We get blows until energy drops below that required for another blow, or
* until the target monster dies. Each blow is handled by py_attack_real().
* We don't allow @ to spend more than 100 energy in one go, to avoid slower
* monsters getting double moves.
*/
void py_attack(int y, int x)
{
int blow_energy = 100 * z_info->move_energy / player->state.num_blows;
int blows = 0;
bool fear = FALSE;
struct monster *mon = square_monster(cave, y, x);
/* disturb the player */
disturb(player, 0);
/* Initialize the energy used */
player->upkeep->energy_use = 0;
/* Attack until energy runs out or enemy dies. We limit energy use to 100
* to avoid giving monsters a possible double move. */
while (player->energy >= blow_energy * (blows + 1)) {
bool stop = py_attack_real(y, x, &fear);
player->upkeep->energy_use += blow_energy;
if (player->upkeep->energy_use + blow_energy > z_info->move_energy ||
stop) break;
blows++;
}
/* Hack - delay fear messages */
if (fear && mflag_has(mon->mflag, MFLAG_VISIBLE)) {
char m_name[80];
/* Don't set monster_desc flags, since add_monster_message does string
* processing on m_name */
monster_desc(m_name, sizeof(m_name), mon, MDESC_DEFAULT);
add_monster_message(m_name, mon, MON_MSG_FLEE_IN_TERROR, TRUE);
}
}
/**
* Attack the monster at the given location
*
* We get blows until energy drops below that required for another blow, or
* until the target monster dies. Each blow is handled by py_attack_real().
* We don't allow @ to spend more than 100 energy in one go, to avoid slower
* monsters getting double moves.
*/
void py_attack(int y, int x) {
int blow_energy = 10000 / p_ptr->state.num_blows;
int blows = 0;
bool fear = FALSE;
monster_type *m_ptr = cave_monster(cave, cave->m_idx[y][x]);
/* disturb the player */
disturb(p_ptr, 0,0);
/* Initialize the energy used */
p_ptr->energy_use = 0;
/* Attack until energy runs out or enemy dies. We limit energy use to 100
* to avoid giving monsters a possible double move. */
while (p_ptr->energy >= blow_energy * (blows + 1)) {
bool stop = py_attack_real(y, x, &fear);
p_ptr->energy_use += blow_energy;
if (stop || p_ptr->energy_use + blow_energy > 100) break;
blows++;
}
/* Hack - delay fear messages */
if (fear && m_ptr->ml) {
char m_name[80];
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
add_monster_message(m_name, cave->m_idx[y][x], MON_MSG_FLEE_IN_TERROR, TRUE);
}
}
/**
* Adds to the message queue a message describing a monster's reaction
* to damage.
*/
void message_pain(int m_idx, int dam)
{
long oldhp, newhp, tmp;
int percentage;
monster_type *m_ptr;
int msg_code = MON_MSG_UNHARMED;
char m_name[80];
assert(m_idx > 0);
m_ptr = cave_monster(cave, m_idx);
/* Get the monster name */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Notice non-damage */
if (dam == 0)
{
add_monster_message(m_name, m_idx, msg_code, FALSE);
return;
}
/* Note -- subtle fix -CFT */
newhp = (long)(m_ptr->hp);
oldhp = newhp + (long)(dam);
tmp = (newhp * 100L) / oldhp;
percentage = (int)(tmp);
if (percentage > 95)
msg_code = MON_MSG_95;
else if (percentage > 75)
msg_code = MON_MSG_75;
else if (percentage > 50)
msg_code = MON_MSG_50;
else if (percentage > 35)
msg_code = MON_MSG_35;
else if (percentage > 20)
msg_code = MON_MSG_20;
else if (percentage > 10)
msg_code = MON_MSG_10;
else
msg_code = MON_MSG_0;
add_monster_message(m_name, m_idx, msg_code, FALSE);
}
/**
* Attempts to set the timer of the given monster effect to `timer`.
*
* Checks to see if the monster resists the effect, using mon_resist_effect().
* If not, the effect is set to `timer` turns. If `timer` is 0, or if the
* effect timer was 0, or if MON_TMD_FLG_NOTIFY is set in `flag`, then a
* message is printed, unless MON_TMD_FLG_NOMESSAGE is set in `flag`.
*
* Set a timed monster event to 'v'. Give messages if the right flags are set.
* Check if the monster is able to resist the spell. Mark the lore.
* Returns TRUE if the monster was affected.
* Return FALSE if the monster was unaffected.
*/
static bool mon_set_timed(monster_type *m_ptr, int ef_idx, int timer,
u16b flag, bool id)
{
mon_timed_effect *effect;
int m_note = 0;
int resisted;
int old_timer;
assert(ef_idx >= 0 && ef_idx < MON_TMD_MAX);
effect = &effects[ef_idx];
assert(m_ptr);
old_timer = m_ptr->m_timed[ef_idx];
/* Ignore dead monsters */
if (!m_ptr->r_idx) return FALSE;
/* No change */
if (old_timer == timer) return FALSE;
if (timer == 0) {
/* Turning off, usually mention */
m_note = effect->message_end;
flag |= MON_TMD_FLG_NOTIFY;
} else if (old_timer == 0) {
/* Turning on, usually mention */
flag |= MON_TMD_FLG_NOTIFY;
m_note = effect->message_begin;
} else if (timer > old_timer) {
/* Different message for increases, but don't automatically mention. */
m_note = effect->message_increase;
}
/* Determine if the monster resisted or not */
resisted = mon_resist_effect(m_ptr, ef_idx, timer, flag);
if (resisted)
m_note = MON_MSG_UNAFFECTED;
else
m_ptr->m_timed[ef_idx] = timer;
if (p_ptr->health_who == m_ptr->midx) p_ptr->redraw |= (PR_HEALTH);
/* Update the visuals, as appropriate. */
p_ptr->redraw |= (PR_MONLIST);
/* Print a message if there is one, if the effect allows for it, and if
* either the monster is visible, or we're trying to ID something */
if (m_note && (m_ptr->ml || id) && !(flag & MON_TMD_FLG_NOMESSAGE) &&
(flag & MON_TMD_FLG_NOTIFY)) {
char m_name[80];
monster_desc(m_name, sizeof(m_name), m_ptr, 0x04);
add_monster_message(m_name, m_ptr->midx, m_note, TRUE);
}
return !resisted;
}
/**
* Adds to the message queue a message describing a monster's reaction
* to damage.
*/
void message_pain(struct monster *m_ptr, int dam)
{
long oldhp, newhp, tmp;
int percentage;
int msg_code = MON_MSG_UNHARMED;
char m_name[80];
/* Get the monster name - don't use monster_desc flags because
* add_monster_message does string processing on m_name */
monster_desc(m_name, sizeof(m_name), m_ptr, MDESC_DEFAULT);
/* Notice non-damage */
if (dam == 0) {
add_monster_message(m_name, m_ptr, msg_code, FALSE);
return;
}
/* Note -- subtle fix -CFT */
newhp = (long)(m_ptr->hp);
oldhp = newhp + (long)(dam);
tmp = (newhp * 100L) / oldhp;
percentage = (int)(tmp);
if (percentage > 95)
msg_code = MON_MSG_95;
else if (percentage > 75)
msg_code = MON_MSG_75;
else if (percentage > 50)
msg_code = MON_MSG_50;
else if (percentage > 35)
msg_code = MON_MSG_35;
else if (percentage > 20)
msg_code = MON_MSG_20;
else if (percentage > 10)
msg_code = MON_MSG_10;
else
msg_code = MON_MSG_0;
add_monster_message(m_name, m_ptr, msg_code, FALSE);
}
/**
* 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(int item, int dir, int range, int shots, ranged_attack attack) {
/* Get the ammo */
object_type *o_ptr = object_from_item_idx(item);
int i, j;
byte missile_attr = object_attr(o_ptr);
char missile_char = object_char(o_ptr);
object_type object_type_body;
object_type *i_ptr = &object_type_body;
char o_name[80];
int path_n;
u16b path_g[256];
int msec = op_ptr->delay_factor;
/* Start at the player */
int x = p_ptr->px;
int y = p_ptr->py;
/* Predict the "target" location */
s16b ty = y + 99 * ddy[dir];
s16b tx = x + 99 * ddx[dir];
bool hit_target = FALSE;
/* Check for target validity */
if ((dir == 5) && target_okay()) {
int taim;
char msg[80];
target_get(&tx, &ty);
taim = distance(y, x, ty, tx);
if (taim > range) {
sprintf (msg, "Target out of range by %d squares. Fire anyway? ",
taim - range);
if (!get_check(msg)) return;
}
}
/* Sound */
sound(MSG_SHOOT);
object_notice_on_firing(o_ptr);
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_FULL | ODESC_SINGULAR);
/* Actually "fire" the object -- Take a partial turn */
p_ptr->energy_use = (100 / shots);
/* Calculate the path */
path_n = project_path(path_g, range, y, x, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff(p_ptr);
/* Start at the player */
x = p_ptr->px;
y = p_ptr->py;
/* Project along the path */
for (i = 0; i < path_n; ++i) {
int ny = GRID_Y(path_g[i]);
int nx = GRID_X(path_g[i]);
/* Hack -- Stop before hitting walls */
if (!cave_floor_bold(ny, nx)) break;
/* Advance */
x = nx;
y = ny;
/* Only do visuals if the player can "see" the missile */
if (player_can_see_bold(y, x)) {
print_rel(missile_char, missile_attr, y, x);
move_cursor_relative(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff(p_ptr);
Term_xtra(TERM_XTRA_DELAY, msec);
cave_light_spot(cave, y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff(p_ptr);
} else {
/* Delay anyway for consistency */
Term_xtra(TERM_XTRA_DELAY, msec);
}
/* Handle monster */
if (cave->m_idx[y][x] > 0) break;
}
/* Try the attack on the monster at (x, y) if any */
if (cave->m_idx[y][x] > 0) {
monster_type *m_ptr = cave_monster(cave, cave->m_idx[y][x]);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int visible = m_ptr->ml;
bool fear = FALSE;
char m_name[80];
const char *note_dies = monster_is_unusual(r_ptr) ? " is destroyed." : " dies.";
struct attack_result result = attack(o_ptr, y, x);
int dmg = result.dmg;
u32b msg_type = result.msg_type;
const char *hit_verb = result.hit_verb;
if (result.success) {
hit_target = TRUE;
/* Get "the monster" or "it" */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
object_notice_attack_plusses(o_ptr);
/* No negative damage; change verb if no damage done */
if (dmg <= 0) {
dmg = 0;
hit_verb = "fail to harm";
}
if (!visible) {
/* Invisible monster */
msgt(MSG_SHOOT_HIT, "The %s finds a mark.", o_name);
} else {
/* Visible monster */
if (msg_type == MSG_SHOOT_HIT)
msgt(MSG_SHOOT_HIT, "The %s %s %s.", o_name, hit_verb, m_name);
else if (msg_type == MSG_HIT_GOOD) {
msgt(MSG_HIT_GOOD, "The %s %s %s. %s", o_name, hit_verb, m_name, "It was a good hit!");
} else if (msg_type == MSG_HIT_GREAT) {
msgt(MSG_HIT_GREAT, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a great hit!");
} else if (msg_type == MSG_HIT_SUPERB) {
msgt(MSG_HIT_SUPERB, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a superb hit!");
}
/* Track this monster */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
if (m_ptr->ml) health_track(p_ptr, cave->m_idx[y][x]);
}
/* Complex message */
if (p_ptr->wizard)
msg("You do %d (out of %d) damage.", dmg, m_ptr->hp);
/* Hit the monster, check for death */
if (!mon_take_hit(cave->m_idx[y][x], dmg, &fear, note_dies)) {
message_pain(cave->m_idx[y][x], dmg);
if (fear && m_ptr->ml)
add_monster_message(m_name, cave->m_idx[y][x], MON_MSG_FLEE_IN_TERROR, TRUE);
}
}
}
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
object_split(i_ptr, o_ptr, 1);
/* See if the ammunition broke or not */
j = breakage_chance(i_ptr, hit_target);
/* Drop (or break) near that location */
drop_near(cave, i_ptr, j, y, x, TRUE);
if (item >= 0) {
/* The ammo is from the inventory */
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
} else {
/* The ammo is from the floor */
floor_item_increase(0 - item, -1);
floor_item_optimize(0 - item);
}
}
/**
* Attempts to set the timer of the given monster effect to `timer`.
*
* Checks to see if the monster resists the effect, using mon_resist_effect().
* If not, the effect is set to `timer` turns. If `timer` is 0, or if the
* effect timer was 0, or if MON_TMD_FLG_NOTIFY is set in `flag`, then a
* message is printed, unless MON_TMD_FLG_NOMESSAGE is set in `flag`.
*
* Set a timed monster event to 'v'. Give messages if the right flags are set.
* Check if the monster is able to resist the spell. Mark the lore.
* Returns true if the monster was affected.
* Return false if the monster was unaffected.
*/
static bool mon_set_timed(struct monster *mon, int ef_idx, int timer,
u16b flag, bool id)
{
bool check_resist = false;
bool resisted = false;
struct mon_timed_effect *effect;
int m_note = 0;
int old_timer;
assert(ef_idx >= 0 && ef_idx < MON_TMD_MAX);
effect = &effects[ef_idx];
assert(mon);
assert(mon->race);
old_timer = mon->m_timed[ef_idx];
/* No change */
if (old_timer == timer)
return false;
if (timer == 0) {
/* Turning off, usually mention */
m_note = effect->message_end;
flag |= MON_TMD_FLG_NOTIFY;
} else if (old_timer == 0) {
/* Turning on, usually mention */
flag |= MON_TMD_FLG_NOTIFY;
m_note = effect->message_begin;
check_resist = true;
} else if (timer > old_timer) {
/* Different message for increases, but don't automatically mention. */
m_note = effect->message_increase;
check_resist = true;
} /* Decreases don't get a message */
/* Determine if the monster resisted or not, if appropriate */
if (check_resist)
resisted = mon_resist_effect(mon, ef_idx, timer, flag);
if (resisted)
m_note = MON_MSG_UNAFFECTED;
else
mon->m_timed[ef_idx] = timer;
if (player->upkeep->health_who == mon)
player->upkeep->redraw |= (PR_HEALTH);
/* Update the visuals, as appropriate. */
player->upkeep->redraw |= (PR_MONLIST);
/* Print a message if there is one, if the effect allows for it, and if
* either the monster is visible, or we're trying to ID something */
if (m_note && !(flag & MON_TMD_FLG_NOMESSAGE) && (flag & MON_TMD_FLG_NOTIFY)
&& ((mflag_has(mon->mflag, MFLAG_VISIBLE) &&
!mflag_has(mon->mflag, MFLAG_UNAWARE)) || id)) {
char m_name[80];
monster_desc(m_name, sizeof(m_name), mon, MDESC_IND_HID);
add_monster_message(m_name, mon, m_note, true);
}
return !resisted;
}
/**
* 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);
}
