/*
* Search for hidden things. Returns true if a search was attempted, returns
* false when the player has a 0% chance of finding anything. Prints messages
* for negative confirmation when verbose mode is requested.
*/
bool search(bool verbose)
{
int py = p_ptr->py;
int px = p_ptr->px;
int y, x, chance;
bool found = FALSE;
object_type *o_ptr;
/* Start with base search ability */
chance = p_ptr->state.skills[SKILL_SEARCH];
/* Penalize various conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) chance = chance / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) chance = chance / 10;
/* Prevent fruitless searches */
if (chance <= 0)
{
if (verbose)
{
msg("You can't make out your surroundings well enough to search.");
/* Cancel repeat */
disturb(p_ptr, 0, 0);
}
return FALSE;
}
/* Search the nearby grids, which are always in bounds */
for (y = (py - 1); y <= (py + 1); y++)
{
for (x = (px - 1); x <= (px + 1); x++)
{
/* Sometimes, notice things */
if (randint0(100) < chance)
{
/* Invisible trap */
if (cave_issecrettrap(cave, y, x))
{
found = TRUE;
/* Pick a trap */
pick_trap(y, x);
/* Message */
msg("You have found a trap.");
/* Disturb */
disturb(p_ptr, 0, 0);
}
/* Secret door */
if (cave_issecretdoor(cave, y, x))
{
found = TRUE;
/* Message */
msg("You have found a secret door.");
/* Pick a door */
place_closed_door(cave, y, x);
/* Disturb */
disturb(p_ptr, 0, 0);
}
/* Scan all objects in the grid */
for (o_ptr = get_first_object(y, x); o_ptr; o_ptr = get_next_object(o_ptr))
{
/* Skip if not a trapped chest */
if (!is_trapped_chest(o_ptr)) continue;
/* Identify once */
if (!object_is_known(o_ptr))
{
found = TRUE;
/* Message */
msg("You have discovered a trap on the chest!");
/* Know the trap */
object_notice_everything(o_ptr);
/* Notice it */
disturb(p_ptr, 0, 0);
}
}
}
}
}
if (verbose && !found)
{
if (chance >= 100)
msg("There are no secrets here.");
else
msg("You found nothing.");
}
return TRUE;
}
/**
* Determine if an item can "absorb" a second item
*
* See "object_absorb()" for the actual "absorption" code.
*
* If permitted, we allow weapons/armor to stack, if "known".
*
* Missiles will combine if both stacks have the same "known" status.
* This is done to make unidentified stacks of missiles useful.
*
* Food, potions, scrolls, and "easy know" items always stack.
*
* Chests, and activatable items, except rods, never stack (for various
* reasons).
*/
bool object_stackable(const struct object *obj1, const struct object *obj2,
object_stack_t mode)
{
int i;
/* Equipment items don't stack */
if (object_is_equipped(player->body, obj1))
return FALSE;
if (object_is_equipped(player->body, obj2))
return FALSE;
/* If either item is unknown, do not stack */
if (mode & OSTACK_LIST && obj1->marked == MARK_AWARE) return FALSE;
if (mode & OSTACK_LIST && obj2->marked == MARK_AWARE) return FALSE;
/* Hack -- identical items cannot be stacked */
if (obj1 == obj2) return FALSE;
/* Require identical object kinds */
if (obj1->kind != obj2->kind) return FALSE;
/* Different flags don't stack */
if (!of_is_equal(obj1->flags, obj2->flags)) return FALSE;
/* Different elements don't stack */
for (i = 0; i < ELEM_MAX; i++) {
if (obj1->el_info[i].res_level != obj2->el_info[i].res_level)
return FALSE;
if ((obj1->el_info[i].flags & (EL_INFO_HATES | EL_INFO_IGNORE)) !=
(obj2->el_info[i].flags & (EL_INFO_HATES | EL_INFO_IGNORE)))
return FALSE;
}
/* Artifacts never stack */
if (obj1->artifact || obj2->artifact) return FALSE;
/* Analyze the items */
if (tval_is_chest(obj1)) {
/* Chests never stack */
return FALSE;
}
else if (tval_is_food(obj1) || tval_is_potion(obj1) ||
tval_is_scroll(obj1) || tval_is_rod(obj1)) {
/* Food, potions, scrolls and rods all stack nicely,
since the kinds are identical, either both will be
aware or both will be unaware */
} else if (tval_can_have_charges(obj1) || tval_is_money(obj1)) {
/* Gold, staves and wands stack most of the time */
/* Too much gold or too many charges */
if (obj1->pval + obj2->pval > MAX_PVAL)
return FALSE;
/* ... otherwise ok */
} else if (tval_is_weapon(obj1) || tval_is_armor(obj1) ||
tval_is_jewelry(obj1) || tval_is_light(obj1)) {
bool obj1_is_known = object_is_known(obj1);
bool obj2_is_known = object_is_known(obj2);
/* Require identical values */
if (obj1->ac != obj2->ac) return FALSE;
if (obj1->dd != obj2->dd) return FALSE;
if (obj1->ds != obj2->ds) return FALSE;
/* Require identical bonuses */
if (obj1->to_h != obj2->to_h) return FALSE;
if (obj1->to_d != obj2->to_d) return FALSE;
if (obj1->to_a != obj2->to_a) return FALSE;
/* Require all identical modifiers */
for (i = 0; i < OBJ_MOD_MAX; i++)
if (obj1->modifiers[i] != obj2->modifiers[i])
return (FALSE);
/* Require identical ego-item types */
if (obj1->ego != obj2->ego) return FALSE;
/* Hack - Never stack recharging wearables ... */
if ((obj1->timeout || obj2->timeout) &&
!tval_is_light(obj1)) return FALSE;
/* ... and lights must have same amount of fuel */
else if ((obj1->timeout != obj2->timeout) &&
tval_is_light(obj1)) return FALSE;
/* Prevent unIDd items stacking with IDd items in the object list */
if (mode & OSTACK_LIST && (obj1_is_known != obj2_is_known))
return FALSE;
} else {
/* Anything else probably okay */
}
/* Require compatible inscriptions */
if (obj1->note && obj2->note && (obj1->note != obj2->note))
return FALSE;
/* They must be similar enough */
return TRUE;
}
/*
* Output object information
*/
static textblock *object_info_out(const object_type *o_ptr, int mode)
{
bitflag flags[OF_SIZE];
bitflag pv_flags[MAX_PVALS][OF_SIZE];
bool something = FALSE;
bool known = object_is_known(o_ptr);
bool full = mode & OINFO_FULL;
bool terse = mode & OINFO_TERSE;
bool subjective = mode & OINFO_SUBJ;
bool ego = mode & OINFO_EGO;
textblock *tb = textblock_new();
/* Unaware objects get simple descriptions */
if (!full && (o_ptr->marked == MARK_AWARE)){
textblock_append(tb, "\n\nYou do not know what this is.\n");
return tb;
}
/* Grab the object flags */
if (full) {
object_flags(o_ptr, flags);
object_pval_flags(o_ptr, pv_flags);
} else {
object_flags_known(o_ptr, flags);
object_pval_flags_known(o_ptr, pv_flags);
}
if (subjective) describe_origin(tb, o_ptr);
if (!terse) describe_flavor_text(tb, o_ptr, ego);
if (!full && !known)
{
textblock_append(tb, "You do not know the full extent of this item's powers.\n");
something = TRUE;
}
if (describe_curses(tb, o_ptr, flags)) something = TRUE;
if (describe_stats(tb, o_ptr, pv_flags, mode)) something = TRUE;
if (describe_slays(tb, flags, o_ptr->tval)) something = TRUE;
if (describe_immune(tb, flags)) something = TRUE;
if (describe_ignores(tb, flags)) something = TRUE;
dedup_hates_flags(flags);
if (describe_hates(tb, flags)) something = TRUE;
if (describe_sustains(tb, flags)) something = TRUE;
if (describe_misc_magic(tb, flags)) something = TRUE;
if (ego && describe_ego(tb, o_ptr->ego)) something = TRUE;
if (something) textblock_append(tb, "\n");
if (!ego && describe_effect(tb, o_ptr, full, terse, subjective)) {
something = TRUE;
textblock_append(tb, "\n");
}
if (subjective && describe_combat(tb, o_ptr, mode)) {
something = TRUE;
textblock_append(tb, "\n");
}
if (!terse && describe_food(tb, o_ptr, subjective, full)) something = TRUE;
if (describe_light(tb, o_ptr, flags, mode)) something = TRUE;
if (!terse && subjective && describe_digger(tb, o_ptr, mode)) something = TRUE;
if (!something)
textblock_append(tb, "\n\nThis item does not seem to possess any special abilities.");
return tb;
}
/*
* Calculate the players current "state", taking into account
* not only race/class intrinsics, but also objects being worn
* and temporary spell effects.
*
* See also calc_mana() and calc_hitpoints().
*
* Take note of the new "speed code", in particular, a very strong
* player will start slowing down as soon as he reaches 150 pounds,
* but not until he reaches 450 pounds will he be half as fast as
* a normal kobold. This both hurts and helps the player, hurts
* because in the old days a player could just avoid 300 pounds,
* and helps because now carrying 300 pounds is not very painful.
*
* The "weapon" and "bow" do *not* add to the bonuses to hit or to
* damage, since that would affect non-combat things. These values
* are actually added in later, at the appropriate place.
*
* If id_only is true, calc_bonuses() will only use the known
* information of objects; thus it returns what the player _knows_
* the character state to be.
*/
void calc_bonuses(object_type inventory[], player_state *state, bool id_only)
{
int i, j, hold;
int extra_blows = 0;
int extra_shots = 0;
int extra_might = 0;
object_type *o_ptr;
bitflag f[OF_SIZE];
bitflag collect_f[OF_SIZE];
/*** Reset ***/
memset(state, 0, sizeof *state);
/* Set various defaults */
state->speed = 110;
state->num_blow = 1;
/*** Extract race/class info ***/
/* Base infravision (purely racial) */
state->see_infra = rp_ptr->infra;
/* Base skills */
for (i = 0; i < SKILL_MAX; i++)
state->skills[i] = rp_ptr->r_skills[i] + cp_ptr->c_skills[i];
/*** Analyze player ***/
/* Extract the player flags */
player_flags(collect_f);
/*** Analyze equipment ***/
/* Scan the equipment */
for (i = INVEN_WIELD; i < INVEN_TOTAL; i++)
{
o_ptr = &inventory[i];
/* Skip non-objects */
if (!o_ptr->k_idx) continue;
/* Extract the item flags */
if (id_only)
object_flags_known(o_ptr, f);
else
object_flags(o_ptr, f);
of_union(collect_f, f);
/* Affect stats */
if (of_has(f, OF_STR)) state->stat_add[A_STR] += o_ptr->pval;
if (of_has(f, OF_INT)) state->stat_add[A_INT] += o_ptr->pval;
if (of_has(f, OF_WIS)) state->stat_add[A_WIS] += o_ptr->pval;
if (of_has(f, OF_DEX)) state->stat_add[A_DEX] += o_ptr->pval;
if (of_has(f, OF_CON)) state->stat_add[A_CON] += o_ptr->pval;
if (of_has(f, OF_CHR)) state->stat_add[A_CHR] += o_ptr->pval;
/* Affect stealth */
if (of_has(f, OF_STEALTH)) state->skills[SKILL_STEALTH] += o_ptr->pval;
/* Affect searching ability (factor of five) */
if (of_has(f, OF_SEARCH)) state->skills[SKILL_SEARCH] += (o_ptr->pval * 5);
/* Affect searching frequency (factor of five) */
if (of_has(f, OF_SEARCH)) state->skills[SKILL_SEARCH_FREQUENCY] += (o_ptr->pval * 5);
/* Affect infravision */
if (of_has(f, OF_INFRA)) state->see_infra += o_ptr->pval;
/* Affect digging (factor of 20) */
if (of_has(f, OF_TUNNEL)) state->skills[SKILL_DIGGING] += (o_ptr->pval * 20);
/* Affect speed */
if (of_has(f, OF_SPEED)) state->speed += o_ptr->pval;
/* Affect blows */
if (of_has(f, OF_BLOWS)) extra_blows += o_ptr->pval;
/* Affect shots */
if (of_has(f, OF_SHOTS)) extra_shots += o_ptr->pval;
/* Affect Might */
if (of_has(f, OF_MIGHT)) extra_might += o_ptr->pval;
/* Modify the base armor class */
state->ac += o_ptr->ac;
/* The base armor class is always known */
state->dis_ac += o_ptr->ac;
/* Apply the bonuses to armor class */
if (!id_only || object_is_known(o_ptr))
state->to_a += o_ptr->to_a;
/* Apply the mental bonuses to armor class, if known */
if (object_defence_plusses_are_visible(o_ptr))
state->dis_to_a += o_ptr->to_a;
/* Hack -- do not apply "weapon" bonuses */
if (i == INVEN_WIELD) continue;
/* Hack -- do not apply "bow" bonuses */
if (i == INVEN_BOW) continue;
/* Apply the bonuses to hit/damage */
if (!id_only || object_is_known(o_ptr))
{
state->to_h += o_ptr->to_h;
state->to_d += o_ptr->to_d;
}
/* Apply the mental bonuses tp hit/damage, if known */
if (object_attack_plusses_are_visible(o_ptr))
{
state->dis_to_h += o_ptr->to_h;
state->dis_to_d += o_ptr->to_d;
}
}
/*** Update all flags ***/
/* Good flags */
if (of_has(collect_f, OF_SLOW_DIGEST)) state->slow_digest = TRUE;
if (of_has(collect_f, OF_FEATHER)) state->ffall = TRUE;
if (of_has(collect_f, OF_REGEN)) state->regenerate = TRUE;
if (of_has(collect_f, OF_TELEPATHY)) state->telepathy = TRUE;
if (of_has(collect_f, OF_SEE_INVIS)) state->see_inv = TRUE;
if (of_has(collect_f, OF_FREE_ACT)) state->free_act = TRUE;
if (of_has(collect_f, OF_HOLD_LIFE)) state->hold_life = TRUE;
/* Weird flags */
if (of_has(collect_f, OF_BLESSED)) state->bless_blade = TRUE;
/* Bad flags */
if (of_has(collect_f, OF_IMPACT)) state->impact = TRUE;
if (of_has(collect_f, OF_AGGRAVATE)) state->aggravate = TRUE;
if (of_has(collect_f, OF_TELEPORT)) state->teleport = TRUE;
if (of_has(collect_f, OF_DRAIN_EXP)) state->exp_drain = TRUE;
if (of_has(collect_f, OF_IMPAIR_HP)) state->impair_hp = TRUE;
if (of_has(collect_f, OF_IMPAIR_MANA)) state->impair_mana = TRUE;
if (of_has(collect_f, OF_AFRAID)) state->afraid = TRUE;
/* Vulnerability flags */
if (of_has(collect_f, OF_VULN_FIRE)) state->vuln_fire = TRUE;
if (of_has(collect_f, OF_VULN_ACID)) state->vuln_acid = TRUE;
if (of_has(collect_f, OF_VULN_COLD)) state->vuln_cold = TRUE;
if (of_has(collect_f, OF_VULN_ELEC)) state->vuln_elec = TRUE;
/* Immunity flags */
if (of_has(collect_f, OF_IM_FIRE)) state->immune_fire = TRUE;
if (of_has(collect_f, OF_IM_ACID)) state->immune_acid = TRUE;
if (of_has(collect_f, OF_IM_COLD)) state->immune_cold = TRUE;
if (of_has(collect_f, OF_IM_ELEC)) state->immune_elec = TRUE;
/* Resistance flags */
if (of_has(collect_f, OF_RES_ACID)) state->resist_acid = TRUE;
if (of_has(collect_f, OF_RES_ELEC)) state->resist_elec = TRUE;
if (of_has(collect_f, OF_RES_FIRE)) state->resist_fire = TRUE;
if (of_has(collect_f, OF_RES_COLD)) state->resist_cold = TRUE;
if (of_has(collect_f, OF_RES_POIS)) state->resist_pois = TRUE;
if (of_has(collect_f, OF_RES_FEAR)) state->resist_fear = TRUE;
if (of_has(collect_f, OF_RES_LIGHT)) state->resist_light = TRUE;
if (of_has(collect_f, OF_RES_DARK)) state->resist_dark = TRUE;
if (of_has(collect_f, OF_RES_BLIND)) state->resist_blind = TRUE;
if (of_has(collect_f, OF_RES_CONFU)) state->resist_confu = TRUE;
if (of_has(collect_f, OF_RES_SOUND)) state->resist_sound = TRUE;
if (of_has(collect_f, OF_RES_SHARD)) state->resist_shard = TRUE;
if (of_has(collect_f, OF_RES_NEXUS)) state->resist_nexus = TRUE;
if (of_has(collect_f, OF_RES_NETHR)) state->resist_nethr = TRUE;
if (of_has(collect_f, OF_RES_CHAOS)) state->resist_chaos = TRUE;
if (of_has(collect_f, OF_RES_DISEN)) state->resist_disen = TRUE;
/* Sustain flags */
if (of_has(collect_f, OF_SUST_STR)) state->sustain_str = TRUE;
if (of_has(collect_f, OF_SUST_INT)) state->sustain_int = TRUE;
if (of_has(collect_f, OF_SUST_WIS)) state->sustain_wis = TRUE;
if (of_has(collect_f, OF_SUST_DEX)) state->sustain_dex = TRUE;
if (of_has(collect_f, OF_SUST_CON)) state->sustain_con = TRUE;
if (of_has(collect_f, OF_SUST_CHR)) state->sustain_chr = TRUE;
/*** Handle stats ***/
/* Calculate stats */
for (i = 0; i < A_MAX; i++)
{
int add, top, use, ind;
/* Extract modifier */
add = state->stat_add[i];
/* Maximize mode */
if (OPT(adult_maximize))
{
/* Modify the stats for race/class */
add += (rp_ptr->r_adj[i] + cp_ptr->c_adj[i]);
}
/* Extract the new "stat_top" value for the stat */
top = modify_stat_value(p_ptr->stat_max[i], add);
/* Save the new value */
state->stat_top[i] = top;
/* Extract the new "stat_use" value for the stat */
use = modify_stat_value(p_ptr->stat_cur[i], add);
/* Save the new value */
state->stat_use[i] = use;
/* Values: n/a */
if (use <= 3) ind = 0;
/* Values: 3, 4, ..., 18 */
else if (use <= 18) ind = (use - 3);
/* Ranges: 18/00-18/09, ..., 18/210-18/219 */
else if (use <= 18+219) ind = (15 + (use - 18) / 10);
/* Range: 18/220+ */
else ind = (37);
assert((0 <= ind) && (ind < STAT_RANGE));
/* Save the new index */
state->stat_ind[i] = ind;
}
/*** Temporary flags ***/
/* Apply temporary "stun" */
if (p_ptr->timed[TMD_STUN] > 50)
{
state->to_h -= 20;
state->dis_to_h -= 20;
state->to_d -= 20;
state->dis_to_d -= 20;
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 8 / 10;
}
else if (p_ptr->timed[TMD_STUN])
{
state->to_h -= 5;
state->dis_to_h -= 5;
state->to_d -= 5;
state->dis_to_d -= 5;
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 9 / 10;
}
/* Invulnerability */
if (p_ptr->timed[TMD_INVULN])
{
state->to_a += 100;
state->dis_to_a += 100;
}
/* Temporary blessing */
if (p_ptr->timed[TMD_BLESSED])
{
state->to_a += 5;
state->dis_to_a += 5;
state->to_h += 10;
state->dis_to_h += 10;
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 105 / 100;
}
/* Temporary shield */
if (p_ptr->timed[TMD_SHIELD])
{
state->to_a += 50;
state->dis_to_a += 50;
}
/* Temporary stoneskin */
if (p_ptr->timed[TMD_STONESKIN])
{
state->to_a += 40;
state->dis_to_a += 40;
state->speed -= 5;
}
/* Temporary "Hero" */
if (p_ptr->timed[TMD_HERO])
{
state->to_h += 12;
state->dis_to_h += 12;
state->resist_fear = TRUE;
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 105 / 100;
}
/* Temporary "Berserk" */
if (p_ptr->timed[TMD_SHERO])
{
state->to_h += 24;
state->dis_to_h += 24;
state->to_a -= 10;
state->dis_to_a -= 10;
state->resist_fear = TRUE;
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 9 / 10;
}
/* Temporary "fast" */
if (p_ptr->timed[TMD_FAST] || p_ptr->timed[TMD_SPRINT])
state->speed += 10;
/* Temporary "slow" */
if (p_ptr->timed[TMD_SLOW])
state->speed -= 10;
/* Temporary see invisible */
if (p_ptr->timed[TMD_SINVIS])
state->see_inv = TRUE;
/* Temporary infravision boost */
if (p_ptr->timed[TMD_SINFRA])
state->see_infra += 5;
/* Temporary telepathy */
if (p_ptr->timed[TMD_TELEPATHY])
state->telepathy = TRUE;
/* Temporary resist confusion */
if (p_ptr->timed[TMD_OPP_CONF])
state->resist_confu = TRUE;
/* Fear */
if (p_ptr->timed[TMD_AFRAID] || p_ptr->timed[TMD_TERROR])
state->afraid = TRUE;
if (p_ptr->timed[TMD_TERROR])
state->speed += 5;
/* Fear can come from item flags too */
if (state->afraid)
{
state->to_h -= 20;
state->dis_to_h -= 20;
state->to_a += 8;
state->dis_to_a += 8;
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 95 / 100;
}
/* Confusion */
if (p_ptr->timed[TMD_CONFUSED])
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 75 / 100;
/* Amnesia */
if (p_ptr->timed[TMD_AMNESIA])
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 8 / 10;
/* Poison */
if (p_ptr->timed[TMD_POISONED])
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 95 / 100;
/* Hallucination */
if (p_ptr->timed[TMD_IMAGE])
state->skills[SKILL_DEVICE] = state->skills[SKILL_DEVICE]
* 8 / 10;
/*** Analyze weight ***/
/* Extract the current weight (in tenth pounds) */
j = p_ptr->total_weight;
/* Extract the "weight limit" (in tenth pounds) */
i = weight_limit(state);
/* Apply "encumbrance" from weight */
if (j > i / 2) state->speed -= ((j - (i / 2)) / (i / 10));
/* Bloating slows the player down (a little) */
if (p_ptr->food >= PY_FOOD_MAX) state->speed -= 10;
/* Searching slows the player down */
if (p_ptr->searching) state->speed -= 10;
/* Sanity check on extreme speeds */
if (state->speed < 0) state->speed = 0;
if (state->speed > 199) state->speed = 199;
/*** Apply modifier bonuses ***/
/* Actual Modifier Bonuses (Un-inflate stat bonuses) */
state->to_a += ((int)(adj_dex_ta[state->stat_ind[A_DEX]]) - 128);
state->to_d += ((int)(adj_str_td[state->stat_ind[A_STR]]) - 128);
state->to_h += ((int)(adj_dex_th[state->stat_ind[A_DEX]]) - 128);
state->to_h += ((int)(adj_str_th[state->stat_ind[A_STR]]) - 128);
/* Displayed Modifier Bonuses (Un-inflate stat bonuses) */
state->dis_to_a += ((int)(adj_dex_ta[state->stat_ind[A_DEX]]) - 128);
state->dis_to_d += ((int)(adj_str_td[state->stat_ind[A_STR]]) - 128);
state->dis_to_h += ((int)(adj_dex_th[state->stat_ind[A_DEX]]) - 128);
state->dis_to_h += ((int)(adj_str_th[state->stat_ind[A_STR]]) - 128);
/*** Modify skills ***/
/* Affect Skill -- stealth (bonus one) */
state->skills[SKILL_STEALTH] += 1;
/* Affect Skill -- disarming (DEX and INT) */
state->skills[SKILL_DISARM] += adj_dex_dis[state->stat_ind[A_DEX]];
state->skills[SKILL_DISARM] += adj_int_dis[state->stat_ind[A_INT]];
/* Affect Skill -- magic devices (INT) */
state->skills[SKILL_DEVICE] += adj_int_dev[state->stat_ind[A_INT]];
/* Affect Skill -- saving throw (WIS) */
state->skills[SKILL_SAVE] += adj_wis_sav[state->stat_ind[A_WIS]];
/* Affect Skill -- digging (STR) */
state->skills[SKILL_DIGGING] += adj_str_dig[state->stat_ind[A_STR]];
/* Affect Skills (Level, by Class) */
for (i = 0; i < SKILL_MAX; i++)
state->skills[i] += (cp_ptr->x_skills[i] * p_ptr->lev / 10);
/* Limit Skill -- digging from 1 up */
if (state->skills[SKILL_DIGGING] < 1) state->skills[SKILL_DIGGING] = 1;
/* Limit Skill -- stealth from 0 to 30 */
if (state->skills[SKILL_STEALTH] > 30) state->skills[SKILL_STEALTH] = 30;
if (state->skills[SKILL_STEALTH] < 0) state->skills[SKILL_STEALTH] = 0;
/* Apply Skill -- Extract noise from stealth */
state->noise = (1L << (30 - state->skills[SKILL_STEALTH]));
/* Obtain the "hold" value */
hold = adj_str_hold[state->stat_ind[A_STR]];
/*** Analyze current bow ***/
/* Examine the "current bow" */
o_ptr = &inventory[INVEN_BOW];
/* Assume not heavy */
state->heavy_shoot = FALSE;
/* It is hard to carholdry a heavy bow */
if (hold < o_ptr->weight / 10)
{
/* Hard to wield a heavy bow */
state->to_h += 2 * (hold - o_ptr->weight / 10);
state->dis_to_h += 2 * (hold - o_ptr->weight / 10);
/* Heavy Bow */
state->heavy_shoot = TRUE;
}
/* Analyze launcher */
if (o_ptr->k_idx)
{
/* Get to shoot */
state->num_fire = 1;
/* Analyze the launcher */
switch (o_ptr->sval)
{
/* Sling and ammo */
case SV_SLING:
{
state->ammo_tval = TV_SHOT;
state->ammo_mult = 2;
break;
}
/* Short Bow and Arrow */
case SV_SHORT_BOW:
{
state->ammo_tval = TV_ARROW;
state->ammo_mult = 2;
break;
}
/* Long Bow and Arrow */
case SV_LONG_BOW:
{
state->ammo_tval = TV_ARROW;
state->ammo_mult = 3;
break;
}
/* Light Crossbow and Bolt */
case SV_LIGHT_XBOW:
{
state->ammo_tval = TV_BOLT;
state->ammo_mult = 3;
break;
}
/* Heavy Crossbow and Bolt */
case SV_HEAVY_XBOW:
{
state->ammo_tval = TV_BOLT;
state->ammo_mult = 4;
break;
}
}
/* Apply special flags */
if (o_ptr->k_idx && !state->heavy_shoot)
{
/* Extra shots */
state->num_fire += extra_shots;
/* Extra might */
state->ammo_mult += extra_might;
/* Hack -- Rangers love Bows */
if (player_has(PF_EXTRA_SHOT) &&
(state->ammo_tval == TV_ARROW))
{
/* Extra shot at level 20 */
if (p_ptr->lev >= 20) state->num_fire++;
/* Extra shot at level 40 */
if (p_ptr->lev >= 40) state->num_fire++;
}
}
/* Require at least one shot */
if (state->num_fire < 1) state->num_fire = 1;
}
/*** Analyze weapon ***/
/* Examine the "current weapon" */
o_ptr = &inventory[INVEN_WIELD];
/* Assume not heavy */
state->heavy_wield = FALSE;
/* It is hard to hold a heavy weapon */
if (hold < o_ptr->weight / 10)
{
/* Hard to wield a heavy weapon */
state->to_h += 2 * (hold - o_ptr->weight / 10);
state->dis_to_h += 2 * (hold - o_ptr->weight / 10);
/* Heavy weapon */
state->heavy_wield = TRUE;
}
/* Non-object means barehanded attacks */
if (!o_ptr->k_idx)
assert(o_ptr->weight == 0);
/* Normal weapons */
if (!state->heavy_wield)
{
/* Calculate number of blows */
state->num_blow = calc_blows(o_ptr, state) + extra_blows;
/* Boost digging skill by weapon weight */
state->skills[SKILL_DIGGING] += (o_ptr->weight / 10);
}
/* Assume okay */
state->icky_wield = FALSE;
/* Priest weapon penalty for non-blessed edged weapons */
if (player_has(PF_BLESS_WEAPON) && (!state->bless_blade) &&
((o_ptr->tval == TV_SWORD) || (o_ptr->tval == TV_POLEARM)))
{
/* Reduce the real bonuses */
state->to_h -= 2;
state->to_d -= 2;
/* Reduce the mental bonuses */
state->dis_to_h -= 2;
state->dis_to_d -= 2;
/* Icky weapon */
state->icky_wield = TRUE;
}
return;
}
/*
* Carry an object and delete it.
*/
static void py_pickup_aux(int o_idx, bool domsg)
{
int slot, quiver_slot = 0;
char o_name[80];
object_type *o_ptr = object_byid(o_idx);
/* Carry the object */
slot = inven_carry(p_ptr, o_ptr);
/* Handle errors (paranoia) */
if (slot < 0) return;
/* If we have picked up ammo which matches something in the quiver, note
* that it so that we can wield it later (and suppress pick up message) */
if (obj_is_ammo(o_ptr))
{
int i;
for (i = QUIVER_START; i < QUIVER_END; i++)
{
if (!p_ptr->inventory[i].kind) continue;
if (!object_similar(&p_ptr->inventory[i], o_ptr,
OSTACK_QUIVER)) continue;
quiver_slot = i;
break;
}
}
/* Get the new object */
o_ptr = &p_ptr->inventory[slot];
/* Set squelch status */
p_ptr->notice |= PN_SQUELCH;
/* Automatically sense artifacts */
object_sense_artifact(o_ptr);
/* Log artifacts if found */
if (o_ptr->artifact)
history_add_artifact(o_ptr->artifact, object_is_known(o_ptr), TRUE);
/* Optionally, display a message */
if (domsg && !quiver_slot)
{
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL);
/* Message */
msg("You have %s (%c).", o_name, index_to_label(slot));
}
/* Update object_idx if necessary */
if (tracked_object_is(0 - o_idx))
{
track_object(slot);
}
/* Delete the object */
delete_object_idx(o_idx);
/* If we have a quiver slot that this ammo matches, use it */
if (quiver_slot) wield_item(o_ptr, slot, quiver_slot);
}
/*
* Attempt to disarm the chest at the given location
*
* Assume there is no monster blocking the destination
*
* Returns TRUE if repeated commands may continue
*/
static bool do_cmd_disarm_chest(int y, int x, s16b o_idx)
{
int i, j;
bool more = FALSE;
object_type *o_ptr = object_byid(o_idx);
/* Get the "disarm" factor */
i = p_ptr->state.skills[SKILL_DISARM];
/* Penalize some conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) i = i / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;
/* Extract the difficulty */
j = i - o_ptr->pval[DEFAULT_PVAL];
/* Always have a small chance of success */
if (j < 2) j = 2;
/* Must find the trap first. */
if (!object_is_known(o_ptr))
{
msg("I don't see any traps.");
}
/* Already disarmed/unlocked */
else if (o_ptr->pval[DEFAULT_PVAL] <= 0)
{
msg("The chest is not trapped.");
}
/* No traps to find. */
else if (!chest_traps[o_ptr->pval[DEFAULT_PVAL]])
{
msg("The chest is not trapped.");
}
/* Success (get a lot of experience) */
else if (randint0(100) < j)
{
msgt(MSG_DISARM, "You have disarmed the chest.");
player_exp_gain(p_ptr, o_ptr->pval[DEFAULT_PVAL]);
o_ptr->pval[DEFAULT_PVAL] = (0 - o_ptr->pval[DEFAULT_PVAL]);
}
/* Failure -- Keep trying */
else if ((i > 5) && (randint1(i) > 5))
{
/* We may keep trying */
more = TRUE;
flush();
msg("You failed to disarm the chest.");
}
/* Failure -- Set off the trap */
else
{
msg("You set off a trap!");
chest_trap(y, x, o_idx);
}
/* Result */
return (more);
}
/*
* Sense the inventory
*/
void sense_inventory(void)
{
int i;
char o_name[80];
unsigned int rate;
/* No ID when confused in a bad state */
if (p_ptr->timed[TMD_CONFUSED]) return;
/* Notice some things after a while */
if (turn >= (object_last_wield + 3000))
{
object_notice_after_time();
object_last_wield = 0;
}
/* Get improvement rate */
if (player_has(PF_PSEUDO_ID_IMPROV))
rate = cp_ptr->sense_base / (p_ptr->lev * p_ptr->lev + cp_ptr->sense_div);
else
rate = cp_ptr->sense_base / (p_ptr->lev + cp_ptr->sense_div);
if (!one_in_(rate)) return;
/* Check everything */
for (i = 0; i < ALL_INVEN_TOTAL; i++)
{
const char *text = NULL;
object_type *o_ptr = &p_ptr->inventory[i];
obj_pseudo_t feel;
bool cursed;
bool okay = FALSE;
/* Skip empty slots */
if (!o_ptr->k_idx) continue;
/* Valid "tval" codes */
switch (o_ptr->tval)
{
case TV_SHOT:
case TV_ARROW:
case TV_BOLT:
case TV_BOW:
case TV_DIGGING:
case TV_HAFTED:
case TV_POLEARM:
case TV_SWORD:
case TV_BOOTS:
case TV_GLOVES:
case TV_HELM:
case TV_CROWN:
case TV_SHIELD:
case TV_CLOAK:
case TV_SOFT_ARMOR:
case TV_HARD_ARMOR:
case TV_DRAG_ARMOR:
{
okay = TRUE;
break;
}
}
/* Skip non-sense machines */
if (!okay) continue;
/* It is known, no information needed */
if (object_is_known(o_ptr)) continue;
/* It has already been sensed, do not sense it again */
if (object_was_sensed(o_ptr))
{
/* Small chance of wielded, sensed items getting complete ID */
if (!o_ptr->name1 && (i >= INVEN_WIELD) && one_in_(1000))
do_ident_item(i, o_ptr);
continue;
}
/* Occasional failure on inventory items */
if ((i < INVEN_WIELD) && one_in_(5)) continue;
/* Sense the object */
object_notice_sensing(o_ptr);
cursed = object_notice_curses(o_ptr);
/* Get the feeling */
feel = object_pseudo(o_ptr);
/* Stop everything */
disturb(0, 0);
if (cursed)
text = "cursed";
else
text = inscrip_text[feel];
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE);
/* Average pseudo-ID means full ID */
if (feel == INSCRIP_AVERAGE)
{
object_notice_everything(o_ptr);
message_format(MSG_PSEUDOID, 0,
"You feel the %s (%c) %s %s average...",
o_name, index_to_label(i),((i >= INVEN_WIELD) ? "you are using" : "in your pack"),
((o_ptr->number == 1) ? "is" : "are"));
}
else
{
if (i >= INVEN_WIELD)
{
message_format(MSG_PSEUDOID, 0, "You feel the %s (%c) you are %s %s %s...",
o_name, index_to_label(i), describe_use(i),
((o_ptr->number == 1) ? "is" : "are"),
text);
}
else
{
message_format(MSG_PSEUDOID, 0, "You feel the %s (%c) in your pack %s %s...",
o_name, index_to_label(i),
((o_ptr->number == 1) ? "is" : "are"),
text);
}
}
/* Set squelch flag as appropriate */
if (i < INVEN_WIELD)
p_ptr->notice |= PN_SQUELCH;
/* Combine / Reorder the pack (later) */
p_ptr->notice |= (PN_COMBINE | PN_REORDER | PN_SORT_QUIVER);
/* Redraw stuff */
p_ptr->redraw |= (PR_INVEN | PR_EQUIP);
}
}
/* XXX Eddie should messages be adhoc all over the place? perhaps the main
* loop should check for change in inventory/wieldeds and all messages be
* printed from one place
*/
void object_notice_on_wield(object_type *o_ptr)
{
bitflag f[OF_SIZE], obvious_mask[OF_SIZE];
bool obvious = FALSE;
const slay_t *s_ptr;
flags_init(obvious_mask, OF_SIZE, OF_OBVIOUS_MASK, FLAG_END);
/* Save time of wield for later */
object_last_wield = turn;
/* Only deal with un-ID'd items */
if (object_is_known(o_ptr)) return;
/* Wear it */
object_flavor_tried(o_ptr);
if (object_add_ident_flags(o_ptr, IDENT_WORN))
object_check_for_ident(o_ptr);
if (obj_is_light(o_ptr) && ego_item_p(o_ptr))
object_notice_ego(o_ptr);
if (object_flavor_is_aware(o_ptr) && easy_know(o_ptr))
{
object_notice_everything(o_ptr);
return;
}
/* Automatically sense artifacts upon wield */
object_sense_artifact(o_ptr);
/* Note artifacts when found */
if (artifact_p(o_ptr))
history_add_artifact(o_ptr->name1, object_is_known(o_ptr), TRUE);
/* special case FA, needed at least for mages wielding gloves */
if (object_FA_would_be_obvious(o_ptr))
of_on(obvious_mask, OF_FREE_ACT);
/* Learn about obvious flags */
of_union(o_ptr->known_flags, obvious_mask);
/* Extract the flags */
object_flags(o_ptr, f);
/* Find obvious things (disregarding curses) */
flags_clear(obvious_mask, OF_SIZE, OF_CURSE_MASK, FLAG_END);
if (of_is_inter(f, obvious_mask)) obvious = TRUE;
flags_init(obvious_mask, OF_SIZE, OF_OBVIOUS_MASK, FLAG_END);
/* XXX Eddie should these next NOT call object_check_for_ident due to worries about repairing? */
/* XXX Eddie this is a small hack, but jewelry with anything noticeable really is obvious */
/* XXX Eddie learn =soulkeeping vs =bodykeeping when notice sustain_str */
if (object_is_jewelry(o_ptr))
{
/* Learn the flavor of jewelry with obvious flags */
if (EASY_LEARN && obvious)
object_flavor_aware(o_ptr);
/* Learn all flags on any aware non-artifact jewelry */
if (object_flavor_is_aware(o_ptr) && !artifact_p(o_ptr))
object_know_all_flags(o_ptr);
}
object_check_for_ident(o_ptr);
if (!obvious) return;
/* Messages */
for (s_ptr = slay_table; s_ptr->slay_flag; s_ptr++)
{
if (of_has(f, s_ptr->slay_flag) && s_ptr->brand)
{
char o_name[40];
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE);
msg_format("Your %s %s!", o_name, s_ptr->active_verb);
}
}
/* XXX Eddie need to add stealth here, also need to assert/double-check everything is covered */
if (of_has(f, OF_STR))
msg_format("You feel %s!", o_ptr->pval > 0 ? "stronger" : "weaker");
if (of_has(f, OF_INT))
msg_format("You feel %s!", o_ptr->pval > 0 ? "smarter" : "more stupid");
if (of_has(f, OF_WIS))
msg_format("You feel %s!", o_ptr->pval > 0 ? "wiser" : "more naive");
if (of_has(f, OF_DEX))
msg_format("You feel %s!", o_ptr->pval > 0 ? "more dextrous" : "clumsier");
if (of_has(f, OF_CON))
msg_format("You feel %s!", o_ptr->pval > 0 ? "healthier" : "sicklier");
if (of_has(f, OF_CHR))
msg_format("You feel %s!", o_ptr->pval > 0 ? "cuter" : "uglier");
if (of_has(f, OF_SPEED))
msg_format("You feel strangely %s.", o_ptr->pval > 0 ? "quick" : "sluggish");
if (flags_test(f, OF_SIZE, OF_BLOWS, OF_SHOTS, FLAG_END))
msg_format("Your hands %s", o_ptr->pval > 0 ? "tingle!" : "ache.");
if (of_has(f, OF_INFRA))
msg_format("Your eyes tingle.");
if (of_has(f, OF_LIGHT))
msg_print("It glows!");
if (of_has(f, OF_TELEPATHY))
msg_print("Your mind feels strangely sharper!");
/* WARNING -- masking f by obvious mask -- this should be at the end of this function */
flags_mask(f, OF_SIZE, OF_OBVIOUS_MASK, FLAG_END);
/* learn the ego on any obvious brand or slay */
if (EASY_LEARN && ego_item_p(o_ptr) && obvious &&
flags_test(f, OF_SIZE, OF_ALL_SLAY_MASK, FLAG_END))
object_notice_ego(o_ptr);
/* Remember the flags */
object_notice_sensing(o_ptr);
/* XXX Eddie should we check_for_ident here? */
}
/*
* Given an object, return a short identifier which gives some idea of what
* the item is.
*/
obj_pseudo_t object_pseudo(const object_type *o_ptr)
{
object_kind *k_ptr = &k_info[o_ptr->k_idx];
bitflag flags[OF_SIZE];
/* Get the known and obvious flags on the object,
* not including curses or properties of the kind
*/
object_flags_known(o_ptr, flags);
/* MEGA-hack : there needs to be a table of what is obvious in each slot perhaps for each class */
/* FA on gloves is obvious to mage casters */
if (object_FA_would_be_obvious(o_ptr))
flags_mask(flags, OF_SIZE, OF_OBVIOUS_MASK, OF_FREE_ACT, FLAG_END);
else
flags_mask(flags, OF_SIZE, OF_OBVIOUS_MASK, FLAG_END);
flags_clear(flags, OF_SIZE, OF_CURSE_MASK, FLAG_END);
of_diff(flags, k_ptr->flags);
if (o_ptr->ident & IDENT_INDESTRUCT)
return INSCRIP_SPECIAL;
if ((object_was_sensed(o_ptr) || object_was_worn(o_ptr)) && artifact_p(o_ptr))
return INSCRIP_SPECIAL;
/* jewelry does not pseudo */
if (object_is_jewelry(o_ptr))
return INSCRIP_NULL;
/* XXX Eddie should also check for flags with pvals where the pval exceeds
* the base pval for things like picks of digging, though for now acid brand gets those
*/
if (!of_is_empty(flags))
return INSCRIP_SPLENDID;
if (!object_is_known(o_ptr) && !object_was_sensed(o_ptr))
return INSCRIP_NULL;
if (ego_item_p(o_ptr))
{
/* uncursed bad egos are not excellent */
if (flags_test(e_info[o_ptr->name2].flags, OF_SIZE, OF_CURSE_MASK, FLAG_END))
return INSCRIP_STRANGE; /* XXX Eddie need something worse */
else
return INSCRIP_EXCELLENT;
}
if (o_ptr->to_a == randcalc(k_ptr->to_a, 0, MINIMISE) &&
o_ptr->to_h == randcalc(k_ptr->to_h, 0, MINIMISE) &&
o_ptr->to_d == randcalc(k_ptr->to_d, 0, MINIMISE))
return INSCRIP_AVERAGE;
if (o_ptr->to_a >= randcalc(k_ptr->to_a, 0, MINIMISE) &&
o_ptr->to_h >= randcalc(k_ptr->to_h, 0, MINIMISE) &&
o_ptr->to_d >= randcalc(k_ptr->to_d, 0, MINIMISE))
return INSCRIP_MAGICAL;
if (o_ptr->to_a <= randcalc(k_ptr->to_a, 0, MINIMISE) &&
o_ptr->to_h <= randcalc(k_ptr->to_h, 0, MINIMISE) &&
o_ptr->to_d <= randcalc(k_ptr->to_d, 0, MINIMISE))
return INSCRIP_MAGICAL;
return INSCRIP_STRANGE;
}
/**
* Describes item `o_ptr` into buffer `buf` of size `max`.
*
* ODESC_PREFIX prepends a 'the', 'a' or number
* ODESC_BASE results in a base description.
* ODESC_COMBAT will add to-hit, to-dam and AC info.
* ODESC_EXTRA will add pval/charge/inscription/squelch info.
* ODESC_PLURAL will pluralise regardless of the number in the stack.
* ODESC_STORE turns off squelch markers, for in-store display.
* ODESC_SPOIL treats the object as fully identified.
*
* Setting 'prefix' to TRUE prepends a 'the', 'a' or the number in the stack,
* respectively.
*
* \returns The number of bytes used of the buffer.
*/
size_t object_desc(char *buf, size_t max, const object_type *o_ptr, int mode)
{
bool prefix = mode & ODESC_PREFIX;
bool spoil = mode & ODESC_SPOIL;
bool terse = mode & ODESC_TERSE;
bool known;
size_t end = 0, i = 0;
/* Simple description for null item */
if (!o_ptr->tval)
return strnfmt(buf, max, "(nothing)");
known = object_is_known(o_ptr) ||
(o_ptr->ident & IDENT_STORE) || spoil;
/* We've seen it at least once now we're aware of it */
if (known && o_ptr->ego && !spoil) o_ptr->ego->everseen = TRUE;
/*** Some things get really simple descriptions ***/
if (o_ptr->marked == MARK_AWARE) {
if (prefix)
return strnfmt(buf, max, "an unknown item");
return strnfmt(buf, max, "unknown item");
}
if (o_ptr->tval == TV_GOLD)
return strnfmt(buf, max, "%d gold pieces worth of %s%s",
o_ptr->pval[DEFAULT_PVAL], o_ptr->kind->name,
squelch_item_ok(o_ptr) ? " {squelch}" : "");
/** Construct the name **/
/* Copy the base name to the buffer */
end = obj_desc_name(buf, max, end, o_ptr, prefix, mode, spoil, terse);
if (mode & ODESC_COMBAT)
{
if (o_ptr->tval == TV_CHEST)
end = obj_desc_chest(o_ptr, buf, max, end);
else if (o_ptr->tval == TV_LIGHT)
end = obj_desc_light(o_ptr, buf, max, end);
end = obj_desc_combat(o_ptr, buf, max, end, spoil);
}
if (mode & ODESC_EXTRA)
{
for (i = 0; i < o_ptr->num_pvals; i++)
if (spoil || object_this_pval_is_visible(o_ptr, i)) {
end = obj_desc_pval(o_ptr, buf, max, end, spoil);
break;
}
end = obj_desc_charges(o_ptr, buf, max, end);
if (mode & ODESC_STORE)
end = obj_desc_aware(o_ptr, buf, max, end);
else
end = obj_desc_inscrip(o_ptr, buf, max, end);
}
return end;
}
static size_t obj_desc_inscrip(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
const char *u[4] = { 0, 0, 0, 0 };
int n = 0;
int feel = object_pseudo(o_ptr);
bitflag flags_known[OF_SIZE], f2[OF_SIZE];
object_flags_known(o_ptr, flags_known);
/* Get inscription */
if (o_ptr->note)
u[n++] = quark_str(o_ptr->note);
/* Use special inscription, if any */
if (!object_is_known(o_ptr) && feel)
{
/* cannot tell excellent vs strange vs splendid until wield */
if (!object_was_worn(o_ptr) && o_ptr->ego)
u[n++] = "ego";
else
u[n++] = inscrip_text[feel];
}
else if ((o_ptr->ident & IDENT_EMPTY) && !object_is_known(o_ptr))
u[n++] = "empty";
else if (!object_is_known(o_ptr) && object_was_worn(o_ptr))
{
if (wield_slot(o_ptr) == INVEN_WIELD || wield_slot(o_ptr) == INVEN_BOW)
u[n++] = "wielded";
else u[n++] = "worn";
}
else if (!object_is_known(o_ptr) && object_was_fired(o_ptr))
u[n++] = "fired";
else if (!object_flavor_is_aware(o_ptr) && object_flavor_was_tried(o_ptr))
u[n++] = "tried";
/* Note curses */
create_mask(f2, FALSE, OFT_CURSE, OFT_MAX);
if (of_is_inter(flags_known, f2))
u[n++] = "cursed";
/* Note squelch */
if (squelch_item_ok(o_ptr))
u[n++] = "squelch";
if (n)
{
int i;
for (i = 0; i < n; i++)
{
if (i == 0)
strnfcat(buf, max, &end, " {");
strnfcat(buf, max, &end, "%s", u[i]);
if (i < n-1)
strnfcat(buf, max, &end, ", ");
}
strnfcat(buf, max, &end, "}");
}
return end;
}
static size_t obj_desc_chest(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
bool known = object_is_known(o_ptr) || (o_ptr->ident & IDENT_STORE);
if (o_ptr->tval != TV_CHEST) return end;
if (!known) return end;
/* May be "empty" */
if (!o_ptr->pval[DEFAULT_PVAL])
strnfcat(buf, max, &end, " (empty)");
/* May be "disarmed" */
else if (!is_locked_chest(o_ptr))
{
if (chest_trap_type(o_ptr) != 0)
strnfcat(buf, max, &end, " (disarmed)");
else
strnfcat(buf, max, &end, " (unlocked)");
}
/* Describe the traps, if any */
else
{
/* Describe the traps */
switch (chest_trap_type(o_ptr))
{
case 0:
strnfcat(buf, max, &end, " (Locked)");
break;
case CHEST_LOSE_STR:
strnfcat(buf, max, &end, " (Poison Needle)");
break;
case CHEST_LOSE_CON:
strnfcat(buf, max, &end, " (Poison Needle)");
break;
case CHEST_POISON:
strnfcat(buf, max, &end, " (Gas Trap)");
break;
case CHEST_PARALYZE:
strnfcat(buf, max, &end, " (Gas Trap)");
break;
case CHEST_EXPLODE:
strnfcat(buf, max, &end, " (Explosion Device)");
break;
case CHEST_SUMMON:
strnfcat(buf, max, &end, " (Summoning Runes)");
break;
default:
strnfcat(buf, max, &end, " (Multiple Traps)");
break;
}
}
return end;
}
/**
* Carry an object and delete it.
*/
extern void py_pickup_aux(int o_idx, bool domsg)
{
int slot, quiver_slot = 0;
char o_name[120];
object_type *o_ptr = &o_list[o_idx];
object_type *i_ptr = &p_ptr->inventory[INVEN_LIGHT];
bitflag f[OF_SIZE], obvious_mask[OF_SIZE];
flags_init(obvious_mask, OF_SIZE, OF_OBVIOUS_MASK, FLAG_END);
of_copy(f, o_ptr->flags_obj);
/* Carry the object */
slot = inven_carry(p_ptr, o_ptr);
/* Handle errors (paranoia) */
if (slot < 0)
return;
/* If we have picked up ammo which matches something in the quiver, note
* that it so that we can wield it later (and suppress pick up message) */
if (obj_is_quiver_obj(o_ptr)) {
int i;
for (i = QUIVER_START; i < QUIVER_END; i++) {
if (!p_ptr->inventory[i].k_idx)
continue;
if (!object_similar(&p_ptr->inventory[i], o_ptr,
OSTACK_QUIVER))
continue;
quiver_slot = i;
break;
}
}
/* Get the object again */
o_ptr = &p_ptr->inventory[slot];
/* Set squelch status */
p_ptr->notice |= PN_SQUELCH;
/* Stone of Lore gives id on pickup */
if (!object_known_p(o_ptr)) {
if (i_ptr->sval == SV_STONE_LORE)
identify_object(o_ptr);
/* Otherwise pseudo-ID */
else {
bool heavy = FALSE;
int feel;
/* Heavy sensing */
heavy = (player_has(PF_PSEUDO_ID_HEAVY));
/* Type of feeling */
feel =
(heavy ? value_check_aux1(o_ptr) :
value_check_aux2(o_ptr));
/* We have "felt" it */
o_ptr->ident |= (IDENT_SENSE);
/* Inscribe it textually */
o_ptr->feel = feel;
/* Set squelch flag as appropriate */
p_ptr->notice |= PN_SQUELCH;
}
}
/* Log artifacts if found */
if (artifact_p(o_ptr))
history_add_artifact(o_ptr->name1, object_is_known(o_ptr), TRUE);
/* Notice dice and other obvious stuff */
notice_other(IF_DD_DS, slot + 1);
(void) of_inter(f, obvious_mask);
of_union(o_ptr->id_obj, f);
/* Average things are average */
if ((o_ptr->feel == FEEL_AVERAGE)
&& (is_weapon(o_ptr) || is_armour(o_ptr))) {
notice_other(IF_AC, slot + 1);
notice_other(IF_TO_A, slot + 1);
notice_other(IF_TO_H, slot + 1);
notice_other(IF_TO_D, slot + 1);
}
/* Recalculate the bonuses */
p_ptr->update |= (PU_BONUS);
/* Optionally, display a message */
if (domsg && !quiver_slot) {
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr,
ODESC_PREFIX | ODESC_FULL);
/* Message */
msg("You have %s (%c).", o_name, index_to_label(slot));
}
/* Delete the object */
delete_object_idx(o_idx);
/* If we have a quiver slot that this item matches, use it */
if (quiver_slot)
wield_item(o_ptr, slot, quiver_slot);
}
