/**
* Remove slays which are duplicates, i.e. they have exactly the same "monster
* flag" and the same "resist flag". The one with highest multiplier is kept.
*
* \param flags is the flagset from which to remove duplicates.
* count is the number of dups removed.
*/
int dedup_slays(bitflag *flags) {
int i, j;
int count = 0;
for (i = 0; i < SL_MAX; i++) {
const struct slay *s_ptr = &slay_table[i];
if (of_has(flags, s_ptr->object_flag)) {
for (j = i + 1; j < SL_MAX; j++) {
const struct slay *t_ptr = &slay_table[j];
if (of_has(flags, t_ptr->object_flag) &&
(t_ptr->monster_flag == s_ptr->monster_flag) &&
(t_ptr->resist_flag == s_ptr->resist_flag) &&
(t_ptr->mult != s_ptr->mult)) {
count++;
if (t_ptr->mult > s_ptr->mult)
of_off(flags, s_ptr->object_flag);
else
of_off(flags, t_ptr->object_flag);
}
}
}
}
return count;
}
/**
* Wipe an object clean and make it a standard object of the specified kind.
*/
void object_prep(object_type *o_ptr, struct object_kind *k, int lev,
aspect rand_aspect)
{
int i, flag, pval;
bitflag flags[OF_SIZE], f2[OF_SIZE];
/* Clean slate */
WIPE(o_ptr, object_type);
/* Assign the kind and copy across data */
o_ptr->kind = k;
o_ptr->tval = k->tval;
o_ptr->sval = k->sval;
o_ptr->ac = k->ac;
o_ptr->dd = k->dd;
o_ptr->ds = k->ds;
o_ptr->weight = k->weight;
/* Default number */
o_ptr->number = 1;
/* Apply pvals and then copy flags */
of_copy(f2, k->flags);
for (i = 0; i < k->num_pvals; i++) {
of_copy(flags, k->pval_flags[i]);
pval = randcalc(k->pval[i], lev, rand_aspect);
for (flag = of_next(flags, FLAG_START); flag != FLAG_END;
flag = of_next(flags, flag + 1))
/* Prevent phantom flags */
if (pval)
object_add_pval(o_ptr, pval, flag);
else
of_off(f2, flag);
}
of_copy(o_ptr->flags, k->base->flags);
of_union(o_ptr->flags, f2);
/* Assign charges (wands/staves only) */
if (o_ptr->tval == TV_WAND || o_ptr->tval == TV_STAFF)
o_ptr->pval[DEFAULT_PVAL] = randcalc(k->charge, lev, rand_aspect);
/* Assign flagless pval for food or oil */
if (o_ptr->tval == TV_FOOD || o_ptr->tval == TV_POTION ||
o_ptr->tval == TV_FLASK)
o_ptr->pval[DEFAULT_PVAL]
= randcalc(k->pval[DEFAULT_PVAL], lev, rand_aspect);
/* Default fuel for lamps */
if (o_ptr->tval == TV_LIGHT) {
if (o_ptr->sval == SV_LIGHT_TORCH)
o_ptr->timeout = DEFAULT_TORCH;
else if (o_ptr->sval == SV_LIGHT_LANTERN)
o_ptr->timeout = DEFAULT_LAMP;
}
/* Default magic */
o_ptr->to_h = randcalc(k->to_h, lev, rand_aspect);
o_ptr->to_d = randcalc(k->to_d, lev, rand_aspect);
o_ptr->to_a = randcalc(k->to_a, lev, rand_aspect);
}
/**
* 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;
}
/**
* Apply an affix to an ego-item, checking minima as we go.
*
* \param o_ptr is the object we're modifying
* \param level is the generation level
* \param affix is the affix we're applying
*/
void ego_apply_magic(object_type *o_ptr, int level, int affix)
{
int i, j, flag, pval, amt;
bitflag flags[OF_SIZE], f2[OF_SIZE];
ego_item_type *ego;
ego = &e_info[affix];
/* Random powers */
for (i = 0; i < ego->num_randlines; i++)
for (j = 0; j < ego->num_randflags[i]; j++)
of_on(o_ptr->flags, get_new_attr(o_ptr->flags, ego->randmask[i]));
/* Apply extra combat bonuses */
amt = randcalc(ego->to_h, level, RANDOMISE);
o_ptr->to_h += amt;
if (ego->min_to_h != NO_MINIMUM) {
if (amt < ego->min_to_h)
o_ptr->to_h += ego->min_to_h - amt;
if (o_ptr->to_h < ego->min_to_h)
o_ptr->to_h = ego->min_to_h;
}
amt = randcalc(ego->to_d, level, RANDOMISE);
o_ptr->to_d += amt;
if (ego->min_to_d != NO_MINIMUM) {
if (amt < ego->min_to_d)
o_ptr->to_d += ego->min_to_d - amt;
if (o_ptr->to_d < ego->min_to_d)
o_ptr->to_d = ego->min_to_d;
}
amt = randcalc(ego->to_a, level, RANDOMISE);
o_ptr->to_a += amt;
if (ego->min_to_a != NO_MINIMUM) {
if (amt < ego->min_to_a)
o_ptr->to_a += ego->min_to_a - amt;
if (o_ptr->to_a < ego->min_to_a)
o_ptr->to_a = ego->min_to_a;
}
/* Apply pvals */
of_copy(f2, ego->flags);
for (i = 0; i < ego->num_pvals; i++) {
of_copy(flags, ego->pval_flags[i]);
pval = randcalc(ego->pval[i], level, RANDOMISE);
if (ego->min_pval[i] != NO_MINIMUM && pval < ego->min_pval[i])
pval = ego->min_pval[i];
for (flag = of_next(flags, FLAG_START); flag != FLAG_END;
flag = of_next(flags, flag + 1))
/* Prevent phantom flags, and check minima after adding */
if (pval) {
object_add_pval(o_ptr, pval, flag);
if (ego->min_pval[i] != NO_MINIMUM && of_has(o_ptr->flags,
flag))
if (o_ptr->pval[which_pval(o_ptr, flag)] < ego->min_pval[i])
object_add_pval(o_ptr, ego->min_pval[i] -
o_ptr->pval[which_pval(o_ptr, flag)], flag);
} else
of_off(f2, flag);
}
/* Apply remaining flags */
of_union(o_ptr->flags, f2);
/* Adjust AC, weight, dice and sides */
if (o_ptr->ac && ego->ac_mod)
o_ptr->ac = ((100 + ego->ac_mod) * o_ptr->ac) / 100;
o_ptr->weight = ((100 + ego->wgt_mod) * o_ptr->weight) / 100;
o_ptr->dd += ego->dd;
if (o_ptr->dd < 1)
o_ptr->dd = 1;
o_ptr->ds += ego->ds;
if (o_ptr->ds < 1)
o_ptr->ds = 1;
/* Tidy up and de-duplicate flags, and set the correct prefix/suffix */
check_flags(o_ptr);
obj_affix_names(o_ptr);
return;
}
