/**
* Helper function used with ranged_helper by do_cmd_fire.
*/
static struct attack_result make_ranged_shot(struct object *ammo, int y, int x)
{
char *hit_verb = mem_alloc(20 * sizeof(char));
struct attack_result result = {FALSE, 0, 0, hit_verb};
struct object *bow = equipped_item_by_slot_name(player, "shooting");
struct monster *mon = square_monster(cave, y, x);
int chance = chance_of_missile_hit(player, ammo, bow, y, x);
int multiplier = player->state.ammo_mult;
const struct brand *b = NULL;
const struct slay *s = NULL;
my_strcpy(hit_verb, "hits", sizeof(hit_verb));
/* Did we hit it (penalize distance travelled) */
if (!test_hit(chance, mon->race->ac, mflag_has(mon->mflag, MFLAG_VISIBLE)))
return result;
result.success = TRUE;
improve_attack_modifier(ammo, mon, &b, &s, result.hit_verb, TRUE, TRUE,
FALSE);
improve_attack_modifier(bow, mon, &b, &s, result.hit_verb, TRUE, TRUE,
FALSE);
result.dmg = ranged_damage(ammo, bow, b, s, multiplier);
result.dmg = critical_shot(ammo->weight, ammo->to_h, result.dmg,
&result.msg_type);
object_notice_attack_plusses(bow);
return result;
}
/**
* Helper function used with ranged_helper by do_cmd_throw.
*/
static struct attack_result make_ranged_throw(object_type *o_ptr, int y, int x) {
struct attack_result result = {FALSE, 0, 0, "hit"};
monster_type *m_ptr = cave_monster(cave, cave->m_idx[y][x]);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int bonus = p_ptr->state.to_h + o_ptr->to_h;
int chance = p_ptr->state.skills[SKILL_TO_HIT_THROW] + bonus * BTH_PLUS_ADJ;
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int multiplier = 1;
const struct slay *best_s_ptr = NULL;
/* If we missed then we're done */
if (!test_hit(chance2, r_ptr->ac, m_ptr->ml)) return result;
result.success = TRUE;
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
/* If we have a slay, modify the multiplier appropriately */
if (best_s_ptr != NULL) {
result.hit_verb = best_s_ptr->range_verb;
multiplier += best_s_ptr->mult;
}
/* Apply damage: multiplier, slays, criticals, bonuses */
result.dmg = damroll(o_ptr->dd, o_ptr->ds);
result.dmg += o_ptr->to_d;
result.dmg *= multiplier;
result.dmg = critical_norm(o_ptr->weight, o_ptr->to_h, result.dmg, &result.msg_type);
return result;
}
/**
* Helper function used with ranged_helper by do_cmd_throw.
*/
static struct attack_result make_ranged_throw(struct object *obj, int y, int x)
{
char *hit_verb = mem_alloc(20*sizeof(char));
struct attack_result result = {FALSE, 0, 0, hit_verb};
struct monster *mon = square_monster(cave, y, x);
int chance = chance_of_missile_hit(player, obj, NULL, y, x);
int multiplier = 1;
const struct brand *b = NULL;
const struct slay *s = NULL;
my_strcpy(hit_verb, "hits", sizeof(hit_verb));
/* If we missed then we're done */
if (!test_hit(chance, mon->race->ac, mflag_has(mon->mflag, MFLAG_VISIBLE)))
return result;
result.success = TRUE;
improve_attack_modifier(obj, mon, &b, &s, result.hit_verb, TRUE, TRUE,
FALSE);
result.dmg = ranged_damage(obj, NULL, b, s, multiplier);
result.dmg = critical_norm(obj->weight, obj->to_h, result.dmg,
&result.msg_type);
return result;
}
/**
* Helper function used with ranged_helper by do_cmd_fire.
*/
static struct attack_result make_ranged_shot(object_type *o_ptr, int y, int x) {
struct attack_result result = {FALSE, 0, 0, "hit"};
object_type *j_ptr = &p_ptr->inventory[INVEN_BOW];
monster_type *m_ptr = cave_monster(cave, cave->m_idx[y][x]);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int bonus = p_ptr->state.to_h + o_ptr->to_h + j_ptr->to_h;
int chance = p_ptr->state.skills[SKILL_TO_HIT_BOW] + bonus * BTH_PLUS_ADJ;
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int multiplier = p_ptr->state.ammo_mult;
const struct slay *best_s_ptr = NULL;
/* Did we hit it (penalize distance travelled) */
if (!test_hit(chance2, r_ptr->ac, m_ptr->ml)) return result;
result.success = TRUE;
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
improve_attack_modifier(j_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
/* If we have a slay, modify the multiplier appropriately */
if (best_s_ptr != NULL) {
result.hit_verb = best_s_ptr->range_verb;
multiplier += best_s_ptr->mult;
}
/* Apply damage: (((arrow_roll + bow_damage_plusses)*(bow_multiplier + slays) + arrow_damage_plusses)*criticals) + player_plusses */
/* This is changed from the old one: (arrow_roll + bow_damage_plusses + arrow_plusses)*(bow_multiplier + slays)*critical) */
result.dmg = damroll(o_ptr->dd, o_ptr->ds);
result.dmg += j_ptr->to_d;
result.dmg *= multiplier;
result.dmg += o_ptr->to_d;
result.dmg = critical_shot(o_ptr->weight, o_ptr->to_h, result.dmg, &result.msg_type);
object_notice_attack_plusses(&p_ptr->inventory[INVEN_BOW]);
/* Apply the player damage bonuses- THIS IS A NEW CHANGE for ranged.*/
result.dmg += p_ptr->state.to_d;
return result;
}
/**
* Helper function used with ranged_helper by do_cmd_fire.
*/
static struct attack_result make_ranged_shot(object_type *o_ptr, int y, int x) {
struct attack_result result = {FALSE, 0, 0, "hit"};
object_type *j_ptr = &p_ptr->inventory[INVEN_BOW];
monster_type *m_ptr = cave_monster_at(cave, y, x);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int bonus = p_ptr->state.to_h + o_ptr->to_h + j_ptr->to_h;
int chance = p_ptr->state.skills[SKILL_TO_HIT_BOW] + bonus * BTH_PLUS_ADJ;
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int multiplier = p_ptr->state.ammo_mult;
const struct slay *best_s_ptr = NULL;
/* Did we hit it (penalize distance travelled) */
if (!test_hit(chance2, r_ptr->ac, m_ptr->ml)) return result;
result.success = TRUE;
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
improve_attack_modifier(j_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
/* If we have a slay, modify the multiplier appropriately */
if (best_s_ptr != NULL) {
result.hit_verb = best_s_ptr->range_verb;
multiplier += best_s_ptr->mult;
if (best_s_ptr->vuln_flag &&
rf_has(r_ptr->flags, best_s_ptr->vuln_flag))
multiplier += 1;
}
/* Apply damage: multiplier, slays, criticals, bonuses */
result.dmg = damroll(o_ptr->dd, o_ptr->ds);
result.dmg += o_ptr->to_d + j_ptr->to_d;
result.dmg *= multiplier;
result.dmg = critical_shot(o_ptr->weight, o_ptr->to_h, result.dmg, &result.msg_type);
object_notice_attack_plusses(&p_ptr->inventory[INVEN_BOW]);
return result;
}
/**
* Calculate the rating for a given slay combination
*/
static s32b slay_power(const object_type *obj, int p, int verbose,
int dice_pwr, bool known)
{
u32b sv = 0;
int i, q, num_brands = 0, num_slays = 0, num_kills = 0;
int mult;
int tot_mon_power = 0;
struct brand *brands = obj->brands;
struct slay *slays = obj->slays;
/* Count the known brands and slays */
while (brands) {
if (known || brands->known)
num_brands++;
brands = brands->next;
}
while (slays) {
if (known || slays->known) {
if (slays->multiplier <= 3)
num_slays++;
else
num_kills++;
}
slays = slays->next;
}
/* If there are no slays or brands return */
if ((num_slays + num_brands + num_kills) == 0)
return p;
/* Look in the cache to see if we know this one yet */
sv = check_slay_cache(obj);
/* If it's cached (or there are no slays), return the value */
if (sv) {
log_obj("Slay cache hit\n");
} else {
/*
* Otherwise we need to calculate the expected average multiplier
* for this combination (multiplied by the total number of
* monsters, which we'll divide out later).
*/
for (i = 0; i < z_info->r_max; i++) {
monster_type *mon = mem_zalloc(sizeof(*mon));
const struct brand *b = NULL;
const struct slay *s = NULL;
char verb[20];
mult = 1;
mon->race = &r_info[i];
/* Find the best multiplier against this monster */
improve_attack_modifier((object_type *)obj, mon, &b, &s,
verb, FALSE, FALSE, !known);
if (s)
mult = s->multiplier;
else if (b)
mult = b->multiplier;
/* Add up totals */
tot_mon_power += mon->race->scaled_power;
sv += mult * mon->race->scaled_power;
mem_free(mon);
}
/*
* To get the expected damage for this weapon, multiply the
* average damage from base dice by sv, and divide by the
* total number of monsters.
*/
if (verbose) {
struct brand *b, *brands = NULL;
struct slay *s, *slays = NULL;
/* Write info about the slay combination and multiplier */
log_obj("Slay multiplier for: ");
brands = brand_collect(obj->brands, NULL, !known);
slays = slay_collect(obj->slays, NULL, !known);
for (b = brands; b; b = b->next) {
log_obj(format("%sx%d ", b->name, b->multiplier));
}
for (s = slays; s; s = s->next) {
log_obj(format("%sx%d ", s->name, s->multiplier));
}
log_obj(format("\nsv is: %d\n", sv));
log_obj(format(" and t_m_p is: %d \n", tot_mon_power));
log_obj(format("times 1000 is: %d\n", (1000 * sv) / tot_mon_power));
free_brand(brands);
free_slay(slays);
}
/* Add to the cache */
if (fill_slay_cache(obj, sv))
log_obj("Added to slay cache\n");
}
q = (dice_pwr * (sv / 100)) / (tot_mon_power / 100);
p += q;
log_obj(format("Add %d for slay power, total is %d\n", q, p));
/* Bonuses for multiple brands and slays */
if (num_slays > 1) {
q = (num_slays * num_slays * dice_pwr) / (DAMAGE_POWER * 5);
p += q;
log_obj(format("Add %d power for multiple slays, total is %d\n", q, p));
}
if (num_brands > 1) {
q = (2 * num_brands * num_brands * dice_pwr) / (DAMAGE_POWER * 5);
p += q;
log_obj(format("Add %d power for multiple brands, total is %d\n",q, p));
}
if (num_kills > 1) {
q = (3 * num_kills * num_kills * dice_pwr) / (DAMAGE_POWER * 5);
p += q;
log_obj(format("Add %d power for multiple kills, total is %d\n", q, p));
}
if (num_slays == 8) {
p += 10;
log_obj(format("Add 10 power for full set of slays, total is %d\n", p));
}
if (num_brands == 5) {
p += 20;
log_obj(format("Add 20 power for full set of brands, total is %d\n",p));
}
if (num_kills == 3) {
p += 20;
log_obj(format("Add 20 power for full set of kills, total is %d\n", p));
}
return p;
}
/**
* Attack the monster at the given location with a single blow.
*/
static bool py_attack_real(int y, int x, bool *fear) {
/* Information about the target of the attack */
monster_type *m_ptr = cave_monster(cave, cave->m_idx[y][x]);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
char m_name[80];
bool stop = FALSE;
/* The weapon used */
object_type *o_ptr = &p_ptr->inventory[INVEN_WIELD];
/* Information about the attack */
int bonus = p_ptr->state.to_h + o_ptr->to_h;
int chance = p_ptr->state.skills[SKILL_TO_HIT_MELEE] + bonus * BTH_PLUS_ADJ;
bool do_quake = FALSE;
bool success = FALSE;
/* Default to punching for one damage */
const char *hit_verb = "punch";
int dmg = 1;
u32b msg_type = MSG_HIT;
/* Extract monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Auto-Recall if possible and visible */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Track a new monster */
if (m_ptr->ml) health_track(p_ptr, cave->m_idx[y][x]);
/* Handle player fear (only for invisible monsters) */
if (check_state(p_ptr, OF_AFRAID, p_ptr->state.flags)) {
msgt(MSG_AFRAID, "You are too afraid to attack %s!", m_name);
return FALSE;
}
/* Disturb the monster */
mon_clear_timed(cave->m_idx[y][x], MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE);
/* See if the player hit */
success = test_hit(chance, r_ptr->ac, m_ptr->ml);
/* If a miss, skip this hit */
if (!success) {
msgt(MSG_MISS, "You miss %s.", m_name);
return FALSE;
}
/* Handle normal weapon */
if (o_ptr->kind) {
int i;
const struct slay *best_s_ptr = NULL;
hit_verb = "hit";
/* Get the best attack from all slays or
* brands on all non-launcher equipment */
for (i = INVEN_LEFT; i < INVEN_TOTAL; i++) {
struct object *obj = &p_ptr->inventory[i];
if (obj->kind)
improve_attack_modifier(obj, m_ptr, &best_s_ptr, TRUE, FALSE);
}
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
if (best_s_ptr != NULL)
hit_verb = best_s_ptr->melee_verb;
dmg = damroll(o_ptr->dd, o_ptr->ds);
dmg *= (best_s_ptr == NULL) ? 1 : best_s_ptr->mult;
dmg += o_ptr->to_d;
dmg = critical_norm(o_ptr->weight, o_ptr->to_h, dmg, &msg_type);
/* Learn by use for the weapon */
object_notice_attack_plusses(o_ptr);
if (check_state(p_ptr, OF_IMPACT, p_ptr->state.flags) && dmg > 50) {
do_quake = TRUE;
wieldeds_notice_flag(p_ptr, OF_IMPACT);
}
}
/* Learn by use for other equipped items */
wieldeds_notice_on_attack();
/* Apply the player damage bonuses */
dmg += p_ptr->state.to_d;
/* No negative damage */
if (dmg <= 0) dmg = 0;
/* Tell the player what happened */
if (dmg <= 0)
msgt(MSG_MISS, "You fail to harm %s.", m_name);
else if (msg_type == MSG_HIT)
msgt(MSG_HIT, "You %s %s.", hit_verb, m_name);
else if (msg_type == MSG_HIT_GOOD)
msgt(MSG_HIT_GOOD, "You %s %s. %s", hit_verb, m_name, "It was a good hit!");
else if (msg_type == MSG_HIT_GREAT)
msgt(MSG_HIT_GREAT, "You %s %s. %s", hit_verb, m_name, "It was a great hit!");
else if (msg_type == MSG_HIT_SUPERB)
msgt(MSG_HIT_SUPERB, "You %s %s. %s", hit_verb, m_name, "It was a superb hit!");
else if (msg_type == MSG_HIT_HI_GREAT)
msgt(MSG_HIT_HI_GREAT, "You %s %s. %s", hit_verb, m_name, "It was a *GREAT* hit!");
else if (msg_type == MSG_HIT_HI_SUPERB)
msgt(MSG_HIT_HI_SUPERB, "You %s %s. %s", hit_verb, m_name, "It was a *SUPERB* hit!");
/* Complex message */
if (p_ptr->wizard)
msg("You do %d (out of %d) damage.", dmg, m_ptr->hp);
/* Confusion attack */
if (p_ptr->confusing) {
p_ptr->confusing = FALSE;
msg("Your hands stop glowing.");
mon_inc_timed(cave->m_idx[y][x], MON_TMD_CONF,
(10 + randint0(p_ptr->lev) / 10), MON_TMD_FLG_NOTIFY);
}
/* Damage, check for fear and death */
stop = mon_take_hit(cave->m_idx[y][x], dmg, fear, NULL);
if (stop)
(*fear) = FALSE;
/* Apply earthquake brand */
if (do_quake) {
earthquake(p_ptr->py, p_ptr->px, 10);
if (cave->m_idx[y][x] == 0) stop = TRUE;
}
return stop;
}
/**
* Attack the monster at the given location with a single blow.
*/
static bool py_attack_real(int y, int x, bool *fear)
{
size_t i;
/* Information about the target of the attack */
struct monster *mon = square_monster(cave, y, x);
char m_name[80];
bool stop = FALSE;
/* The weapon used */
struct object *obj = equipped_item_by_slot_name(player, "weapon");
/* Information about the attack */
int chance = py_attack_hit_chance(obj);
bool do_quake = FALSE;
bool success = FALSE;
/* Default to punching for one damage */
char verb[20];
int dmg = 1;
u32b msg_type = MSG_HIT;
/* Default to punching for one damage */
my_strcpy(verb, "punch", sizeof(verb));
/* Extract monster name (or "it") */
monster_desc(m_name, sizeof(m_name), mon,
MDESC_OBJE | MDESC_IND_HID | MDESC_PRO_HID);
/* Auto-Recall if possible and visible */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
monster_race_track(player->upkeep, mon->race);
/* Track a new monster */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
health_track(player->upkeep, mon);
/* Handle player fear (only for invisible monsters) */
if (player_of_has(player, OF_AFRAID)) {
msgt(MSG_AFRAID, "You are too afraid to attack %s!", m_name);
return FALSE;
}
/* Disturb the monster */
mon_clear_timed(mon, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE, FALSE);
/* See if the player hit */
success = test_hit(chance, mon->race->ac,
mflag_has(mon->mflag, MFLAG_VISIBLE));
/* If a miss, skip this hit */
if (!success) {
msgt(MSG_MISS, "You miss %s.", m_name);
return FALSE;
}
/* Handle normal weapon */
if (obj) {
int j;
const struct brand *b = NULL;
const struct slay *s = NULL;
my_strcpy(verb, "hit", sizeof(verb));
/* Get the best attack from all slays or
* brands on all non-launcher equipment */
for (j = 2; j < player->body.count; j++) {
struct object *obj = slot_object(player, j);
if (obj)
improve_attack_modifier(obj, mon, &b, &s, verb, FALSE, TRUE,
FALSE);
}
improve_attack_modifier(obj, mon, &b, &s, verb, FALSE, TRUE, FALSE);
dmg = melee_damage(obj, b, s);
dmg = critical_norm(obj->weight, obj->to_h, dmg, &msg_type);
/* Learn by use for the weapon */
object_notice_attack_plusses(obj);
if (player_of_has(player, OF_IMPACT) && dmg > 50) {
do_quake = TRUE;
equip_notice_flag(player, OF_IMPACT);
}
}
/* Learn by use for other equipped items */
equip_notice_on_attack(player);
/* Apply the player damage bonuses */
dmg += player_damage_bonus(&player->state);
/* No negative damage; change verb if no damage done */
if (dmg <= 0) {
dmg = 0;
msg_type = MSG_MISS;
my_strcpy(verb, "fail to harm", sizeof(verb));
}
for (i = 0; i < N_ELEMENTS(melee_hit_types); i++) {
const char *dmg_text = "";
if (msg_type != melee_hit_types[i].msg)
continue;
if (OPT(show_damage))
dmg_text = format(" (%d)", dmg);
if (melee_hit_types[i].text)
msgt(msg_type, "You %s %s%s. %s", verb, m_name, dmg_text,
melee_hit_types[i].text);
else
msgt(msg_type, "You %s %s%s.", verb, m_name, dmg_text);
}
/* Pre-damage side effects */
blow_side_effects(player, mon);
/* Damage, check for fear and death */
stop = mon_take_hit(mon, dmg, fear, NULL);
if (stop)
(*fear) = FALSE;
/* Post-damage effects */
if (blow_after_effects(y, x, do_quake))
stop = TRUE;
return stop;
}
/*
* 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);
}
/*
* Attack the monster at the given location
*
* If no "weapon" is available, then "punch" the monster one time.
*
* We get blows until energy drops below that required for another blow, or
* until the target monster dies. We use a wrapper to work out the number of
* blows. We don't allow @ to spend more than 100 energy in one go, to avoid
* slower monsters getting double moves.
*/
bool py_attack_real(int y, int x)
{
int bonus, chance;
monster_type *m_ptr = &mon_list[cave_m_idx[y][x]];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
monster_lore *l_ptr = &l_list[m_ptr->r_idx];
object_type *o_ptr;
char m_name[80];
bool fear = FALSE;
bool do_quake = FALSE;
bool dead = FALSE;
u32b msg_type = 0;
bool success = FALSE;
const char *hit_verb = "ERROR";
int dmg = 1;
/* Default to punching for one damage */
/* Maybe handle monster melee here -Simon */
if(!rp_ptr->p_monster_index)
{
hit_verb = "punch";
msg_type = MSG_HIT;
}
/*
* Hack -- if advanced innate attacks are disabled for this race, fall back
* on defaults <player>'s 1d1.
*/
/* TODO: this -Simon */
/* if (p_ptr->flags[NO_INNATE])
{
p_ptr = &r_info[0];
} */
/* Extract monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Auto-Recall if possible and visible */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Track a new monster */
if (m_ptr->ml) health_track(cave_m_idx[y][x]);
/* Handle player fear (only for invisible monsters) */
if (p_ptr->state.afraid)
{
message_format(MSG_AFRAID, 0,
"You are too afraid to attack %s!",
m_name);
return (FALSE);
}
/* Disturb the monster */
wake_monster(m_ptr);
/* Get the weapon */
o_ptr = &p_ptr->inventory[INVEN_WIELD];
/* Calculate the "attack quality" */
bonus = p_ptr->state.to_h + o_ptr->to_h;
chance = (p_ptr->state.skills[SKILL_TO_HIT_MELEE] + (bonus * BTH_PLUS_ADJ));
/* Handle innate melee -Simon */
if(!o_ptr->k_idx && rp_ptr->p_monster_index)
{
for (int num = 0; (num < MONSTER_BLOW_MAX) && !dead; num++)
{
const slay_t *best_s_ptr = NULL;
int type = GF_ARROW, type2 = 0, i;
int flg = PROJECT_KILL | PROJECT_STOP | PROJECT_HIDE; // | PROJECT_PASS; TODO: figure out what this is and implement it -Simon
char *p = "";
if (!r_info[rp_ptr->p_monster_index].blow[num].method && !dead)
continue;
/* Test for hit */
if (test_hit(chance, r_info[m_ptr->r_idx].ac, m_ptr->ml))
{
int mul = 1;
int k = 0;
/* Get the method */
switch (r_info[rp_ptr->p_monster_index].blow[num].method)
{
case RBM_HIT: p = "hit"; break;
case RBM_TOUCH: p = "touch"; break;
case RBM_PUNCH: p = "punch"; break;
case RBM_KICK: p = "kick"; break;
case RBM_CLAW: p = "claw"; break;
case RBM_BITE: p = "bite"; break;
case RBM_STING: p = "sting"; break;
case RBM_BUTT: p = "butt"; break;
case RBM_CRUSH: p = "crush"; break;
case RBM_ENGULF:p = "engulf"; break;
case RBM_PECK: p = "peck"; break;
case RBM_CRAWL: p = "crawl on"; break;
case RBM_DROOL: p = "drool on"; break;
case RBM_SPIT: p = "spit on"; break;
case RBM_SLIME: p = "slime"; break;
case RBM_GAZE: p = "gaze at"; break;
case RBM_WAIL: p = "wail at"; break;
case RBM_SPORE: p = "release spores at"; break;
case RBM_BEG: p = "beg for money"; break;
case RBM_INSULT: p = "insult"; break;
default: p = "attack";
}
/* Get the effect */
switch (r_info[rp_ptr->p_monster_index].blow[num].effect)
{
case RBE_HURT: type = GF_ARROW; break;
case RBE_DISEASE: type = GF_POIS; mul = 2; break;
case RBE_POISON: type = GF_POIS; mul = 2; break;
case RBE_LOSE_MANA: type = GF_DISENCHANT; break;
case RBE_UN_BONUS: type = GF_DISENCHANT; mul = 2; break;
case RBE_UN_POWER: type = GF_DISENCHANT; mul = 2; break; /* ? */
case RBE_EAT_LIGHT: type = GF_DARK; mul = 2; break;
case RBE_ACID: type = GF_ACID; mul = 2; break;
case RBE_ELEC: type = GF_ELEC; mul = 2; break;
case RBE_FIRE: type = GF_FIRE; mul = 2; break;
case RBE_COLD: type = GF_COLD; mul = 2; break;
case RBE_BLIND: type2 = GF_OLD_CONF; break; /* ? */
case RBE_CONFUSE: type2 = GF_OLD_CONF; break;
case RBE_TERRIFY: type2 = GF_TURN_ALL; break; /* ? */
case RBE_PARALYZE: type2 = GF_OLD_SLEEP; break; /* ? */
/* Earthquake would be natural, but all monsters
* with RBE_SHATTER are already humanoids
*/
case RBE_SHATTER: type = GF_ARROW; break;
case RBE_EXP_10: type = GF_NETHER; mul = 2; break;
case RBE_EXP_20: type = GF_NETHER; mul = 2; break;
case RBE_EXP_40: type = GF_NETHER; mul = 2; break;
case RBE_EXP_80: type = GF_NETHER; mul = 2; break;
/* GF_CHAOS will polymorph, so it is bad */
case RBE_HALLU: type = GF_DISENCHANT; mul = 2; break;
default: type = GF_ARROW;
}
k = damroll(r_info[rp_ptr->p_monster_index].blow[num].d_dice, r_info[rp_ptr->p_monster_index].blow[num].d_side);
/* Get the best attack from all slays or
* brands on all non-launcher equipment */
for (i = INVEN_FINGER; i < INVEN_TOTAL; i++)
improve_attack_modifier(&p_ptr->inventory[i], m_ptr, &best_s_ptr);
if (best_s_ptr != NULL)
{
if (best_s_ptr->mult > mul)
{
p = best_s_ptr->melee_verb;
mul = best_s_ptr->mult;
if (best_s_ptr->resist_flag == RF_IM_ACID)
type = GF_ACID;
else if (best_s_ptr->resist_flag == RF_IM_ELEC)
type = GF_ELEC;
else if (best_s_ptr->resist_flag == RF_IM_FIRE)
type = GF_FIRE;
else if (best_s_ptr->resist_flag == RF_IM_COLD)
type = GF_COLD;
else if (best_s_ptr->resist_flag == RF_IM_POIS)
type = GF_POIS;
}
}
k *= mul;
message_format(MSG_HIT, m_ptr->r_idx, "You %s %s.", p, m_name);
/* Add to-dam bonus only if did some damage */
if (k) k += p_ptr->state.to_d;
if (k < 0) k = 0;
/* Learn by use for other equipped items */
wieldeds_notice_on_attack();
/* If there is an extra effect, project it also, using 4*level as power */
if (type2)
{
project(-1, 0, y, x, 4 * p_ptr->lev, type2, flg);
}
/* Confusion attack */
if (p_ptr->confusing)
{
/* Message */
if (p_ptr->confusing)
msg_print("Your limbs stop glowing.");
/* Cancel glowing hands */
p_ptr->confusing = FALSE;
/* Confuse the monster */
if (rf_has(r_ptr->flags, RF_NO_CONF))
{
if (m_ptr->ml)
{
rf_on(l_ptr->flags, RF_NO_CONF);
}
msg_format("%^s is unaffected.", m_name);
}
else if (randint0(100) < r_ptr->level)
{
msg_format("%^s appears slightly perplexed.", m_name);
}
else
{
msg_format("%^s appears confused.", m_name);
m_ptr->confused += 10 + randint0(p_ptr->lev) / 5;
}
}
/* Damage, check for fear and death */
/* Makes elemental attacks do half their damage physically -Simon */
if (type != GF_ARROW)
{
project(-1, 0, y, x, (k + 1)/2, type, flg);
/* Make the physical portion TOP SECRET -Simon */
flg &= ~(PROJECT_AWARE);
project(-1, 0, y, x, k/2, GF_ARROW, flg);
}
else
project(-1, 0, y, x, k, type, flg);
/* Hack: check if the square is empty after we project the attack into it -Simon */
dead = (cave_m_idx[y][x] == 0);
/* Hack -- delay fear messages */
if (fear && m_ptr->ml && !dead)
message_format(MSG_FLEE, m_ptr->r_idx, "%^s flees in terror!", m_name);
}
/* Player misses */
else
{
/* Message */
message_format(MSG_MISS, m_ptr->r_idx, "You miss %s.", m_name);
}
}
return (TRUE);
}
else
{
/* See if the player hit */
success = test_hit(chance, r_ptr->ac, m_ptr->ml);
/* If a miss, skip this hit */
if (!success)
{
message_format(MSG_MISS, m_ptr->r_idx, "You miss %s.", m_name);
return (FALSE);
}
/* Handle normal weapon */
if (o_ptr->k_idx)
{
int i;
const slay_t *best_s_ptr = NULL;
hit_verb = "hit";
/* Get the best attack from all slays or
* brands on all non-launcher equipment */
for (i = INVEN_FINGER; i < INVEN_TOTAL; i++)
improve_attack_modifier(&p_ptr->inventory[i], m_ptr,
&best_s_ptr);
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr);
if (best_s_ptr != NULL)
hit_verb = best_s_ptr->melee_verb;
dmg = damroll(o_ptr->dd, o_ptr->ds);
dmg *= (best_s_ptr == NULL) ? 1 : best_s_ptr->mult;
if (p_ptr->state.impact && (dmg > 50))
do_quake = TRUE;
dmg += o_ptr->to_d;
dmg = critical_norm(o_ptr->weight, o_ptr->to_h, dmg, &msg_type);
/* Learn by use for the weapon */
object_notice_attack_plusses(o_ptr);
if (do_quake)
wieldeds_notice_flag(OF_IMPACT);
}
/* Learn by use for other equipped items */
wieldeds_notice_on_attack();
/* Apply the player damage bonuses */
dmg += p_ptr->state.to_d;
/* No negative damage */
if (dmg <= 0) dmg = 0;
/* Tell the player what happened */
if (dmg <= 0)
message_format(MSG_MISS, m_ptr->r_idx,
"You fail to harm %s.", m_name);
else if (msg_type == MSG_HIT)
message_format(MSG_HIT, m_ptr->r_idx, "You %s %s.",
hit_verb, m_name);
else if (msg_type == MSG_HIT_GOOD)
message_format(MSG_HIT_GOOD, m_ptr->r_idx, "You %s %s. %s",
hit_verb, m_name, "It was a good hit!");
else if (msg_type == MSG_HIT_GREAT)
message_format(MSG_HIT_GREAT, m_ptr->r_idx, "You %s %s. %s",
hit_verb, m_name, "It was a great hit!");
else if (msg_type == MSG_HIT_SUPERB)
message_format(MSG_HIT_SUPERB, m_ptr->r_idx, "You %s %s. %s",
hit_verb, m_name, "It was a superb hit!");
else if (msg_type == MSG_HIT_HI_GREAT)
message_format(MSG_HIT_HI_GREAT, m_ptr->r_idx, "You %s %s. %s",
hit_verb, m_name, "It was a *GREAT* hit!");
else if (msg_type == MSG_HIT_HI_SUPERB)
message_format(MSG_HIT_HI_SUPERB, m_ptr->r_idx, "You %s %s. %s",
hit_verb, m_name, "It was a *SUPERB* hit!");
/* Complex message */
if (p_ptr->wizard)
msg_format("You do %d (out of %d) damage.", dmg, m_ptr->hp);
/* Confusion attack */
if (p_ptr->confusing)
{
/* Cancel glowing hands */
p_ptr->confusing = FALSE;
/* Message */
msg_print("Your limbs stop glowing.");
/* Update the lore */
if (m_ptr->ml)
rf_on(l_ptr->flags, RF_NO_CONF);
/* Confuse the monster */
if (rf_has(r_ptr->flags, RF_NO_CONF))
msg_format("%^s is unaffected.", m_name);
else if (randint0(100) < r_ptr->level)
msg_format("%^s is unaffected.", m_name);
else
{
msg_format("%^s appears confused.", m_name);
m_ptr->confused += 10 + randint0(p_ptr->lev) / 5;
}
}
/* Damage, check for fear and death */
dead = mon_take_hit(cave_m_idx[y][x], dmg, &fear, NULL);
/* Hack -- delay fear messages */
if (fear && m_ptr->ml)
message_format(MSG_FLEE, m_ptr->r_idx, "%^s flees in terror!",
m_name);
/* Mega-Hack -- apply earthquake brand */
if (do_quake) earthquake(p_ptr->py, p_ptr->px, 10);
return (dead);
}
}
/*
* 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);
}
/**
* Calculate the rating for a given slay combination
*/
static s32b slay_power(const object_type *o_ptr, int verbose, ang_file*
log_file, bool known)
{
bitflag s_index[OF_SIZE], f[OF_SIZE], f2[OF_SIZE];
u32b sv = 0;
int i, j;
int mult;
const struct slay *best_s_ptr = NULL;
monster_race *r_ptr;
monster_type *m_ptr;
monster_type monster_type_body;
const char *desc[SL_MAX] = { 0 }, *brand[SL_MAX] = { 0 };
int s_mult[SL_MAX] = { 0 };
if (known)
object_flags(o_ptr, f);
else
object_flags_known(o_ptr, f);
/* Combine the slay bytes into an index value, return if there are none */
of_copy(s_index, f);
create_mask(f2, FALSE, OFT_SLAY, OFT_KILL, OFT_BRAND, OFT_MAX);
if (!of_is_inter(s_index, f2))
return tot_mon_power;
else
of_inter(s_index, f2);
/* Look in the cache to see if we know this one yet */
sv = check_slay_cache(s_index);
/* If it's cached (or there are no slays), return the value */
if (sv) {
file_putf(log_file, "Slay cache hit\n");
return sv;
}
/*
* Otherwise we need to calculate the expected average multiplier
* for this combination (multiplied by the total number of
* monsters, which we'll divide out later).
*/
for (i = 0; i < z_info->r_max; i++) {
best_s_ptr = NULL;
mult = 1;
r_ptr = &r_info[i];
m_ptr = &monster_type_body;
m_ptr->r_idx = i;
/* Find the best multiplier against this monster */
improve_attack_modifier((object_type *)o_ptr, m_ptr, &best_s_ptr,
FALSE, !known);
if (best_s_ptr)
mult = best_s_ptr->mult;
/* Add the multiple to sv */
sv += mult * r_ptr->scaled_power;
}
/*
* To get the expected damage for this weapon, multiply the
* average damage from base dice by sv, and divide by the
* total number of monsters.
*/
if (verbose) {
/* Write info about the slay combination and multiplier */
file_putf(log_file, "Slay multiplier for: ");
j = list_slays(s_index, s_index, desc, brand, s_mult, FALSE);
for (i = 0; i < j; i++) {
if (brand[i]) {
file_putf(log_file, brand[i]);
} else {
file_putf(log_file, desc[i]);
}
file_putf(log_file, "x%d ", s_mult[i]);
}
file_putf(log_file, "\nsv is: %d\n", sv);
file_putf(log_file, " and t_m_p is: %d \n", tot_mon_power);
file_putf(log_file, "times 1000 is: %d\n", (1000 * sv) / tot_mon_power);
}
/* Add to the cache */
if (fill_slay_cache(s_index, sv))
file_putf(log_file, "Added to slay cache\n");
return sv;
}
