static void refuel_torch(object_type *j_ptr, object_type *o_ptr, int item)
{
bitflag f[OF_SIZE];
bitflag g[OF_SIZE];
/* Refuel */
j_ptr->timeout += o_ptr->timeout + 5;
/* Message */
msg("You combine the torches.");
/* Transfer the LIGHT flag if refuelling from a torch with it to one
without it */
object_flags(o_ptr, f);
object_flags(j_ptr, g);
if (of_has(f, OF_LIGHT) && !of_has(g, OF_LIGHT))
{
of_on(j_ptr->flags, OF_LIGHT);
if (!j_ptr->ego && o_ptr->ego)
j_ptr->ego = o_ptr->ego;
msg("Your torch shines further!");
}
/* Over-fuel message */
if (j_ptr->timeout >= FUEL_TORCH)
{
j_ptr->timeout = FUEL_TORCH;
msg("Your torch is fully fueled.");
}
/* Refuel message */
else
{
msg("Your torch glows more brightly.");
}
/* Decrease the item (from the pack) */
if (item >= 0)
{
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
}
/* Decrease the item (from the floor) */
else
{
floor_item_increase(0 - item, -1);
floor_item_describe(0 - item);
floor_item_optimize(0 - item);
}
/* Recalculate torch */
p_ptr->update |= (PU_TORCH);
/* Redraw stuff */
p_ptr->redraw |= (PR_EQUIP);
}
static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
bitflag f[OF_SIZE];
object_flags(o_ptr, f);
if (!flags_test(f, OF_SIZE, OF_PVAL_MASK, FLAG_END)) return end;
strnfcat(buf, max, &end, " (%+d", o_ptr->pval);
if (!of_has(f, OF_HIDE_TYPE))
{
if (of_has(f, OF_STEALTH))
strnfcat(buf, max, &end, " stealth");
else if (of_has(f, OF_SEARCH))
strnfcat(buf, max, &end, " searching");
else if (of_has(f, OF_INFRA))
strnfcat(buf, max, &end, " infravision");
else if (of_has(f, OF_SPEED))
strnfcat(buf, max, &end, " speed");
else if (of_has(f, OF_BLOWS))
strnfcat(buf, max, &end, " attack%s", PLURAL(o_ptr->pval));
}
strnfcat(buf, max, &end, ")");
return end;
}
/*
* Checks for additional knowledge implied by what the player already knows.
*
* \param o_ptr is the object to check
*
* returns whether it calls object_notice_everyting
*/
bool object_check_for_ident(object_type *o_ptr)
{
bitflag flags[OF_SIZE], known_flags[OF_SIZE];
object_flags(o_ptr, flags);
object_flags_known(o_ptr, known_flags);
/* Some flags are irrelevant or never learned or too hard to learn */
flags_clear(flags, OF_SIZE, OF_OBJ_ONLY_MASK, FLAG_END);
flags_clear(known_flags, OF_SIZE, OF_OBJ_ONLY_MASK, FLAG_END);
if (!of_is_equal(flags, known_flags)) return FALSE;
/* If we know attack bonuses, and defence bonuses, and effect, then
* we effectively know everything, so mark as such */
if ((object_attack_plusses_are_visible(o_ptr) || (object_was_sensed(o_ptr) && o_ptr->to_h == 0 && o_ptr->to_d == 0)) &&
(object_defence_plusses_are_visible(o_ptr) || (object_was_sensed(o_ptr) && o_ptr->to_a == 0)) &&
(object_effect_is_known(o_ptr) || !object_effect(o_ptr)))
{
object_notice_everything(o_ptr);
return TRUE;
}
/* We still know all the flags, so we still know if it's an ego */
else if (ego_item_p(o_ptr))
{
/* require worn status so you don't learn launcher of accuracy or gloves of slaying before wield */
if (object_was_worn(o_ptr))
object_notice_ego(o_ptr);
}
return FALSE;
}
/*!
* @brief 装備への呪い付加判定と付加処理 /
* @param chance 呪いの基本確率
* @param heavy_chance 重い呪いを選択肢に入れるか否か。
* @return なし
*/
void curse_equipment(int chance, int heavy_chance)
{
bool changed = FALSE;
int curse_power = 0;
u32b new_curse;
u32b oflgs[TR_FLAG_SIZE];
object_type *o_ptr = &inventory[INVEN_RARM + randint0(12)];
char o_name[MAX_NLEN];
if (randint1(100) > chance) return;
if (!o_ptr->k_idx) return;
object_flags(o_ptr, oflgs);
object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
/* Extra, biased saving throw for blessed items */
if (have_flag(oflgs, TR_BLESSED) && (randint1(888) > chance))
{
#ifdef JP
msg_format("%sは呪いを跳ね返した！", o_name,
#else
msg_format("Your %s resist%s cursing!", o_name,
#endif
((o_ptr->number > 1) ? "" : "s"));
/* Hmmm -- can we wear multiple items? If not, this is unnecessary */
return;
}
/*
* Is o_ptr a weapon?
*/
static bool obj_desc_show_weapon(const object_type *o_ptr)
{
u32b f1, f2, f3, fn;
object_flags(o_ptr, &f1, &f2, &f3, &fn);
if (f3 & TR3_SHOW_MODS) return TRUE;
if (o_ptr->to_h && o_ptr->to_d) return TRUE;
/* You need to list both to_h and to_d for things like unaware rings of accuracy and damage e.g. to differentiate (+8) */
if ((o_ptr->to_h || o_ptr->to_d) && !object_flavor_is_aware(o_ptr)) return TRUE;
switch (o_ptr->tval)
{
case TV_SHOT:
case TV_BOLT:
case TV_ARROW:
case TV_BOW:
case TV_HAFTED:
case TV_POLEARM:
case TV_SWORD:
case TV_DIGGING:
{
return TRUE;
}
}
return FALSE;
}
static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max,
size_t end, bool spoil)
{
bitflag f[OF_SIZE], f2[OF_SIZE];
int i;
bool any = FALSE;
object_flags(o_ptr, f);
create_mask(f2, FALSE, OFT_PVAL, OFT_STAT, OFT_MAX);
if (!of_is_inter(f, f2)) return end;
strnfcat(buf, max, &end, " <");
for (i = 0; i < o_ptr->num_pvals; i++) {
if (spoil || object_this_pval_is_visible(o_ptr, i)) {
if (any)
strnfcat(buf, max, &end, ", ");
strnfcat(buf, max, &end, "%+d", o_ptr->pval[i]);
any = TRUE;
}
}
strnfcat(buf, max, &end, ">");
return end;
}
int res_ct_known(int which)
{
int ct = p_ptr->resist[which];
int hidden = 0;
int flg = res_get_object_flag(which);
int i;
/* Life is a bit hard at the moment since "player flags"
may account for multiple resistances. Really, the entire
flag based approach to resistance is just wrong, but I'm
too lazy to fix ...
*/
for (i = 0; i < equip_count(); i++)
{
int slot = EQUIP_BEGIN + i;
object_type *o_ptr = equip_obj(slot);
u32b flgs[TR_FLAG_SIZE];
u32b flgs_known[TR_FLAG_SIZE];
if (!o_ptr) continue;
object_flags(o_ptr, flgs);
object_flags_known(o_ptr, flgs_known);
if (have_flag(flgs, flg) && !have_flag(flgs_known, flg))
hidden++;
}
ct -= hidden;
return ct;
}
static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
u32b f1, f2, f3, fn;
object_flags(o_ptr, &f1, &f2, &f3, &fn);
if (!(f1 & TR1_PVAL_MASK)) return end;
strnfcat(buf, max, &end, " (%+d", o_ptr->pval);
if (!(f3 & TR3_HIDE_TYPE))
{
if (f1 & TR1_STEALTH)
strnfcat(buf, max, &end, " stealth");
else if (f1 & TR1_SEARCH)
strnfcat(buf, max, &end, " searching");
else if (f1 & TR1_INFRA)
strnfcat(buf, max, &end, " infravision");
else if (f1 & TR1_SPEED)
strnfcat(buf, max, &end, " speed");
else if (f1 & TR1_BLOWS)
strnfcat(buf, max, &end, " attack%s", PLURAL(o_ptr->pval));
}
strnfcat(buf, max, &end, ")");
return end;
}
/**
* Notice any slays on a particular object which are in mask.
*
* \param o_ptr is the object on which we are noticing slays
* \param mask is the flagset within which we are noticing them
*/
void object_notice_slays(object_type *o_ptr, const bitflag mask[OF_SIZE])
{
bool learned;
bitflag f[OF_SIZE];
char o_name[40];
int i;
/* We are only interested in the flags specified in mask */
object_flags(o_ptr, f);
of_inter(f, mask);
/* if you learn a slay, learn the ego and print a message */
for (i = 0; i < SL_MAX; i++) {
const struct slay *s_ptr = &slay_table[i];
if (of_has(f, s_ptr->object_flag)) {
learned = object_notice_flag(o_ptr, s_ptr->object_flag);
if (EASY_LEARN && learned) {
object_notice_ego(o_ptr);
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE | ODESC_SINGULAR);
msg("Your %s %s!", o_name, s_ptr->active_verb);
}
}
}
object_check_for_ident(o_ptr);
}
int evaluate_weapon(object_type *o_ptr)
{
int value = 0;
int ds = strength_modified_ds(o_ptr, 0);
int max_dam = o_ptr->dd * ds;
int min_dam = (o_ptr->ds > 0) ? o_ptr->dd : 0;
u32b f1, f2, f3;
// 'nothings' are worthless
if (!o_ptr->k_idx) return (0);
// extract the flags for the object
// need to be careful using these as they could involve hidden information
object_flags(o_ptr, &f1, &f2, &f3);
// value skill points as per normal
value += (o_ptr->att * skill_vals[S_MEL]) + (o_ptr->evn * skill_vals[S_EVN]);
// value each point of average damage as 100
value += (min_dam + max_dam) * 100 / 2;
// value {special} items as 100 (could easily be improved!)
if (o_ptr->name1 || o_ptr->name2) value += 100;
// value lightness
value = value * 100 / (70 + o_ptr->weight);
// value one-handedness
if (f3 & (TR3_TWO_HANDED)) value = value * 8 / 10;
return (value);
}
/**
* Extract the multiplier from a given object hitting a given monster.
*
* \param o_ptr is the object being used to attack
* \param m_ptr is the monster being attacked
* \param best_s_ptr is the best applicable slay_table entry, or NULL if no
* slay already known
* \param real is whether this is a real attack (where we update lore) or a
* simulation (where we don't)
* \param known_only is whether we are using all the object flags, or only
* the ones we *already* know about
*/
void improve_attack_modifier(object_type *o_ptr, const monster_type
*m_ptr, const struct slay **best_s_ptr, bool real, bool known_only)
{
monster_race *r_ptr = &r_info[m_ptr->r_idx];
monster_lore *l_ptr = &l_list[m_ptr->r_idx];
bitflag f[OF_SIZE], known_f[OF_SIZE], note_f[OF_SIZE];
int i;
object_flags(o_ptr, f);
object_flags_known(o_ptr, known_f);
for (i = 0; i < SL_MAX; i++) {
const struct slay *s_ptr = &slay_table[i];
if ((known_only && !of_has(known_f, s_ptr->object_flag)) ||
(!known_only && !of_has(f, s_ptr->object_flag))) continue;
/* Disallow forbidden off-weapon slays/brands */
if (wield_slot(o_ptr) > INVEN_BOW && wield_slot(o_ptr) < INVEN_TOTAL
&& !s_ptr->nonweap) continue;
/* In a real attack, learn about monster resistance or slay match if:
* EITHER the slay flag on the object is known,
* OR the monster is vulnerable to the slay/brand
*/
if (real && (of_has(known_f, s_ptr->object_flag) || (s_ptr->monster_flag
&& rf_has(r_ptr->flags, s_ptr->monster_flag)) ||
(s_ptr->resist_flag && !rf_has(r_ptr->flags,
s_ptr->resist_flag)) || (s_ptr->vuln_flag &&
rf_has(r_ptr->flags, s_ptr->vuln_flag)))) {
/* notice any brand or slay that would affect monster */
of_wipe(note_f);
of_on(note_f, s_ptr->object_flag);
object_notice_slays(o_ptr, note_f);
if (m_ptr->ml && s_ptr->monster_flag)
rf_on(l_ptr->flags, s_ptr->monster_flag);
if (m_ptr->ml && s_ptr->resist_flag)
rf_on(l_ptr->flags, s_ptr->resist_flag);
if (m_ptr->ml && s_ptr->vuln_flag)
rf_on(l_ptr->flags, s_ptr->vuln_flag);
}
/* If the monster doesn't resist or the slay flag matches */
if ((s_ptr->brand && !rf_has(r_ptr->flags, s_ptr->resist_flag)) ||
(s_ptr->monster_flag && rf_has(r_ptr->flags,
s_ptr->monster_flag)) || (s_ptr->vuln_flag &&
rf_has(r_ptr->flags, s_ptr->vuln_flag))) {
/* compare multipliers to determine best attack */
if ((*best_s_ptr == NULL) || ((*best_s_ptr)->mult < s_ptr->mult))
*best_s_ptr = s_ptr;
}
}
}
static bool _fire_p(object_type *o_ptr)
{
u32b flgs[TR_FLAG_SIZE];
if (object_is_artifact(o_ptr)) return FALSE;
if (o_ptr->tval != TV_SCROLL && o_ptr->tval != TV_STAFF) return FALSE;
object_flags(o_ptr, flgs);
if (have_flag(flgs, TR_IGNORE_FIRE)) return FALSE;
return TRUE;
}
static size_t obj_desc_combat(const object_type *o_ptr, char *buf, size_t max,
size_t end, bool spoil)
{
bitflag flags[OF_SIZE];
bitflag flags_known[OF_SIZE];
object_flags(o_ptr, flags);
object_flags_known(o_ptr, flags_known);
if (of_has(flags, OF_SHOW_DICE)) {
/* Only display the real damage dice if the combat stats are known */
if (spoil || object_attack_plusses_are_visible(o_ptr))
strnfcat(buf, max, &end, " (%dd%d)", o_ptr->dd, o_ptr->ds);
else
strnfcat(buf, max, &end, " (%dd%d)", o_ptr->kind->dd, o_ptr->kind->ds);
}
if (of_has(flags, OF_SHOW_MULT)) {
/* Display shooting power as part of the multiplier */
if (of_has(flags, OF_MIGHT) &&
(spoil || object_flag_is_known(o_ptr, OF_MIGHT)))
strnfcat(buf, max, &end, " (x%d)", (o_ptr->sval % 10) + o_ptr->pval[which_pval(o_ptr, OF_MIGHT)]);
else
strnfcat(buf, max, &end, " (x%d)", o_ptr->sval % 10);
}
/* Show weapon bonuses */
if (spoil || object_attack_plusses_are_visible(o_ptr)) {
if (wield_slot(o_ptr) == INVEN_WIELD || wield_slot(o_ptr) == INVEN_BOW
|| obj_is_ammo(o_ptr) || o_ptr->to_d || o_ptr->to_h) {
/* Make an exception for body armor with only a to-hit penalty */
if (o_ptr->to_h < 0 && o_ptr->to_d == 0 &&
(o_ptr->tval == TV_SOFT_ARMOR ||
o_ptr->tval == TV_HARD_ARMOR ||
o_ptr->tval == TV_DRAG_ARMOR))
strnfcat(buf, max, &end, " (%+d)", o_ptr->to_h);
/* Otherwise, always use the full tuple */
else
strnfcat(buf, max, &end, " (%+d,%+d)", o_ptr->to_h, o_ptr->to_d);
}
}
/* Show armor bonuses */
if (spoil || object_defence_plusses_are_visible(o_ptr)) {
if (obj_desc_show_armor(o_ptr))
strnfcat(buf, max, &end, " [%d,%+d]", o_ptr->ac, o_ptr->to_a);
else if (o_ptr->to_a)
strnfcat(buf, max, &end, " [%+d]", o_ptr->to_a);
}
else if (obj_desc_show_armor(o_ptr))
strnfcat(buf, max, &end, " [%d]", object_was_sensed(o_ptr) ? o_ptr->ac : o_ptr->kind->ac);
return end;
}
/**
* Add power for non-derived flags (derived flags have flag_power 0)
*/
static int flags_power(const object_type *obj, int p, int verbose,
ang_file *log_file, bool known)
{
size_t i, j;
int q;
bitflag flags[OF_SIZE];
/* Extract the flags */
if (known)
object_flags(obj, flags);
else
object_flags_known(obj, flags);
/* Log the flags in human-readable form */
if (verbose)
log_flags(flags, log_file);
/* Zero the flag counts */
for (i = 0; i < N_ELEMENTS(flag_sets); i++)
flag_sets[i].count = 0;
for (i = of_next(flags, FLAG_START); i != FLAG_END;
i = of_next(flags, i + 1)) {
if (flag_power(i)) {
q = (flag_power(i) * flag_slot_mult(i, wield_slot(obj)));
p += q;
log_obj(format("Add %d power for %s, total is %d\n",
q, flag_name(i), p));
}
/* Track combinations of flag types */
for (j = 0; j < N_ELEMENTS(flag_sets); j++)
if (flag_sets[j].type == obj_flag_type(i))
flag_sets[j].count++;
}
/* Add extra power for multiple flags of the same type */
for (i = 0; i < N_ELEMENTS(flag_sets); i++) {
if (flag_sets[i].count > 1) {
q = (flag_sets[i].factor * flag_sets[i].count * flag_sets[i].count);
p += q;
log_obj(format("Add %d power for multiple %s, total is %d\n",
q, flag_sets[i].desc, p));
}
/* Add bonus if item has a full set of these flags */
if (flag_sets[i].count == flag_sets[i].size) {
q = flag_sets[i].bonus;
p += q;
log_obj(format("Add %d power for full set of %s, total is %d\n",
q, flag_sets[i].desc, p));
}
}
return p;
}
/**
* Notice things about an object that would be noticed in time.
*/
static void object_notice_after_time(void)
{
int i;
int flag;
object_type *o_ptr;
char o_name[80];
bitflag f[OF_SIZE], timed_mask[OF_SIZE];
flags_init(timed_mask, OF_SIZE, OF_NOTICE_TIMED_MASK, FLAG_END);
/* Check every item the player is wearing */
for (i = INVEN_WIELD; i < ALL_INVEN_TOTAL; i++)
{
o_ptr = &p_ptr->inventory[i];
if (!o_ptr->k_idx || object_is_known(o_ptr)) continue;
/* Check for timed notice flags */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE);
object_flags(o_ptr, f);
of_inter(f, timed_mask);
for (flag = of_next(f, FLAG_START); flag != FLAG_END; flag = of_next(f, flag + 1))
{
if (!of_has(o_ptr->known_flags, flag))
{
/* Message */
if (!streq(msgs[flag], ""))
msg_format(msgs[flag], o_name);
/* Notice the flag */
object_notice_flag(o_ptr, flag);
if (object_is_jewelry(o_ptr) &&
(!object_effect(o_ptr) || object_effect_is_known(o_ptr)))
{
/* XXX this is a small hack, but jewelry with anything noticeable really is obvious */
/* XXX except, wait until learn activation if that is only clue */
object_flavor_aware(o_ptr);
object_check_for_ident(o_ptr);
}
}
else
{
/* Notice the flag is absent */
object_notice_flag(o_ptr, flag);
}
}
/* XXX Is this necessary? */
object_check_for_ident(o_ptr);
}
}
static bool _absorb(object_type *o_ptr)
{
bool result = FALSE;
int i;
int div = 1;
object_kind *k_ptr = &k_info[o_ptr->k_idx];
u32b flags[TR_FLAG_SIZE];
object_flags(o_ptr, flags);
if (o_ptr->curse_flags & TRC_AGGRAVATE)
div++;
if (o_ptr->curse_flags & (TRC_TY_CURSE | TRC_HEAVY_CURSE))
div++;
if (!have_flag(flags, TR_ORDER) && !have_flag(flags, TR_WILD))
{
if (_add_essence(_ESSENCE_XTRA_DICE, (o_ptr->ds - k_ptr->ds)/1/*div?*/))
result = TRUE;
if (_add_essence(_ESSENCE_XTRA_DICE, (o_ptr->dd - k_ptr->dd)/1/*div?*/))
result = TRUE;
}
for (i = 0; i < TR_FLAG_MAX; i++)
{
if (_skip_flag(i)) continue;
if (have_flag(flags, i))
{
if (is_pval_flag(i))
{
if (_add_essence(i, o_ptr->pval/div))
result = TRUE;
}
else
{
_essences[i]++;
result = TRUE;
}
}
}
if (_add_essence(_ESSENCE_AC, o_ptr->to_a/div))
result = TRUE;
if (_add_essence(_ESSENCE_TO_HIT, o_ptr->to_h/div))
result = TRUE;
if (_add_essence(_ESSENCE_TO_DAM, o_ptr->to_d/div))
result = TRUE;
if (result)
{
p_ptr->update |= PU_BONUS;
msg_print("You grow stronger!");
}
return result;
}
static size_t obj_desc_light(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
bitflag f[OF_SIZE];
object_flags(o_ptr, f);
/* Fuelled light sources get number of remaining turns appended */
if ((o_ptr->tval == TV_LIGHT) && !of_has(f, OF_NO_FUEL))
strnfcat(buf, max, &end, " (%d turns)", o_ptr->timeout);
return end;
}
/**
* Get the object flags the player should know about for the given object/
* viewing mode combination.
*/
static void get_known_flags(const struct object *obj, const oinfo_detail_t mode,
bitflag flags[OF_SIZE])
{
/* Grab the object flags */
if (mode & OINFO_EGO) {
object_flags(obj, flags);
} else {
object_flags_known(obj, flags);
/* Don't include base flags when terse */
if (mode & OINFO_TERSE)
of_diff(flags, obj->kind->base->flags);
}
}
static bool _air_p(object_type *o_ptr)
{
u32b flgs[TR_FLAG_SIZE];
if (object_is_artifact(o_ptr)) return FALSE;
if ( o_ptr->tval != TV_RING
&& o_ptr->tval != TV_AMULET
&& o_ptr->tval != TV_WAND
&& o_ptr->tval != TV_ROD)
{
return FALSE;
}
object_flags(o_ptr, flgs);
if (have_flag(flgs, TR_IGNORE_ELEC)) return FALSE;
return TRUE;
}
/**
* Extract the multiplier from a given object hitting a given monster.
*
* If there is a slay or brand in effect, change the verb for hitting
* to something interesting ('burn', 'smite', etc.). Also, note which
* flags had an effect in o_ptr->known_flags[].
*
* \param o_ptr is the object being used to attack
* \param m_ptr is the monster being attacked
* \param best_s_ptr is the best applicable slay_table entry, or NULL if no
* slay already known
*
*/
void improve_attack_modifier(object_type *o_ptr, const monster_type *m_ptr, const slay_t **best_s_ptr)
{
const slay_t *s_ptr;
monster_race *r_ptr = &r_info[m_ptr->r_idx];
monster_lore *l_ptr = &l_list[m_ptr->r_idx];
bitflag f[OF_SIZE], known_f[OF_SIZE];
object_flags(o_ptr, f);
object_flags_known(o_ptr, known_f);
for (s_ptr = slay_table; s_ptr->slay_flag; s_ptr++)
{
if (!of_has(f, s_ptr->slay_flag)) continue;
/* Learn about monster resistance/vulnerability IF:
* 1) The slay flag on the object is known OR
* 2) The monster does not possess the appropriate resistance flag OR
* 3) The monster does possess the appropriate vulnerability flag
*/
if (of_has(known_f, s_ptr->slay_flag) ||
(s_ptr->monster_flag && rf_has(r_ptr->flags, s_ptr->monster_flag)) ||
(s_ptr->resist_flag && !rf_has(r_ptr->flags, s_ptr->resist_flag)))
{
if (m_ptr->ml && s_ptr->monster_flag)
{
rf_on(l_ptr->flags, s_ptr->monster_flag);
}
if (m_ptr->ml && s_ptr->resist_flag)
{
rf_on(l_ptr->flags, s_ptr->resist_flag);
}
}
/* If the monster doesn't match or the slay flag does */
if ((s_ptr->brand && !rf_has(r_ptr->flags, s_ptr->resist_flag)) ||
rf_has(r_ptr->flags, s_ptr->monster_flag))
{
/* notice any brand or slay that would affect the monster */
object_notice_slay(o_ptr, s_ptr->slay_flag);
/* compare multipliers to determine best attack, would be more complex for O-style brands */
if ((*best_s_ptr == NULL) || ((*best_s_ptr)->mult < s_ptr->mult))
*best_s_ptr = s_ptr;
}
}
}
/*
* \returns whether it is possible an object has a high resist given the
* player's current knowledge
*/
bool object_high_resist_is_possible(const object_type *o_ptr)
{
bitflag flags[OF_SIZE];
/* Actual object flags */
object_flags(o_ptr, flags);
/* Add player's uncertainty */
of_comp_union(flags, o_ptr->known_flags);
/* Check for possible high resist */
if (flags_test(flags, OF_SIZE, OF_HIGH_RESIST_MASK, FLAG_END))
return TRUE;
else
return FALSE;
}
/*
* Hook to determine if an object is activatable
*/
static bool item_tester_hook_activate(const object_type *o_ptr)
{
u32b f1, f2, f3;
/* Not known */
if (!object_known_p(o_ptr)) return (FALSE);
/* Extract the flags */
object_flags(o_ptr, &f1, &f2, &f3);
/* Check activation flag */
if (f3 & (TR3_ACTIVATE)) return (TRUE);
/* Assume not */
return (FALSE);
}
bool object_FA_would_be_obvious(const object_type *o_ptr)
{
bitflag flags[OF_SIZE];
if (!player_has(PF_CUMBER_GLOVE))
return FALSE;
if ((wield_slot(o_ptr) != INVEN_HANDS) || (o_ptr->sval == SV_SET_OF_ALCHEMISTS_GLOVES))
return FALSE;
object_flags(o_ptr, flags);
if (of_has(flags, OF_DEX))
return FALSE;
return TRUE;
}
/**
* Notice a given special flag on wielded items.
*
* \param flag is the flag to notice
*/
void wieldeds_notice_flag(int flag)
{
int i;
/* XXX Eddie need different naming conventions for starting wieldeds at INVEN_WIELD vs INVEN_WIELD+2 */
for (i = INVEN_WIELD; i < ALL_INVEN_TOTAL; i++)
{
object_type *o_ptr = &p_ptr->inventory[i];
bitflag f[OF_SIZE];
if (!o_ptr->k_idx) continue;
object_flags(o_ptr, f);
if (of_has(f, flag) && !of_has(o_ptr->known_flags, flag))
{
char o_name[80];
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE);
/* Notice the flag */
object_notice_flag(o_ptr, flag);
/* XXX Eddie should this go before noticing the flag to avoid learning twice? */
if (EASY_LEARN && object_is_jewelry(o_ptr))
{
/* XXX Eddie EASY_LEARN Possible concern: gets =teleportation just from +2 speed */
object_flavor_aware(o_ptr);
object_check_for_ident(o_ptr);
}
/* Message */
if (!streq(msgs[flag], ""))
msg_format(msgs[flag], o_name);
}
else
{
/* Notice that flag is absent */
object_notice_flag(o_ptr, flag);
}
/* XXX Eddie should not need this, should be done in noticing, but will remove later */
object_check_for_ident(o_ptr);
}
return;
}
/**
* Notice curses on an object.
*
* \param o_ptr is the object to notice curses on
*/
bool object_notice_curses(object_type *o_ptr)
{
bitflag f[OF_SIZE];
object_flags(o_ptr, f);
/* Know whatever curse flags there are to know */
flags_mask(f, OF_SIZE, OF_CURSE_MASK, FLAG_END);
/* give knowledge of which curses are present */
object_notice_flags(o_ptr, f);
object_check_for_ident(o_ptr);
p_ptr->notice |= PN_SQUELCH;
return !of_is_empty(f);
}
/**
* Apply generation magic to an ego-item.
*/
void ego_apply_magic(object_type *o_ptr, int level)
{
int i, flag, x;
bitflag flags[OF_SIZE], newf[OF_SIZE], f2[OF_SIZE];
object_flags(o_ptr, flags);
/* Extra powers */
if (o_ptr->ego->xtra == OBJECT_XTRA_TYPE_SUSTAIN)
create_mask(newf, FALSE, OFT_SUST, OFT_MAX);
else if (o_ptr->ego->xtra == OBJECT_XTRA_TYPE_RESIST)
create_mask(newf, FALSE, OFT_HRES, OFT_MAX);
else if (o_ptr->ego->xtra == OBJECT_XTRA_TYPE_POWER)
create_mask(newf, FALSE, OFT_PROT, OFT_MISC, OFT_MAX);
if (o_ptr->ego->xtra)
of_on(o_ptr->flags, get_new_attr(flags, newf));
/* Apply extra o_ptr->ego bonuses */
o_ptr->to_h += randcalc(o_ptr->ego->to_h, level, RANDOMISE);
o_ptr->to_d += randcalc(o_ptr->ego->to_d, level, RANDOMISE);
o_ptr->to_a += randcalc(o_ptr->ego->to_a, level, RANDOMISE);
/* Apply pvals */
of_copy(f2, o_ptr->ego->flags);
for (i = 0; i < o_ptr->ego->num_pvals; i++) {
of_copy(flags, o_ptr->ego->pval_flags[i]);
x = randcalc(o_ptr->ego->pval[i], level, RANDOMISE);
for (flag = of_next(flags, FLAG_START); flag != FLAG_END;
flag = of_next(flags, flag + 1))
/* Prevent phantom flags */
if (x)
object_add_pval(o_ptr, x, flag);
else
of_off(f2, flag);
}
/* Apply remaining flags */
of_union(o_ptr->flags, f2);
return;
}
void do_cmd_refill(cmd_code code, cmd_arg args[])
{
object_type *j_ptr = &p_ptr->inventory[INVEN_LIGHT];
bitflag f[OF_SIZE];
int item = args[0].item;
object_type *o_ptr = object_from_item_idx(item);
if (!item_is_available(item, NULL, USE_INVEN | USE_FLOOR))
{
msg("You do not have that item to refill with it.");
return;
}
/* Check what we're wielding. */
object_flags(j_ptr, f);
if (j_ptr->tval != TV_LIGHT)
{
msg("You are not wielding a light.");
return;
}
else if (of_has(f, OF_NO_FUEL))
{
msg("Your light cannot be refilled.");
return;
}
/* It's a lamp */
if (j_ptr->sval == SV_LIGHT_LANTERN)
refill_lamp(j_ptr, o_ptr, item);
/* It's a torch */
else if (j_ptr->sval == SV_LIGHT_TORCH)
refuel_torch(j_ptr, o_ptr, item);
p_ptr->energy_use = 50;
}
static void _water_process_world(void)
{
int inven_ct = 0;
int equip_ct = 0;
int chance = 15;
int i;
for (i = 0; i < INVEN_TOTAL; i++)
{
object_type *o_ptr = &inventory[i];
u32b flgs[TR_FLAG_SIZE];
char o_name[MAX_NLEN];
if (!o_ptr->k_idx) continue;
if (!object_is_armour(o_ptr)) continue;
if (randint0(1000) >= chance) continue;
if (o_ptr->ac + o_ptr->to_a <= 0) continue;
object_flags(o_ptr, flgs);
if (have_flag(flgs, TR_IGNORE_ACID)) continue;
object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
msg_format("Your watery touch corrodes your %s!", o_name);
o_ptr->to_a--;
if (i >= EQUIP_BEGIN) ++equip_ct;
else ++inven_ct;
}
if (equip_ct)
{
p_ptr->update |= PU_BONUS;
p_ptr->window |= PW_EQUIP | PW_PLAYER;
}
if (equip_ct + inven_ct)
disturb(1, 0);
}
/*
* Determine the "Activation" (if any) for an artefact
*/
static void describe_item_activation(const object_type *o_ptr, char *random_name, size_t max)
{
u32b f1, f2, f3;
/* Extract the flags */
object_flags(o_ptr, &f1, &f2, &f3);
/* Require activation ability */
if (!(f3 & TR3_ACTIVATE)) return;
/* Artefact activations */
if ((o_ptr->name1) && (o_ptr->name1 < z_info->art_norm_max))
{
artefact_type *a_ptr = &a_info[o_ptr->name1];
/* Paranoia */
if (a_ptr->activation >= ACT_MAX)
{
return;
}
/* Some artefacts can be activated */
my_strcat(random_name, act_description[a_ptr->activation], max);
/* Output the number of turns */
if (a_ptr->time && a_ptr->randtime)
my_strcat(random_name, format(" every %d+d%d turns", a_ptr->time, a_ptr->randtime), max);
else if (a_ptr->time)
my_strcat(random_name, format(" every %d turns", a_ptr->time), max);
else if (a_ptr->randtime)
my_strcat(random_name, format(" every d%d turns", a_ptr->randtime), max);
return;
}
}
/*
* Output object information
*/
bool object_info_out(const object_type *o_ptr)
{
u32b f1, f2, f3;
u32b ff1, ff2, ff3;
bool something = FALSE;
/* Grab the object flags */
object_info_out_flags(o_ptr, &f1, &f2, &f3);
/* Hack - grab the ID-independent flags */
/* Used to show handedness even when not ID'd */
object_flags(o_ptr, &ff1, &ff2, &ff3);
/* Describe the object */
if (describe_stats(o_ptr, f1)) something = TRUE;
if (describe_neg_stats(o_ptr, f1)) something = TRUE;
if (describe_secondary(o_ptr, f1)) something = TRUE;
if (describe_slay(o_ptr, f1)) something = TRUE;
if (describe_brand(o_ptr, f1)) something = TRUE;
if (describe_misc_weapon_attributes(o_ptr, f1)) something = TRUE;
if (describe_resist(o_ptr, f2)) something = TRUE;
if (describe_vulnerability(o_ptr, f2)) something = TRUE;
if (describe_sustains(o_ptr, f2)) something = TRUE;
if (describe_misc_magic(o_ptr, f2, f3)) something = TRUE;
if (describe_activation(o_ptr, f3)) something = TRUE;
if (describe_ignores(o_ptr, f3)) something = TRUE;
if (describe_abilities(o_ptr)) something = TRUE;
if (describe_handedness(o_ptr, ff3)) something = TRUE;
if (describe_polearmness(ff3)) something = TRUE;
if (describe_archery(o_ptr)) something = TRUE;
/* We are done. */
return something;
}
