/**
* Gets miscellaneous combat information about the given object.
*
* Fills in whether there is a special effect when thrown in `thrown effect`,
* the `range` in ft (or zero if not ammo), whether the weapon has the
* impact flag set, the percentage chance of breakage and whether it is
* too heavy to be weilded effectively at the moment.
*/
static void obj_known_misc_combat(const struct object *obj, bool *thrown_effect, int *range, bool *impactful, int *break_chance, bool *too_heavy)
{
struct object *bow = equipped_item_by_slot_name(player, "shooting");
bool weapon = tval_is_melee_weapon(obj);
bool ammo = (player->state.ammo_tval == obj->tval) &&
(bow);
bitflag f[OF_SIZE];
*thrown_effect = *impactful = *too_heavy = false;
*range = *break_chance = 0;
get_known_flags(obj, 0, f);
if (!weapon && !ammo) {
/* Potions can have special text */
if (tval_is_potion(obj) && obj->dd != 0 && obj->ds != 0 &&
object_flavor_is_aware(obj))
*thrown_effect = true;
}
if (ammo)
*range = 10 * MIN(6 + 2 * player->state.ammo_mult, z_info->max_range);
/* Note the impact flag */
*impactful = of_has(f, OF_IMPACT);
/* Add breakage chance */
*break_chance = breakage_chance(obj, true);
/* Is the weapon too heavy? */
if (weapon) {
struct player_state state;
int weapon_slot = slot_by_name(player, "weapon");
struct object *current = equipped_item_by_slot_name(player, "weapon");
/* Pretend we're wielding the object */
player->body.slots[weapon_slot].obj = (struct object *) obj;
/* Calculate the player's hypothetical state */
calc_bonuses(player, &state, true, false);
/* Stop pretending */
player->body.slots[weapon_slot].obj = current;
/* Warn about heavy weapons */
*too_heavy = state.heavy_wield;
}
}
/**
* Gets miscellaneous combat information about the given object.
*
* Fills in whether there is a special effect when thrown in `thrown effect`,
* the `range` in ft (or zero if not ammo), the percentage chance of breakage
* and whether it is too heavy to be wielded effectively at the moment.
*/
static void obj_known_misc_combat(const struct object *obj, bool *thrown_effect,
int *range, int *break_chance, bool *heavy)
{
struct object *bow = equipped_item_by_slot_name(player, "shooting");
bool weapon = tval_is_melee_weapon(obj);
bool ammo = (player->state.ammo_tval == obj->tval) && (bow);
*thrown_effect = *heavy = false;
*range = *break_chance = 0;
if (!weapon && !ammo) {
/* Potions can have special text */
if (tval_is_potion(obj) && obj->dd != 0 && obj->ds != 0 &&
object_flavor_is_aware(obj))
*thrown_effect = true;
}
if (ammo)
*range = 10 * MIN(6 + 2 * player->state.ammo_mult, z_info->max_range);
/* Add breakage chance */
*break_chance = breakage_chance(obj, true);
/* Is the weapon too heavy? */
if (weapon) {
struct player_state state;
int weapon_slot = slot_by_name(player, "weapon");
struct object *current = equipped_item_by_slot_name(player, "weapon");
/* Pretend we're wielding the object */
player->body.slots[weapon_slot].obj = (struct object *) obj;
/* Calculate the player's hypothetical state */
memcpy(&state, &player->state, sizeof(state));
state.stat_ind[STAT_STR] = 0; //Hack - NRM
state.stat_ind[STAT_DEX] = 0; //Hack - NRM
calc_bonuses(player, &state, true, false);
/* Stop pretending */
player->body.slots[weapon_slot].obj = current;
/* Warn about heavy weapons */
*heavy = state.heavy_wield;
}
}
/*
* Describe combat advantages.
*/
static bool describe_combat(textblock *tb, const object_type *o_ptr,
oinfo_detail_t mode)
{
bool full = mode & OINFO_FULL;
const char *desc[SL_MAX] = { 0 };
int i;
int mult[SL_MAX];
int cnt, dam, total_dam, plus = 0;
int xtra_postcrit = 0, xtra_precrit = 0;
int crit_mult, crit_div, crit_add;
int str_plus, dex_plus, old_blows = 0, new_blows, extra_blows;
int str_faster = -1, str_done = -1;
object_type *bow = &p_ptr->inventory[INVEN_BOW];
bitflag f[OF_SIZE], tmp_f[OF_SIZE], mask[OF_SIZE];
bool weapon = (wield_slot(o_ptr) == INVEN_WIELD);
bool ammo = (p_ptr->state.ammo_tval == o_ptr->tval) &&
(bow->kind);
int multiplier = 1;
/* Create the "all slays" mask */
create_mask(mask, FALSE, OFT_SLAY, OFT_KILL, OFT_BRAND, OFT_MAX);
/* Abort if we've nothing to say */
if (mode & OINFO_DUMMY) return FALSE;
if (!weapon && !ammo)
{
/* Potions can have special text */
if (o_ptr->tval != TV_POTION ||
o_ptr->dd == 0 || o_ptr->ds == 0 ||
!object_flavor_is_aware(o_ptr))
return FALSE;
textblock_append(tb, "It can be thrown at creatures with damaging effect.\n");
return TRUE;
}
if (full) {
object_flags(o_ptr, f);
} else {
object_flags_known(o_ptr, f);
}
textblock_append_c(tb, TERM_L_WHITE, "Combat info:\n");
if (weapon)
{
/*
* Get the player's hypothetical state, were they to be
* wielding this item.
*/
player_state state;
int dex_plus_bound;
int str_plus_bound;
object_type inven[INVEN_TOTAL];
memcpy(inven, p_ptr->inventory, INVEN_TOTAL * sizeof(object_type));
inven[INVEN_WIELD] = *o_ptr;
if (full) object_know_all_flags(&inven[INVEN_WIELD]);
calc_bonuses(inven, &state, TRUE);
dex_plus_bound = STAT_RANGE - state.stat_ind[A_DEX];
str_plus_bound = STAT_RANGE - state.stat_ind[A_STR];
dam = ((o_ptr->ds + 1) * o_ptr->dd * 5);
xtra_postcrit = state.dis_to_d * 10;
if (object_attack_plusses_are_visible(o_ptr))
{
xtra_precrit += o_ptr->to_d * 10;
plus += o_ptr->to_h;
}
calculate_melee_crits(&state, o_ptr->weight, plus,
&crit_mult, &crit_add, &crit_div);
/* Warn about heavy weapons */
if (adj_str_hold[state.stat_ind[A_STR]] < o_ptr->weight / 10)
textblock_append_c(tb, TERM_L_RED, "You are too weak to use this weapon.\n");
textblock_append_c(tb, TERM_L_GREEN, "%d.%d ",
state.num_blows / 100, (state.num_blows / 10) % 10);
textblock_append(tb, "blow%s/round.\n",
(state.num_blows > 100) ? "s" : "");
/* Check to see if extra STR or DEX would yield extra blows */
old_blows = state.num_blows;
extra_blows = 0;
/* First we need to look for extra blows on other items, as
* state does not track these */
for (i = INVEN_BOW; i < INVEN_TOTAL; i++)
{
if (!p_ptr->inventory[i].kind)
continue;
object_flags_known(&p_ptr->inventory[i], tmp_f);
if (of_has(tmp_f, OF_BLOWS))
extra_blows += p_ptr->inventory[i].pval[which_pval(&p_ptr->inventory[i], OF_BLOWS)];
}
/* Then we add blows from the weapon being examined */
if (of_has(f, OF_BLOWS))
extra_blows += o_ptr->pval[which_pval(o_ptr, OF_BLOWS)];
/* Then we check for extra "real" blows */
for (dex_plus = 0; dex_plus < dex_plus_bound; dex_plus++)
{
for (str_plus = 0; str_plus < str_plus_bound; str_plus++)
{
state.stat_ind[A_STR] += str_plus;
state.stat_ind[A_DEX] += dex_plus;
new_blows = calc_blows(o_ptr, &state, extra_blows);
/* Test to make sure that this extra blow is a
* new str/dex combination, not a repeat
*/
if ((new_blows - new_blows % 10) > (old_blows - old_blows % 10) &&
(str_plus < str_done ||
str_done == -1))
{
textblock_append(tb, "With +%d STR and +%d DEX you would get %d.%d blows\n",
str_plus, dex_plus, (new_blows / 100),
(new_blows / 10) % 10);
state.stat_ind[A_STR] -= str_plus;
state.stat_ind[A_DEX] -= dex_plus;
str_done = str_plus;
break;
}
/* If the combination doesn't increment
* the displayed blows number, it might still
* take a little less energy
*/
if (new_blows > old_blows &&
(str_plus < str_faster ||
str_faster == -1) &&
(str_plus < str_done ||
str_done == -1))
{
textblock_append(tb, "With +%d STR and +%d DEX you would attack a bit faster\n",
str_plus, dex_plus);
state.stat_ind[A_STR] -= str_plus;
state.stat_ind[A_DEX] -= dex_plus;
str_faster = str_plus;
continue;
}
state.stat_ind[A_STR] -= str_plus;
state.stat_ind[A_DEX] -= dex_plus;
}
}
}
else
{
int tdis = 6 + 2 * p_ptr->state.ammo_mult;
if (object_attack_plusses_are_visible(o_ptr))
plus += o_ptr->to_h;
calculate_missile_crits(&p_ptr->state, o_ptr->weight, plus,
&crit_mult, &crit_add, &crit_div);
/* Calculate damage */
dam = ((o_ptr->ds + 1) * o_ptr->dd * 5);
if (object_attack_plusses_are_visible(o_ptr))
dam += (o_ptr->to_d * 10);
if (object_attack_plusses_are_visible(bow))
dam += (bow->to_d * 10);
/* Apply brands/slays from the shooter to the ammo, but only if known
* Note that this is not dependent on mode, so that viewing shop-held
* ammo (fully known) does not leak information about launcher */
object_flags_known(bow, tmp_f);
of_union(f, tmp_f);
textblock_append(tb, "Hits targets up to ");
textblock_append_c(tb, TERM_L_GREEN, format("%d", tdis * 10));
textblock_append(tb, " feet away.\n");
}
/* Collect slays */
/* Melee weapons get slays and brands from other items now */
if (weapon)
{
bool nonweap = FALSE;
for (i = INVEN_LEFT; i < INVEN_TOTAL; i++)
{
if (!p_ptr->inventory[i].kind)
continue;
object_flags_known(&p_ptr->inventory[i], tmp_f);
of_inter(tmp_f, mask); /* strip out non-slays */
if (of_union(f, tmp_f))
nonweap = TRUE;
}
if (nonweap)
textblock_append(tb, "This weapon may benefit from one or more off-weapon brands or slays.\n");
}
textblock_append(tb, "Average damage/round: ");
if (ammo) multiplier = p_ptr->state.ammo_mult;
cnt = list_slays(f, mask, desc, NULL, mult, TRUE);
for (i = 0; i < cnt; i++)
{
int melee_adj_mult = ammo ? 0 : 1; /* ammo mult adds fully, melee mult is times 1, so adds 1 less */
/* Include bonus damage and slay in stated average */
total_dam = dam * (multiplier + mult[i] - melee_adj_mult) + xtra_precrit;
total_dam = (total_dam * crit_mult + crit_add) / crit_div;
total_dam += xtra_postcrit;
if (weapon)
total_dam = (total_dam * old_blows) / 100;
else
total_dam *= p_ptr->state.num_shots;
if (total_dam <= 0)
textblock_append_c(tb, TERM_L_RED, "%d", 0);
else if (total_dam % 10)
textblock_append_c(tb, TERM_L_GREEN, "%d.%d",
total_dam / 10, total_dam % 10);
else
textblock_append_c(tb, TERM_L_GREEN, "%d", total_dam / 10);
textblock_append(tb, " vs. %s, ", desc[i]);
}
if (cnt) textblock_append(tb, "and ");
/* Include bonus damage in stated average */
total_dam = dam * multiplier + xtra_precrit;
total_dam = (total_dam * crit_mult + crit_add) / crit_div;
total_dam += xtra_postcrit;
if (weapon)
total_dam = (total_dam * old_blows) / 100;
else
total_dam *= p_ptr->state.num_shots;
if (total_dam <= 0)
textblock_append_c(tb, TERM_L_RED, "%d", 0);
else if (total_dam % 10)
textblock_append_c(tb, TERM_L_GREEN, "%d.%d",
total_dam / 10, total_dam % 10);
else
textblock_append_c(tb, TERM_L_GREEN, "%d", total_dam / 10);
if (cnt) textblock_append(tb, " vs. others");
textblock_append(tb, ".\n");
/* Note the impact flag */
if (of_has(f, OF_IMPACT))
textblock_append(tb, "Sometimes creates earthquakes on impact.\n");
/* Add breakage chance */
if (ammo)
{
int chance = breakage_chance(o_ptr, TRUE);
textblock_append_c(tb, TERM_L_GREEN, "%d%%", chance);
textblock_append(tb, " chance of breaking upon contact.\n");
}
/* You always have something to say... */
return TRUE;
}
/*
* Describe combat advantages.
*/
static bool describe_combat(textblock *tb, const object_type *o_ptr,
oinfo_detail_t mode)
{
bool full = mode & OINFO_FULL;
object_type *bow = &p_ptr->inventory[INVEN_BOW];
bitflag f[OF_SIZE];
bool weapon = (wield_slot(o_ptr) == INVEN_WIELD);
bool ammo = (p_ptr->state.ammo_tval == o_ptr->tval) &&
(bow->kind);
/* The player's hypothetical state, were they to wield this item */
player_state state;
/* Abort if we've nothing to say */
if (mode & OINFO_DUMMY) return FALSE;
if (!weapon && !ammo) {
/* Potions can have special text */
if (o_ptr->tval != TV_POTION ||
o_ptr->dd == 0 || o_ptr->ds == 0 ||
!object_flavor_is_aware(o_ptr))
return FALSE;
textblock_append(tb, "It can be thrown at creatures with damaging effect.\n");
return TRUE;
}
if (full)
object_flags(o_ptr, f);
else
object_flags_known(o_ptr, f);
textblock_append_c(tb, TERM_L_WHITE, "Combat info:\n");
if (weapon) {
object_type inven[INVEN_TOTAL];
memcpy(inven, p_ptr->inventory, INVEN_TOTAL * sizeof(object_type));
inven[INVEN_WIELD] = *o_ptr;
if (full) object_know_all_flags(&inven[INVEN_WIELD]);
/* Calculate the player's hypothetical state */
calc_bonuses(inven, &state, TRUE);
/* Warn about heavy weapons */
if (adj_str_hold[state.stat_ind[A_STR]] < o_ptr->weight / 10)
textblock_append_c(tb, TERM_L_RED, "You are too weak to use this weapon.\n");
/* Describe blows */
describe_blows(tb, o_ptr, state, f);
} else { /* Ammo */
/* Range of the weapon */
int tdis = 6 + 2 * p_ptr->state.ammo_mult;
/* Output the range */
textblock_append(tb, "Hits targets up to ");
textblock_append_c(tb, TERM_L_GREEN, format("%d", tdis * 10));
textblock_append(tb, " feet away.\n");
}
/* Describe damage */
describe_damage(tb, o_ptr, state, f, mode);
/* Note the impact flag */
if (of_has(f, OF_IMPACT))
textblock_append(tb, "Sometimes creates earthquakes on impact.\n");
/* Add breakage chance */
if (ammo) {
int chance = breakage_chance(o_ptr, TRUE);
textblock_append_c(tb, TERM_L_GREEN, "%d%%", chance);
textblock_append(tb, " chance of breaking upon contact.\n");
}
/* Something has been said */
return TRUE;
}
/**
* 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);
}
}
/**
* 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);
}
/*
* Fire an object from the pack or floor.
*
* You may only fire items that "match" your missile launcher.
*
* See "calc_bonuses()" for more calculations and such.
*
* Note that "firing" a missile is MUCH better than "throwing" it.
*
* Note: "unseen" monsters are very hard to hit.
*
* Objects are more likely to break if they "attempt" to hit a monster.
*
* Rangers (with Bows) and Anyone (with "Extra Shots") get extra shots.
* The "extra shot" code works by decreasing the amount of energy
* required to make each shot, spreading the shots out over time.
*
* Note that when firing missiles, the launcher multiplier is applied
* after all the bonuses are added in, making multipliers very useful.
*
* Note that Bows of "Extra Might" get extra range and an extra bonus
* for the damage multiplier.
*/
void do_cmd_fire(cmd_code code, cmd_arg args[])
{
int dir, item;
int i, j, y, x;
s16b ty, tx;
int tdam, tdis, thits;
int bonus, chance;
object_type *o_ptr;
object_type *j_ptr;
object_type *i_ptr;
object_type object_type_body;
bool hit_body = FALSE;
byte missile_attr;
char missile_char;
char o_name[80];
u32b msg_type = 0;
int path_n;
u16b path_g[256];
int msec = op_ptr->delay_factor * op_ptr->delay_factor;
/* Get the "bow" */
j_ptr = &p_ptr->inventory[INVEN_BOW];
/* Require a usable launcher */
if (!j_ptr->tval || !p_ptr->state.ammo_tval)
{
msg_print("You have nothing to fire with.");
return;
}
/* Get item to fire and direction to fire in. */
item = args[0].item;
dir = args[1].direction;
/* Check the item being fired is usable by the player. */
if (!item_is_available(item, NULL, (USE_EQUIP | USE_INVEN | USE_FLOOR)))
{
msg_format("That item is not within your reach.");
return;
}
/* Get the object for the ammo */
o_ptr = object_from_item_idx(item);
/* Check the ammo can be used with the launcher */
if (o_ptr->tval != p_ptr->state.ammo_tval)
{
msg_format("That ammo cannot be fired by your current weapon.");
return;
}
/* Base range XXX XXX */
tdis = 6 + 2 * p_ptr->state.ammo_mult;
/* Start at the player */
x = p_ptr->px;
y = p_ptr->py;
/* Predict the "target" location */
ty = y + 99 * ddy[dir];
tx = x + 99 * ddx[dir];
/* Check for target validity */
if ((dir == 5) && target_okay())
{
target_get(&tx, &ty);
if (distance(y, x, ty, tx) > tdis)
{
if (!get_check("Target out of range. Fire anyway? "))
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);
/* Find the color and symbol for the object for throwing */
missile_attr = object_attr(o_ptr);
missile_char = object_char(o_ptr);
/* Use the proper number of shots */
thits = p_ptr->state.num_fire;
/* Actually "fire" the object */
bonus = (p_ptr->state.to_h + o_ptr->to_h + j_ptr->to_h);
chance = p_ptr->state.skills[SKILL_TO_HIT_BOW] +
(bonus * BTH_PLUS_ADJ);
/* Take a (partial) turn */
p_ptr->energy_use = (100 / thits);
/* Calculate the path */
path_n = project_path(path_g, tdis, y, x, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff();
/* 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))
{
/* Visual effects */
print_rel(missile_char, missile_attr, y, x);
move_cursor_relative(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
Term_xtra(TERM_XTRA_DELAY, msec);
light_spot(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
}
/* Delay anyway for consistency */
else
{
/* Pause anyway, for consistancy */
Term_xtra(TERM_XTRA_DELAY, msec);
}
/* Handle monster */
if (cave_m_idx[y][x] > 0)
{
monster_type *m_ptr = &mon_list[cave_m_idx[y][x]];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int visible = m_ptr->ml;
int multiplier = 1;
const char *hit_verb = "hits";
const slay_t *best_s_ptr = NULL;
/* Note the collision */
hit_body = TRUE;
/* Did we hit it (penalize distance travelled) */
if (test_hit(chance2, r_ptr->ac, m_ptr->ml))
{
bool fear = FALSE;
/* Assume a default death */
cptr note_dies = " dies.";
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr);
improve_attack_modifier(j_ptr, m_ptr, &best_s_ptr);
if (best_s_ptr != NULL)
hit_verb = best_s_ptr->range_verb;
/* Some monsters get "destroyed" */
if (monster_is_unusual(r_ptr))
{
/* Special note at death */
note_dies = " is destroyed.";
}
/* Calculate multiplier */
multiplier = p_ptr->state.ammo_mult;
if (best_s_ptr != NULL) multiplier += best_s_ptr->mult;
/* Apply damage: multiplier, slays, criticals, bonuses */
tdam = damroll(o_ptr->dd, o_ptr->ds);
tdam += o_ptr->to_d + j_ptr->to_d;
tdam *= multiplier;
tdam = critical_shot(o_ptr->weight, o_ptr->to_h, tdam, &msg_type);
object_notice_attack_plusses(o_ptr);
object_notice_attack_plusses(&p_ptr->inventory[INVEN_BOW]);
/* No negative damage; change verb if no damage done */
if (tdam <= 0)
{
tdam = 0;
hit_verb = "fail to harm";
}
/* Handle unseen monster */
if (!visible)
{
/* Invisible monster */
message_format(MSG_SHOOT_HIT, 0, "The %s finds a mark.", o_name);
}
/* Handle visible monster */
else
{
char m_name[80];
/* Get "the monster" or "it" */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Tell the player what happened */
if (msg_type == MSG_SHOOT_HIT)
message_format(MSG_SHOOT_HIT, 0, "The %s %s %s.", o_name, hit_verb, m_name);
else
{
if (msg_type == MSG_HIT_GOOD)
{
message_format(MSG_HIT_GOOD, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a good hit!");
}
else if (msg_type == MSG_HIT_GREAT)
{
message_format(MSG_HIT_GREAT, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a great hit!");
}
else if (msg_type == MSG_HIT_SUPERB)
{
message_format(MSG_HIT_SUPERB, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a superb hit!");
}
}
/* Hack -- Track this monster race */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Hack -- Track this monster */
if (m_ptr->ml) health_track(cave_m_idx[y][x]);
}
/* Complex message */
if (p_ptr->wizard)
{
msg_format("You do %d (out of %d) damage.",
tdam, m_ptr->hp);
}
/* Hit the monster, check for death */
if (mon_take_hit(cave_m_idx[y][x], tdam, &fear, note_dies))
{
/* Dead monster */
}
/* No death */
else
{
/* Message */
message_pain(cave_m_idx[y][x], tdam);
/* Take note */
if (fear && m_ptr->ml)
{
char m_name[80];
/* Get the monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Message */
message_format(MSG_FLEE, m_ptr->r_idx,
"%^s flees in terror!", m_name);
}
}
}
/* Stop looking */
break;
}
}
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Single object */
i_ptr->number = 1;
if (item >= 0)
{
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
}
/* Reduce and describe floor item */
else
{
floor_item_increase(0 - item, -1);
floor_item_optimize(0 - item);
}
/* Chance of breakage (during attacks) */
j = (hit_body ? breakage_chance(i_ptr) : 0);
/* Drop (or break) near that location */
drop_near(i_ptr, j, y, x, TRUE);
}
/*
* Throw an object from the pack or floor.
*
* Note: "unseen" monsters are very hard to hit.
*
* Should throwing a weapon do full damage? Should it allow the magic
* to hit bonus of the weapon to have an effect? Should it ever cause
* the item to be destroyed? Should it do any damage at all?
*/
void do_cmd_throw(cmd_code code, cmd_arg args[])
{
int dir, item;
int i, j, y, x;
s16b ty, tx;
int chance, tdam, tdis;
int weight;
object_type *o_ptr;
object_type *i_ptr;
object_type object_type_body;
bool hit_body = FALSE;
byte missile_attr;
char missile_char;
char o_name[80];
u32b msg_type = 0;
int path_n;
u16b path_g[256];
int msec = op_ptr->delay_factor * op_ptr->delay_factor;
/* Get item to throw and direction in which to throw it. */
item = args[0].item;
dir = args[1].direction;
/* Make sure the player isn't throwing wielded items */
if (item >= INVEN_WIELD && item < QUIVER_START)
{
msg_print("You have cannot throw wielded items.");
return;
}
/* Check the item being thrown is usable by the player. */
if (!item_is_available(item, NULL, (USE_EQUIP | USE_INVEN | USE_FLOOR)))
{
msg_format("That item is not within your reach.");
return;
}
/* Get the object */
o_ptr = object_from_item_idx(item);
object_notice_on_firing(o_ptr);
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Distribute the charges of rods/wands/staves between the stacks */
distribute_charges(o_ptr, i_ptr, 1);
/* Single object */
i_ptr->number = 1;
/* Reduce and describe inventory */
if (item >= 0)
{
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
}
/* Reduce and describe floor item */
else
{
floor_item_increase(0 - item, -1);
floor_item_optimize(0 - item);
}
/* Description */
object_desc(o_name, sizeof(o_name), i_ptr, ODESC_FULL);
/* Find the color and symbol for the object for throwing */
missile_attr = object_attr(i_ptr);
missile_char = object_char(i_ptr);
/* Enforce a minimum "weight" of one pound */
weight = ((i_ptr->weight > 10) ? i_ptr->weight : 10);
/* Hack -- Distance -- Reward strength, penalize weight */
tdis = (adj_str_blow[p_ptr->state.stat_ind[A_STR]] + 20) * 10 / weight;
/* Max distance of 10 */
if (tdis > 10) tdis = 10;
/* Hack -- Base damage from thrown object */
tdam = damroll(i_ptr->dd, i_ptr->ds);
if (!tdam) tdam = 1;
tdam += i_ptr->to_d;
/* Chance of hitting */
chance = (p_ptr->state.skills[SKILL_TO_HIT_THROW] + (p_ptr->state.to_h * BTH_PLUS_ADJ));
/* Take a turn */
p_ptr->energy_use = 100;
/* Start at the player */
y = p_ptr->py;
x = p_ptr->px;
/* Predict the "target" location */
ty = p_ptr->py + 99 * ddy[dir];
tx = p_ptr->px + 99 * ddx[dir];
/* Check for "target request" */
if ((dir == 5) && target_okay())
{
target_get(&tx, &ty);
}
/* Calculate the path */
path_n = project_path(path_g, tdis, p_ptr->py, p_ptr->px, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff();
/* 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))
{
/* Visual effects */
print_rel(missile_char, missile_attr, y, x);
move_cursor_relative(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
Term_xtra(TERM_XTRA_DELAY, msec);
light_spot(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
}
/* Delay anyway for consistency */
else
{
/* Pause anyway, for consistancy */
Term_xtra(TERM_XTRA_DELAY, msec);
}
/* Handle monster */
if (cave_m_idx[y][x] > 0)
{
monster_type *m_ptr = &mon_list[cave_m_idx[y][x]];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int visible = m_ptr->ml;
/* Note the collision */
hit_body = TRUE;
/* Did we hit it (penalize range) */
if (test_hit(chance2, r_ptr->ac, m_ptr->ml))
{
const char *hit_verb = "hits";
bool fear = FALSE;
const slay_t *best_s_ptr = NULL;
/* Assume a default death */
cptr note_dies = " dies.";
/* Some monsters get "destroyed" */
if (monster_is_unusual(r_ptr))
{
/* Special note at death */
note_dies = " is destroyed.";
}
/* Apply special damage - brought forward to fill in hit_verb XXX XXX XXX */
improve_attack_modifier(i_ptr, m_ptr, &best_s_ptr);
if (best_s_ptr != NULL)
{
tdam *= best_s_ptr->mult;
hit_verb = best_s_ptr->range_verb;
}
/* Apply special damage XXX XXX XXX */
tdam = critical_shot(i_ptr->weight, i_ptr->to_h, tdam, &msg_type);
/* No negative damage; change verb if no damage done */
if (tdam <= 0)
{
tdam = 0;
hit_verb = "fail to harm";
}
/* Handle unseen monster */
if (!visible)
{
/* Invisible monster */
msg_format("The %s finds a mark.", o_name);
}
/* Handle visible monster */
else
{
char m_name[80];
/* Get "the monster" or "it" */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Tell the player what happened */
if (msg_type == MSG_SHOOT_HIT)
message_format(MSG_SHOOT_HIT, 0, "The %s %s %s.", o_name, hit_verb, m_name);
else
{
if (msg_type == MSG_HIT_GOOD)
{
message_format(MSG_HIT_GOOD, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a good hit!");
}
else if (msg_type == MSG_HIT_GREAT)
{
message_format(MSG_HIT_GREAT, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a great hit!");
}
else if (msg_type == MSG_HIT_SUPERB)
{
message_format(MSG_HIT_SUPERB, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a superb hit!");
}
}
/* Hack -- Track this monster race */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Hack -- Track this monster */
if (m_ptr->ml) health_track(cave_m_idx[y][x]);
}
/* Learn the bonuses */
/* XXX Eddie This is messed up, better done for firing, */
/* should use that method [split last] instead */
/* check if inven_optimize removed what o_ptr referenced */
if (object_similar(i_ptr, o_ptr, OSTACK_PACK))
object_notice_attack_plusses(o_ptr);
object_notice_attack_plusses(i_ptr);
/* Complex message */
if (p_ptr->wizard)
msg_format("You do %d (out of %d) damage.",
tdam, m_ptr->hp);
/* Hit the monster, check for death */
if (mon_take_hit(cave_m_idx[y][x], tdam, &fear, note_dies))
{
/* Dead monster */
}
/* No death */
else
{
/* Message */
message_pain(cave_m_idx[y][x], tdam);
/* Take note */
if (fear && m_ptr->ml)
{
char m_name[80];
/* Get the monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Message */
message_format(MSG_FLEE, m_ptr->r_idx,
"%^s flees in terror!", m_name);
}
}
}
/* Stop looking */
break;
}
}
/* Chance of breakage (during attacks) */
j = (hit_body ? breakage_chance(i_ptr) : 0);
/* Drop (or break) near that location */
drop_near(i_ptr, j, y, x, TRUE);
}
/*
* Handle monster hitting a real trap.
*/
void mon_hit_trap(int m_idx, int y, int x)
{
feature_type *f_ptr;
monster_type *m_ptr = &m_list[m_idx];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int feat = cave_feat[y][x];
bool fear;
/* Option */
if (!variant_hit_traps) return;
/* Hack --- don't activate unknown invisible traps */
if (cave_feat[y][x] == FEAT_INVIS) return;
/* Get feature */
f_ptr = &f_info[cave_feat[y][x]];
/* Hack --- trapped doors */
/* XXX XXX Dangerous */
while (!(f_ptr->spell) && !(f_ptr->blow.method) && (f_ptr->flags1 & (FF1_TRAP)))
{
pick_trap(y,x);
/* Error */
if (cave_feat[y][x] == feat) break;
feat = cave_feat[y][x];
/* Get feature */
f_ptr = &f_info[feat];
}
/* Use covered or bridged if necessary */
if ((f_ptr->flags2 & (FF2_COVERED)) || (f_ptr->flags2 & (FF2_BRIDGED)))
{
f_ptr = &f_info[f_ptr->mimic];
}
/* Hack -- monster falls onto trap */
if ((m_ptr->fy!=y)|| (m_ptr->fx !=x))
{
/* Move monster */
monster_swap(m_ptr->fy, m_ptr->fx, y, x);
}
/* Apply the object */
if ((cave_o_idx[y][x]) && (f_ptr->flags1 & (FF1_HIT_TRAP)))
{
object_type *o_ptr = &o_list[cave_o_idx[y][x]];
char o_name[80];
int power = 0;
switch (o_ptr->tval)
{
case TV_BOW:
{
object_type *j_ptr;
u32b f1,f2,f3;
int i, shots = 1;
/* Get bow */
j_ptr = o_ptr;
/* Get bow flags */
object_flags(o_ptr,&f1,&f2,&f3);
/* Apply extra shots */
if (f1 & (TR1_SHOTS)) shots += j_ptr->pval;
/* Test for hit */
for (i = 0; i < shots; i++)
{
if (j_ptr->next_o_idx)
{
int ammo = j_ptr->next_o_idx;
object_type *i_ptr;
object_type object_type_body;
/* Use ammo instead of bow */
o_ptr = &o_list[ammo];
/* Describe ammo */
object_desc(o_name, sizeof(o_name), o_ptr, TRUE, 0);
if ((ammo) && (test_hit_fire((j_ptr->to_h + o_ptr->to_h)* BTH_PLUS_ADJ + f_ptr->power, r_ptr->ac * (r_ptr->flags2 & (RF2_ARMOR) ? 2 : 1), TRUE)))
{
int k, mult;
switch (j_ptr->sval)
{
case SV_SLING:
case SV_SHORT_BOW:
mult = 2;
break;
case SV_LONG_BOW:
case SV_LIGHT_XBOW:
mult = 3;
break;
case SV_HEAVY_XBOW:
mult = 4;
break;
default:
mult = 1;
break;
}
/* Apply extra might */
if (f1 & (TR1_MIGHT)) mult += j_ptr->pval;
k = damroll(o_ptr->dd, o_ptr->ds);
k *= mult;
k = tot_dam_aux(o_ptr, k, m_ptr);
k = critical_shot(o_ptr->weight, o_ptr->to_h + j_ptr->to_h, k);
k += o_ptr->to_d + j_ptr->to_d;
/* No negative damage */
if (k < 0) k = 0;
/* Trap description */
msg_format("%^s hits you.",o_name);
/* Damage, check for fear and death */
(void)mon_take_hit(cave_m_idx[y][x], k, &fear, NULL);
}
else
{
/* Trap description */
msg_format("%^s narrowly misses you.",o_name);
}
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Modify quantity */
i_ptr->number = 1;
/* Drop nearby - some chance of breakage */
drop_near(i_ptr,y,x,breakage_chance(i_ptr));
/* Decrease the item */
floor_item_increase(ammo, -1);
floor_item_optimize(ammo);
break;
}
else
{
/* Disarm */
cave_alter_feat(y,x,FS_DISARM);
}
}
}
case TV_SHOT:
case TV_ARROW:
case TV_BOLT:
case TV_HAFTED:
case TV_SWORD:
case TV_POLEARM:
{
object_type *i_ptr;
object_type object_type_body;
/* Describe ammo */
object_desc(o_name, sizeof(o_name), o_ptr, TRUE, 0);
/* Test for hit */
if (test_hit_norm(o_ptr->to_h * BTH_PLUS_ADJ + f_ptr->power, r_ptr->ac, TRUE))
{
int k;
k = damroll(o_ptr->dd, o_ptr->ds);
k = tot_dam_aux(o_ptr, k, m_ptr);
k = critical_norm(o_ptr->weight, o_ptr->to_h, k);
k += o_ptr->to_d;
/* Armour reduces total damage */
k -= (k * ((p_ptr->ac < 150) ? p_ptr->ac : 150) / 250);
/* No negative damage */
if (k < 0) k = 0;
/* Trap description */
msg_format("%^s hits you.",o_name);
/* Damage, check for fear and death */
(void)mon_take_hit(cave_m_idx[y][x], k, &fear, NULL);
}
else
{
/* Trap description */
msg_format("%^s narrowly misses you.",o_name);
}
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Modify quantity */
i_ptr->number = 1;
/* Drop nearby - some chance of breakage */
drop_near(i_ptr,y,x,breakage_chance(i_ptr));
/* Decrease the item */
floor_item_increase(cave_o_idx[y][x], -1);
floor_item_optimize(cave_o_idx[y][x]);
/* Disarm if runs out */
if (!cave_o_idx[y][x]) cave_alter_feat(y,x,FS_DISARM);
break;
}
case TV_WAND:
case TV_STAFF:
{
if (o_ptr->pval > 0)
{
/* Get item effect */
get_spell(&power, "use", o_ptr, FALSE);
/* XXX Hack -- new unstacking code */
o_ptr->stackc++;
/* No spare charges */
if (o_ptr->stackc >= o_ptr->number)
{
/* Use a charge off the stack */
o_ptr->pval--;
/* Reset the stack count */
o_ptr->stackc = 0;
}
/* XXX Hack -- unstack if necessary */
if ((o_ptr->number > 1) &&
((!variant_pval_stacks) ||
((!object_known_p(o_ptr) && (o_ptr->pval == 2) && (o_ptr->stackc > 1)) ||
(!object_known_p(o_ptr) && (rand_int(o_ptr->number) <= o_ptr->stackc) &&
(o_ptr->stackc != 1) && (o_ptr->pval > 2)))))
{
object_type *i_ptr;
object_type object_type_body;
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Modify quantity */
i_ptr->number = 1;
/* Reset stack counter */
i_ptr->stackc = 0;
/* Unstack the used item */
o_ptr->number--;
/* Reduce the charges on the new item */
if (o_ptr->stackc > 1)
{
i_ptr->pval-=2;
o_ptr->stackc--;
}
else if (!o_ptr->stackc)
{
i_ptr->pval--;
o_ptr->pval++;
o_ptr->stackc = o_ptr->number-1;
}
(void)floor_carry(y,x,i_ptr);
}
}
else
{
/* Disarm if runs out */
cave_alter_feat(y,x,FS_DISARM);
}
break;
}
case TV_ROD:
case TV_DRAG_ARMOR:
{
if (!((o_ptr->timeout) && ((!o_ptr->stackc) || (o_ptr->stackc >= o_ptr->number))))
{
int tmpval;
/* Store pval */
tmpval = o_ptr->timeout;
/* Time rod out */
o_ptr->timeout = o_ptr->pval;
/* Get item effect */
get_spell(&power, "use", o_ptr, FALSE);
/* Has a power */
/* Hack -- check if we are stacking rods */
if ((o_ptr->timeout > 0) && (!(tmpval) || stack_force_times))
{
/* Hack -- one more rod charging */
if (o_ptr->timeout) o_ptr->stackc++;
/* Reset stack count */
if (o_ptr->stackc == o_ptr->number) o_ptr->stackc = 0;
/* Hack -- always use maximum timeout */
if (tmpval > o_ptr->timeout) o_ptr->timeout = tmpval;
}
/* XXX Hack -- unstack if necessary */
if ((o_ptr->number > 1) && (o_ptr->timeout > 0))
{
object_type *i_ptr;
object_type object_type_body;
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Modify quantity */
i_ptr->number = 1;
/* Clear stack counter */
i_ptr->stackc = 0;
/* Restore "charge" */
o_ptr->timeout = tmpval;
/* Unstack the used item */
o_ptr->number--;
/* Reset the stack if required */
if (o_ptr->stackc == o_ptr->number) o_ptr->stackc = 0;
(void)floor_carry(y,x,i_ptr);
}
}
break;
}
case TV_POTION:
case TV_SCROLL:
case TV_FLASK:
case TV_FOOD:
{
/* Hack -- boring food */
if ((o_ptr->tval == TV_FOOD) && (o_ptr->sval >= SV_FOOD_MIN_FOOD))
{
/* Disarm */
cave_alter_feat(y,x,FS_DISARM);
}
else
{
/* Get item effect */
get_spell(&power, "use", o_ptr, FALSE);
/* Decrease the item */
floor_item_increase(cave_o_idx[y][x], -1);
floor_item_optimize(cave_o_idx[y][x]);
/* Disarm if runs out */
if (!cave_o_idx[y][x]) cave_alter_feat(y,x,FS_DISARM);
}
break;
}
case TV_RUNESTONE:
{
u32b runes = p_ptr->cur_runes;
int num = 0;
s16b book[26];
/* Hack -- use current rune */
p_ptr->cur_runes = (2 << (o_ptr->sval-1));
/* Fill the book with spells */
fill_book(o_ptr,book,&num);
/* Unhack */
p_ptr->cur_runes = runes;
/* Get a power */
power = book[rand_int(num)];
/* Decrease the item */
floor_item_increase(cave_o_idx[y][x], -1);
floor_item_optimize(cave_o_idx[y][x]);
/* Disarm if runs out */
if (!cave_o_idx[y][x]) cave_alter_feat(y,x,FS_DISARM);
break;
}
default:
{
/* Disarm */
cave_alter_feat(y,x,FS_DISARM);
break;
}
}
/* Has a power */
if (power > 0)
{
spell_type *s_ptr = &s_info[power];
int ap_cnt;
/* Object is used */
if (k_info[o_ptr->k_idx].used < MAX_SHORT) k_info[o_ptr->k_idx].used++;
/* Scan through all four blows */
for (ap_cnt = 0; ap_cnt < 4; ap_cnt++)
{
int damage = 0;
/* Extract the attack infomation */
int effect = s_ptr->blow[ap_cnt].effect;
int method = s_ptr->blow[ap_cnt].method;
int d_dice = s_ptr->blow[ap_cnt].d_dice;
int d_side = s_ptr->blow[ap_cnt].d_side;
int d_plus = s_ptr->blow[ap_cnt].d_plus;
/* Hack -- no more attacks */
if (!method) break;
/* Mega hack -- dispel evil/undead objects */
if (!d_side)
{
d_plus += 25 * d_dice;
}
/* Roll out the damage */
if ((d_dice) && (d_side))
{
damage = damroll(d_dice, d_side) + d_plus;
}
else
{
damage = d_plus;
}
(void)project_m(0,0,y,x,damage, effect);
(void)project_f(0,0,y,x,damage, effect);
}
}
}
/* Regular traps */
else
{
if (f_ptr->spell)
{
make_attack_spell_aux(0,y,x,f_ptr->spell);
}
else if (f_ptr->blow.method)
{
int damage = damroll(f_ptr->blow.d_side,f_ptr->blow.d_dice);
/* Apply the blow */
project_m(0, 0, y, x, damage, f_ptr->blow.effect);
}
/* Get feature */
f_ptr = &f_info[cave_feat[p_ptr->py][p_ptr->px]];
if (f_ptr->flags1 & (FF1_HIT_TRAP))
{
/* Modify the location hit by the trap */
cave_alter_feat(y,x,FS_HIT_TRAP);
}
else if (f_ptr->flags1 & (FF1_SECRET))
{
/* Discover */
cave_alter_feat(y,x,FS_SECRET);
}
}
}
