/* release the objects the creature is carrying */
void
relobj(struct monst *mtmp, int show, boolean is_pet)
{ /* If true, pet should keep wielded/worn items */
struct obj *otmp;
int omx = mtmp->mx, omy = mtmp->my;
struct obj *keepobj = 0;
struct obj *wep = MON_WEP(mtmp), *hwep = attacktype(mtmp->data, AT_WEAP)
? select_hwep(mtmp) : (struct obj *)0, *proj =
attacktype(mtmp->data, AT_WEAP)
? select_rwep(mtmp) : (struct obj *)0, *rwep;
boolean item1 = FALSE, item2 = FALSE;
rwep = attacktype(mtmp->data, AT_WEAP) ? propellor : &zeroobj;
if (!is_pet || mindless(mtmp->data) || is_animal(mtmp->data))
item1 = item2 = TRUE;
if (!tunnels(mtmp->data) || !needspick(mtmp->data))
item1 = TRUE;
while ((otmp = mtmp->minvent) != 0) {
obj_extract_self(otmp);
/* special case: pick-axe and unicorn horn are non-worn */
/* items that we also want pets to keep 1 of */
/* (It is a coincidence that these can also be wielded.) */
if (otmp->owornmask || otmp == wep || otmp == hwep || otmp == rwep ||
otmp == proj ||
would_prefer_hwep(mtmp, otmp) || /* cursed item in hand? */
would_prefer_rwep(mtmp, otmp) || could_use_item(mtmp, otmp) ||
((!rwep || rwep == &zeroobj) &&
(is_ammo(otmp) || is_launcher(otmp))) ||
(rwep && rwep != &zeroobj && ammo_and_launcher(otmp, rwep)) ||
((!item1 && otmp->otyp == PICK_AXE) ||
(!item2 && otmp->otyp == UNICORN_HORN && !otmp->cursed))) {
if (is_pet) { /* dont drop worn/wielded item */
if (otmp->otyp == PICK_AXE)
item1 = TRUE;
if (otmp->otyp == UNICORN_HORN && !otmp->cursed)
item2 = TRUE;
otmp->nobj = keepobj;
keepobj = otmp;
continue;
}
}
if (otmp == wep)
setmnotwielded(mtmp, otmp);
mdrop_obj(mtmp, otmp, is_pet && flags.verbose);
}
/* put kept objects back */
while ((otmp = keepobj) != NULL) {
keepobj = otmp->nobj;
add_to_minv(mtmp, otmp);
}
if (show & cansee(omx, omy))
newsym(omx, omy);
}
/* creature sticks other creatures it hits */
boolean
sticks(const struct permonst * ptr)
{
return ((boolean)
(dmgtype(ptr, AD_STCK) || dmgtype(ptr, AD_WRAP) ||
attacktype(ptr, AT_HUGS)));
}
/* Returns 1 if otmp is free'd, 0 otherwise. */
int mpickobj(struct monst *mtmp, struct obj *otmp)
{
int freed_otmp;
boolean snuff_otmp = FALSE;
/* don't want hidden light source inside the monster; assumes that
engulfers won't have external inventories; whirly monsters cause
the light to be extinguished rather than letting it shine thru */
if (otmp->lamplit && /* hack to avoid function calls for most objs */
obj_sheds_light(otmp) &&
attacktype(mtmp->data, AT_ENGL)) {
/* this is probably a burning object that you dropped or threw */
if (u.uswallow && mtmp == u.ustuck && !Blind)
pline("%s out.", Tobjnam(otmp, "go"));
snuff_otmp = TRUE;
}
/* Must do carrying effects on object prior to add_to_minv() */
carry_obj_effects(otmp);
/* add_to_minv() might free otmp [if merged with something else],
so we have to call it after doing the object checks */
freed_otmp = add_to_minv(mtmp, otmp);
/* and we had to defer this until object is in mtmp's inventory */
if (snuff_otmp) snuff_light_source(mtmp->mx, mtmp->my);
return freed_otmp;
}
/* Returns 1 if otmp is free'd, 0 otherwise. */
int mpickobj (struct monst *mtmp, struct obj *otmp) {
int freed_otmp;
if (otmp->oclass == COIN_CLASS) {
mtmp->mgold += otmp->quan;
obfree(otmp, (struct obj *)0);
freed_otmp = 1;
} else {
bool snuff_otmp = false;
/* don't want hidden light source inside the monster; assumes that
engulfers won't have external inventories; whirly monsters cause
the light to be extinguished rather than letting it shine thru */
if (otmp->lamplit && /* hack to avoid function calls for most objs */
obj_sheds_light(otmp) &&
attacktype(mtmp->data, AT_ENGL)) {
/* this is probably a burning object that you dropped or threw */
if (u.uswallow && mtmp == u.ustuck && !Blind()) {
message_object(MSG_O_GO_OUT, otmp);
}
snuff_otmp = true;
}
/* Must do carrying effects on object prior to add_to_minv() */
carry_obj_effects(otmp);
/* add_to_minv() might free otmp [if merged with something else],
so we have to call it after doing the object checks */
freed_otmp = add_to_minv(mtmp, otmp);
/* and we had to defer this until object is in mtmp's inventory */
if (snuff_otmp) snuff_light_source(mtmp->mx, mtmp->my);
}
return freed_otmp;
}
/*
* See if a monst could use this item in an offensive or defensive capacity.
*/
boolean
could_use_item(struct monst *mtmp, struct obj *otmp)
{
boolean can_use =
/* make sure this is an intelligent monster */
(mtmp && !is_animal(mtmp->data) && !mindless(mtmp->data) &&
!nohands(mtmp->data) && otmp &&
/* food */
((dogfood(mtmp, otmp) < APPORT) ||
/* better weapons */
(attacktype(mtmp->data, AT_WEAP) &&
(otmp->oclass == WEAPON_CLASS || is_weptool(otmp)) &&
(would_prefer_hwep(mtmp, otmp) || would_prefer_rwep(mtmp, otmp))) ||
/* better armor */
(otmp->oclass == ARMOR_CLASS && is_better_armor(mtmp, otmp)) ||
/* useful amulets */
otmp->otyp == AMULET_OF_LIFE_SAVING ||
otmp->otyp == AMULET_OF_REFLECTION ||
/* misc magic items that muse can use */
otmp->otyp == SCR_TELEPORTATION || otmp->otyp == SCR_EARTH ||
otmp->otyp == SCR_REMOVE_CURSE || otmp->otyp == WAN_DEATH ||
otmp->otyp == WAN_DIGGING || otmp->otyp == WAN_FIRE ||
otmp->otyp == WAN_COLD || otmp->otyp == WAN_LIGHTNING ||
otmp->otyp == WAN_MAGIC_MISSILE || otmp->otyp == WAN_STRIKING ||
otmp->otyp == WAN_TELEPORTATION || otmp->otyp == POT_HEALING ||
otmp->otyp == POT_EXTRA_HEALING || otmp->otyp == POT_FULL_HEALING ||
otmp->otyp == POT_PARALYSIS || otmp->otyp == POT_BLINDNESS ||
otmp->otyp == POT_CONFUSION || otmp->otyp == POT_ACID ||
otmp->otyp == FROST_HORN || otmp->otyp == FIRE_HORN ||
otmp->otyp == UNICORN_HORN));
if (can_use) {
/* arbitrary - greedy monsters keep any item you can use */
if (likes_gold(mtmp->data))
return TRUE;
if (otmp->oclass == ARMOR_CLASS) {
return !is_better_armor(&youmonst, otmp);
} else if (otmp->oclass == WAND_CLASS && otmp->spe <= 0)
return FALSE; /* used charges or was cancelled? */
else {
/* Check if you've got one. If you don't, don't hoard it. */
register struct obj *otmp2;
for (otmp2 = invent; otmp2; otmp2 = otmp2->nobj)
if (otmp->otyp == otmp2->otyp)
return TRUE;
}
}
return FALSE;
}
static struct obj *
DROPPABLES(struct monst *mon)
{
struct obj *obj;
struct obj *wep = MON_WEP(mon), *hwep = attacktype(mon->data, AT_WEAP)
? select_hwep(mon) : (struct obj *)0, *proj =
attacktype(mon->data, AT_WEAP)
? select_rwep(mon) : (struct obj *)0, *rwep;
boolean item1 = FALSE, item2 = FALSE;
rwep = attacktype(mon->data, AT_WEAP) ? propellor : &zeroobj;
if (is_animal(mon->data) || mindless(mon->data))
item1 = item2 = TRUE;
if (!tunnels(mon->data) || !needspick(mon->data))
item1 = TRUE;
for (obj = mon->minvent; obj; obj = obj->nobj) {
if (!item1 && is_pick(obj) &&
(obj->otyp != DWARVISH_MATTOCK || !which_armor(mon, W_ARMS))) {
item1 = TRUE;
continue;
}
if (!item2 && obj->otyp == UNICORN_HORN && !obj->cursed) {
item2 = TRUE;
continue;
}
if (!obj->owornmask && obj != wep && obj != rwep &&
obj != proj && obj != hwep &&
!would_prefer_hwep(mon, obj) /* cursed item in hand? */
&& !would_prefer_rwep(mon, obj)
&& ((rwep != &zeroobj) || (!is_ammo(obj) && !is_launcher(obj)))
&& (rwep == &zeroobj || !ammo_and_launcher(obj, rwep))
&& !could_use_item(mon, obj))
return obj;
}
return NULL;
}
/* returns 1 if polymorph successful */
int polymon(int mntmp)
{
boolean sticky = sticks(youmonst.data) && u.ustuck && !u.uswallow,
was_blind = !!Blind, dochange = FALSE;
boolean could_pass_walls = Passes_walls;
int mlvl;
if (mvitals[mntmp].mvflags & G_GENOD) { /* allow G_EXTINCT */
pline("You feel rather %s-ish.",mons[mntmp].mname);
exercise(A_WIS, TRUE);
return 0;
}
/* KMH, conduct */
u.uconduct.polyselfs++;
if (!Upolyd) {
/* Human to monster; save human stats */
u.macurr = u.acurr;
u.mamax = u.amax;
u.mfemale = flags.female;
} else {
/* Monster to monster; restore human stats, to be
* immediately changed to provide stats for the new monster
*/
u.acurr = u.macurr;
u.amax = u.mamax;
flags.female = u.mfemale;
}
if (youmonst.m_ap_type) {
/* stop mimicking immediately */
if (multi < 0) unmul("");
} else if (mons[mntmp].mlet != S_MIMIC) {
/* as in polyman() */
youmonst.m_ap_type = M_AP_NOTHING;
}
if (is_male(&mons[mntmp])) {
if (flags.female) dochange = TRUE;
} else if (is_female(&mons[mntmp])) {
if (!flags.female) dochange = TRUE;
} else if (!is_neuter(&mons[mntmp]) && mntmp != u.ulycn) {
if (!rn2(10)) dochange = TRUE;
}
if (dochange) {
flags.female = !flags.female;
pline("You %s %s%s!",
(u.umonnum != mntmp) ? "turn into a" : "feel like a new",
(is_male(&mons[mntmp]) || is_female(&mons[mntmp])) ? "" :
flags.female ? "female " : "male ",
mons[mntmp].mname);
} else {
if (u.umonnum != mntmp)
pline("You turn into %s!", an(mons[mntmp].mname));
else
pline("You feel like a new %s!", mons[mntmp].mname);
}
if (Stoned && poly_when_stoned(&mons[mntmp])) {
/* poly_when_stoned already checked stone golem genocide */
pline("You turn to stone!");
mntmp = PM_STONE_GOLEM;
Stoned = 0;
delayed_killer = 0;
}
u.mtimedone = rn1(500, 500);
u.umonnum = mntmp;
set_uasmon();
/* New stats for monster, to last only as long as polymorphed.
* Currently only strength gets changed.
*/
if (strongmonst(&mons[mntmp])) ABASE(A_STR) = AMAX(A_STR) = STR18(100);
if (Stone_resistance && Stoned) { /* [email protected] */
Stoned = 0;
delayed_killer = 0;
pline("You no longer seem to be petrifying.");
}
if (Sick_resistance && Sick) {
make_sick(0L, NULL, FALSE, SICK_ALL);
pline("You no longer feel sick.");
}
if (Slimed) {
if (flaming(youmonst.data)) {
pline("The slime burns away!");
Slimed = 0L;
iflags.botl = 1;
} else if (mntmp == PM_GREEN_SLIME) {
/* do it silently */
Slimed = 0L;
iflags.botl = 1;
}
}
if (nohands(youmonst.data)) Glib = 0;
/*
mlvl = adj_lev(&mons[mntmp]);
* We can't do the above, since there's no such thing as an
* "experience level of you as a monster" for a polymorphed character.
*/
mlvl = (int)mons[mntmp].mlevel;
if (youmonst.data->mlet == S_DRAGON && mntmp >= PM_GRAY_DRAGON) {
u.mhmax = In_endgame(&u.uz) ? (8*mlvl) : (4*mlvl + dice(mlvl,4));
} else if (is_golem(youmonst.data)) {
u.mhmax = golemhp(mntmp);
} else {
if (!mlvl) u.mhmax = rnd(4);
else u.mhmax = dice(mlvl, 8);
if (is_home_elemental(&u.uz, &mons[mntmp])) u.mhmax *= 3;
}
u.mh = u.mhmax;
if (u.ulevel < mlvl) {
/* Low level characters can't become high level monsters for long */
u.mtimedone = u.mtimedone * u.ulevel / mlvl;
}
if (uskin && mntmp != armor_to_dragon(uskin->otyp))
skinback(FALSE);
break_armor();
drop_weapon(1);
if (hides_under(youmonst.data))
u.uundetected = OBJ_AT(u.ux, u.uy);
else if (youmonst.data->mlet == S_EEL)
u.uundetected = is_pool(level, u.ux, u.uy);
else
u.uundetected = 0;
if (u.utraptype == TT_PIT) {
if (could_pass_walls && !Passes_walls) {
u.utrap = rn1(6,2);
} else if (!could_pass_walls && Passes_walls) {
u.utrap = 0;
}
}
if (was_blind && !Blind) { /* previous form was eyeless */
Blinded = 1L;
make_blinded(0L, TRUE); /* remove blindness */
}
newsym(u.ux,u.uy); /* Change symbol */
if (!sticky && !u.uswallow && u.ustuck && sticks(youmonst.data)) u.ustuck = 0;
else if (sticky && !sticks(youmonst.data)) uunstick();
if (u.usteed) {
if (touch_petrifies(u.usteed->data) &&
!Stone_resistance && rnl(3)) {
char buf[BUFSZ];
pline("No longer petrifying-resistant, you touch %s.",
mon_nam(u.usteed));
sprintf(buf, "riding %s", an(u.usteed->data->mname));
instapetrify(buf);
}
if (!can_ride(u.usteed)) dismount_steed(DISMOUNT_POLY);
}
if (flags.verbose) {
static const char use_thec[] = "Use the command #%s to %s.";
static const char monsterc[] = "monster";
if (can_breathe(youmonst.data))
pline(use_thec,monsterc,"use your breath weapon");
if (attacktype(youmonst.data, AT_SPIT))
pline(use_thec,monsterc,"spit venom");
if (youmonst.data->mlet == S_NYMPH)
pline(use_thec,monsterc,"remove an iron ball");
if (attacktype(youmonst.data, AT_GAZE))
pline(use_thec,monsterc,"gaze at monsters");
if (is_hider(youmonst.data))
pline(use_thec,monsterc,"hide");
if (is_were(youmonst.data))
pline(use_thec,monsterc,"summon help");
if (webmaker(youmonst.data))
pline(use_thec,monsterc,"spin a web");
if (u.umonnum == PM_GREMLIN)
pline(use_thec,monsterc,"multiply in a fountain");
if (is_unicorn(youmonst.data))
pline(use_thec,monsterc,"use your horn");
if (is_mind_flayer(youmonst.data))
pline(use_thec,monsterc,"emit a mental blast");
if (youmonst.data->msound == MS_SHRIEK) /* worthless, actually */
pline(use_thec,monsterc,"shriek");
if (lays_eggs(youmonst.data) && flags.female)
pline(use_thec,"sit","lay an egg");
}
/* you now know what an egg of your type looks like */
if (lays_eggs(youmonst.data)) {
learn_egg_type(u.umonnum);
/* make queen bees recognize killer bee eggs */
learn_egg_type(egg_type_from_parent(u.umonnum, TRUE));
}
find_ac();
if ((!Levitation && !u.ustuck && !Flying &&
(is_pool(level, u.ux,u.uy) || is_lava(level, u.ux,u.uy))) ||
(Underwater && !Swimming))
spoteffects(TRUE);
if (Passes_walls && u.utrap && u.utraptype == TT_INFLOOR) {
u.utrap = 0;
pline("The rock seems to no longer trap you.");
} else if (likes_lava(youmonst.data) && u.utrap && u.utraptype == TT_LAVA) {
u.utrap = 0;
pline("The lava now feels soothing.");
}
if (amorphous(youmonst.data) || is_whirly(youmonst.data) || unsolid(youmonst.data)) {
if (Punished) {
pline("You slip out of the iron chain.");
unpunish();
}
}
if (u.utrap && (u.utraptype == TT_WEB || u.utraptype == TT_BEARTRAP) &&
(amorphous(youmonst.data) || is_whirly(youmonst.data) || unsolid(youmonst.data) ||
(youmonst.data->msize <= MZ_SMALL && u.utraptype == TT_BEARTRAP))) {
pline("You are no longer stuck in the %s.",
u.utraptype == TT_WEB ? "web" : "bear trap");
/* probably should burn webs too if PM_FIRE_ELEMENTAL */
u.utrap = 0;
}
if (webmaker(youmonst.data) && u.utrap && u.utraptype == TT_WEB) {
pline("You orient yourself on the web.");
u.utrap = 0;
}
iflags.botl = 1;
vision_full_recalc = 1;
see_monsters();
exercise(A_CON, FALSE);
exercise(A_WIS, TRUE);
encumber_msg();
return 1;
}
const char *mbodypart(struct monst *mon, int part)
{
static const char
*const humanoid_parts[] = { "arm", "eye", "face", "finger",
"fingertip", "foot", "hand", "handed", "head", "leg",
"light headed", "neck", "spine", "toe", "hair",
"blood", "lung", "nose", "stomach"},
*const jelly_parts[] = { "pseudopod", "dark spot", "front",
"pseudopod extension", "pseudopod extremity",
"pseudopod root", "grasp", "grasped", "cerebral area",
"lower pseudopod", "viscous", "middle", "surface",
"pseudopod extremity", "ripples", "juices",
"surface", "sensor", "stomach" },
*const animal_parts[] = { "forelimb", "eye", "face", "foreclaw", "claw tip",
"rear claw", "foreclaw", "clawed", "head", "rear limb",
"light headed", "neck", "spine", "rear claw tip",
"fur", "blood", "lung", "nose", "stomach" },
*const bird_parts[] = { "wing", "eye", "face", "wing", "wing tip",
"foot", "wing", "winged", "head", "leg",
"light headed", "neck", "spine", "toe",
"feathers", "blood", "lung", "bill", "stomach" },
*const horse_parts[] = { "foreleg", "eye", "face", "forehoof", "hoof tip",
"rear hoof", "foreclaw", "hooved", "head", "rear leg",
"light headed", "neck", "backbone", "rear hoof tip",
"mane", "blood", "lung", "nose", "stomach"},
*const sphere_parts[] = { "appendage", "optic nerve", "body", "tentacle",
"tentacle tip", "lower appendage", "tentacle", "tentacled",
"body", "lower tentacle", "rotational", "equator", "body",
"lower tentacle tip", "cilia", "life force", "retina",
"olfactory nerve", "interior" },
*const fungus_parts[] = { "mycelium", "visual area", "front", "hypha",
"hypha", "root", "strand", "stranded", "cap area",
"rhizome", "sporulated", "stalk", "root", "rhizome tip",
"spores", "juices", "gill", "gill", "interior" },
*const vortex_parts[] = { "region", "eye", "front", "minor current",
"minor current", "lower current", "swirl", "swirled",
"central core", "lower current", "addled", "center",
"currents", "edge", "currents", "life force",
"center", "leading edge", "interior" },
*const snake_parts[] = { "vestigial limb", "eye", "face", "large scale",
"large scale tip", "rear region", "scale gap", "scale gapped",
"head", "rear region", "light headed", "neck", "length",
"rear scale", "scales", "blood", "lung", "forked tongue", "stomach" },
*const fish_parts[] = { "fin", "eye", "premaxillary", "pelvic axillary",
"pelvic fin", "anal fin", "pectoral fin", "finned", "head", "peduncle",
"played out", "gills", "dorsal fin", "caudal fin",
"scales", "blood", "gill", "nostril", "stomach" };
/* claw attacks are overloaded in mons[]; most humanoids with
such attacks should still reference hands rather than claws */
static const char not_claws[] = {
S_HUMAN, S_MUMMY, S_ZOMBIE, S_ANGEL,
S_NYMPH, S_LEPRECHAUN, S_QUANTMECH, S_VAMPIRE,
S_ORC, S_GIANT, /* quest nemeses */
'\0' /* string terminator; assert( S_xxx != 0 ); */
};
const struct permonst *mptr = mon->data;
if (part == HAND || part == HANDED) { /* some special cases */
if (mptr->mlet == S_DOG || mptr->mlet == S_FELINE ||
mptr->mlet == S_YETI)
return part == HAND ? "paw" : "pawed";
if (humanoid(mptr) && attacktype(mptr, AT_CLAW) &&
!strchr(not_claws, mptr->mlet) &&
mptr != &mons[PM_STONE_GOLEM] &&
mptr != &mons[PM_INCUBUS] && mptr != &mons[PM_SUCCUBUS])
return part == HAND ? "claw" : "clawed";
}
if ((mptr == &mons[PM_MUMAK] || mptr == &mons[PM_MASTODON]) &&
part == NOSE)
return "trunk";
if (mptr == &mons[PM_SHARK] && part == HAIR)
return "skin"; /* sharks don't have scales */
if (mptr == &mons[PM_JELLYFISH] && (part == ARM || part == FINGER ||
part == HAND || part == FOOT || part == TOE))
return "tentacle";
if (mptr == &mons[PM_FLOATING_EYE] && part == EYE)
return "cornea";
if (humanoid(mptr) &&
(part == ARM || part == FINGER || part == FINGERTIP ||
part == HAND || part == HANDED))
return humanoid_parts[part];
if (mptr == &mons[PM_RAVEN])
return bird_parts[part];
if (mptr->mlet == S_CENTAUR || mptr->mlet == S_UNICORN ||
(mptr == &mons[PM_ROTHE] && part != HAIR))
return horse_parts[part];
if (mptr->mlet == S_LIGHT) {
if (part == HANDED) return "rayed";
else if (part == ARM || part == FINGER ||
part == FINGERTIP || part == HAND) return "ray";
else return "beam";
}
if (mptr->mlet == S_EEL && mptr != &mons[PM_JELLYFISH])
return fish_parts[part];
if (slithy(mptr) || (mptr->mlet == S_DRAGON && part == HAIR))
return snake_parts[part];
if (mptr->mlet == S_EYE)
return sphere_parts[part];
if (mptr->mlet == S_JELLY || mptr->mlet == S_PUDDING ||
mptr->mlet == S_BLOB || mptr == &mons[PM_JELLYFISH])
return jelly_parts[part];
if (mptr->mlet == S_VORTEX || mptr->mlet == S_ELEMENTAL)
return vortex_parts[part];
if (mptr->mlet == S_FUNGUS)
return fungus_parts[part];
if (humanoid(mptr))
return humanoid_parts[part];
return animal_parts[part];
}
/* called when someone is being hit by Magicbane */
static boolean magicbane_hit(
struct monst *magr, /* attacker */
struct monst *mdef, /* defender */
struct obj *mb, /* Magicbane */
int *dmgptr, /* extra damage target will suffer */
int dieroll, /* d20 that has already scored a hit */
boolean vis, /* whether the action can be seen */
char *hittee /* target's name: "you" or mon_nam(mdef) */
)
{
const struct permonst *old_uasmon;
const char *verb;
boolean youattack = (magr == &youmonst),
youdefend = (mdef == &youmonst),
resisted = FALSE, do_stun, do_confuse, result;
int attack_indx, scare_dieroll = MB_MAX_DIEROLL / 2;
result = FALSE; /* no message given yet */
/* the most severe effects are less likely at higher enchantment */
if (mb->spe >= 3)
scare_dieroll /= (1 << (mb->spe / 3));
/* if target successfully resisted the artifact damage bonus,
reduce overall likelihood of the assorted special effects */
if (!spec_dbon_applies) dieroll += 1;
/* might stun even when attempting a more severe effect, but
in that case it will only happen if the other effect fails;
extra damage will apply regardless; 3.4.1: sometimes might
just probe even when it hasn't been enchanted */
do_stun = (max(mb->spe,0) < rn2(spec_dbon_applies ? 11 : 7));
/* the special effects also boost physical damage; increments are
generally cumulative, but since the stun effect is based on a
different criterium its damage might not be included; the base
damage is either 1d4 (athame) or 2d4 (athame+spec_dbon) depending
on target's resistance check against AD_STUN (handled by caller)
[note that a successful save against AD_STUN doesn't actually
prevent the target from ending up stunned] */
attack_indx = MB_INDEX_PROBE;
*dmgptr += rnd(4); /* (2..3)d4 */
if (do_stun) {
attack_indx = MB_INDEX_STUN;
*dmgptr += rnd(4); /* (3..4)d4 */
}
if (dieroll <= scare_dieroll) {
attack_indx = MB_INDEX_SCARE;
*dmgptr += rnd(4); /* (3..5)d4 */
}
if (dieroll <= (scare_dieroll / 2)) {
attack_indx = MB_INDEX_CANCEL;
*dmgptr += rnd(4); /* (4..6)d4 */
}
/* give the hit message prior to inflicting the effects */
verb = mb_verb[!!Hallucination][attack_indx];
if (youattack || youdefend || vis) {
result = TRUE;
pline("The magic-absorbing blade %s %s!",
vtense(NULL, verb), hittee);
/* assume probing has some sort of noticeable feedback
even if it is being done by one monster to another */
if (attack_indx == MB_INDEX_PROBE && !canspotmon(mdef))
map_invisible(mdef->mx, mdef->my);
}
/* now perform special effects */
switch (attack_indx) {
case MB_INDEX_CANCEL:
old_uasmon = youmonst.data;
/* No mdef->mcan check: even a cancelled monster can be polymorphed
* into a golem, and the "cancel" effect acts as if some magical
* energy remains in spellcasting defenders to be absorbed later.
*/
if (!cancel_monst(mdef, mb, youattack, FALSE, FALSE)) {
resisted = TRUE;
} else {
do_stun = FALSE;
if (youdefend) {
if (youmonst.data != old_uasmon)
*dmgptr = 0; /* rehumanized, so no more damage */
if (u.uenmax > 0) {
pline("You lose magical energy!");
u.uenmax--;
if (u.uen > 0) u.uen--;
iflags.botl = 1;
}
} else {
if (mdef->data == &mons[PM_CLAY_GOLEM])
mdef->mhp = 1; /* cancelled clay golems will die */
if (youattack && attacktype(mdef->data, AT_MAGC)) {
pline("You absorb magical energy!");
u.uenmax++;
u.uen++;
iflags.botl = 1;
}
}
}
break;
case MB_INDEX_SCARE:
if (youdefend) {
if (Antimagic) {
resisted = TRUE;
} else {
nomul(-3, "being scared stiff");
nomovemsg = "";
if (magr && magr == u.ustuck && sticks(youmonst.data)) {
u.ustuck = NULL;
pline("You release %s!", mon_nam(magr));
}
}
} else {
if (rn2(2) && resist(mdef, WEAPON_CLASS, 0, NOTELL))
resisted = TRUE;
else
monflee(mdef, 3, FALSE, (mdef->mhp > *dmgptr));
}
if (!resisted) do_stun = FALSE;
break;
case MB_INDEX_STUN:
do_stun = TRUE; /* (this is redundant...) */
break;
case MB_INDEX_PROBE:
if (youattack && (mb->spe == 0 || !rn2(3 * abs(mb->spe)))) {
pline("The %s is insightful.", verb);
/* pre-damage status */
probe_monster(mdef);
}
break;
}
/* stun if that was selected and a worse effect didn't occur */
if (do_stun) {
if (youdefend)
make_stunned((HStun + 3), FALSE);
else
mdef->mstun = 1;
/* avoid extra stun message below if we used mb_verb["stun"] above */
if (attack_indx == MB_INDEX_STUN) do_stun = FALSE;
}
/* lastly, all this magic can be confusing... */
do_confuse = !rn2(12);
if (do_confuse) {
if (youdefend)
make_confused(HConfusion + 4, FALSE);
else
mdef->mconf = 1;
}
if (youattack || youdefend || vis) {
upstart(hittee); /* capitalize */
if (resisted) {
pline("%s %s!", hittee, vtense(hittee, "resist"));
shieldeff(youdefend ? u.ux : mdef->mx,
youdefend ? u.uy : mdef->my);
}
if ((do_stun || do_confuse) && flags.verbose) {
char buf[BUFSZ];
buf[0] = '\0';
if (do_stun) strcat(buf, "stunned");
if (do_stun && do_confuse) strcat(buf, " and ");
if (do_confuse) strcat(buf, "confused");
pline("%s %s %s%c", hittee, vtense(hittee, "are"),
buf, (do_stun && do_confuse) ? '!' : '.');
}
}
return result;
}
struct monst *
tamedog(struct monst *mtmp, struct obj *obj)
{
struct monst *mtmp2;
/* The Wiz, Medusa and the quest nemeses aren't even made peaceful. */
if (mtmp->iswiz || mtmp->data == &mons[PM_MEDUSA]
|| (mtmp->data->mflags3 & M3_WANTSARTI))
return NULL;
/* worst case, at least it'll be peaceful; this uses the main RNG because
realtime effects means that this won't really sync anyway; this also
calls set_malign (thus there's no need for the caller to call it after
calling tamedog()) */
msethostility(mtmp, FALSE, TRUE);
if (flags.moonphase == FULL_MOON && night() && rn2(6) && obj &&
mtmp->data->mlet == S_DOG)
return NULL;
/* If we cannot tame it, at least it's no longer afraid. */
mtmp->mflee = 0;
mtmp->mfleetim = 0;
/* make grabber let go now, whether it becomes tame or not */
if (mtmp == u.ustuck) {
if (Engulfed)
expels(mtmp, mtmp->data, TRUE);
else if (!(Upolyd && sticks(youmonst.data)))
unstuck(mtmp);
}
/* feeding it treats makes it tamer */
if (mtmp->mtame && obj) {
int tasty;
if (mtmp->mcanmove && !mtmp->mconf && !mtmp->meating &&
((tasty = dogfood(mtmp, obj)) == DOGFOOD ||
(tasty <= ACCFOOD && CONST_EDOG(mtmp)->hungrytime <= moves))) {
/* pet will "catch" and eat this thrown food */
if (canseemon(mtmp)) {
boolean big_corpse = (obj->otyp == CORPSE &&
obj->corpsenm >= LOW_PM &&
mons[obj->corpsenm].msize >
mtmp->data->msize);
pline("%s catches %s%s", Monnam(mtmp), the(xname(obj)),
!big_corpse ? "." : ", or vice versa!");
} else if (cansee(mtmp->mx, mtmp->my))
pline("%s.", Tobjnam(obj, "stop"));
/* dog_eat expects a floor object */
place_object(obj, level, mtmp->mx, mtmp->my);
dog_eat(mtmp, obj, mtmp->mx, mtmp->my, FALSE);
/* eating might have killed it, but that doesn't matter here; a
non-null result suppresses "miss" message for thrown food and
also implies that the object has been deleted */
return mtmp;
} else
return NULL;
}
if (mtmp->mtame || !mtmp->mcanmove ||
/* monsters with conflicting structures cannot be tamed */
mtmp->isshk || mtmp->isgd || mtmp->ispriest || mtmp->isminion ||
is_covetous(mtmp->data) || is_human(mtmp->data) ||
(is_demon(mtmp->data) && !is_demon(youmonst.data)) ||
(obj && dogfood(mtmp, obj) >= MANFOOD))
return NULL;
if (mtmp->m_id == u.quest_status.leader_m_id)
return NULL;
/* make a new monster which has the pet extension */
mtmp2 = newmonst(MX_EDOG, mtmp->mnamelth);
*mtmp2 = *mtmp;
mtmp2->mxtyp = MX_EDOG;
mtmp2->mxlth = sizeof (struct edog);
if (mtmp->mnamelth)
strcpy(NAME_MUTABLE(mtmp2), NAME(mtmp));
initedog(mtmp2);
replmon(mtmp, mtmp2);
/* `mtmp' is now obsolete */
if (obj) { /* thrown food */
/* defer eating until the edog extension has been set up */
place_object(obj, level, mtmp2->mx, mtmp2->my); /* put on floor */
/* devour the food (might grow into larger, genocided monster) */
if (dog_eat(mtmp2, obj, mtmp2->mx, mtmp2->my, TRUE) == 2)
return mtmp2; /* oops, it died... */
/* `obj' is now obsolete */
}
if (mtmp2->dlevel == level)
newsym(mtmp2->mx, mtmp2->my);
if (attacktype(mtmp2->data, AT_WEAP)) {
mtmp2->weapon_check = NEED_HTH_WEAPON;
mon_wield_item(mtmp2);
}
return mtmp2;
}
struct monst *
make_familiar(struct obj *otmp, xchar x, xchar y, boolean quietly)
{
const struct permonst *pm;
struct monst *mtmp = 0;
int chance, trycnt = 100;
do {
if (otmp) { /* figurine; otherwise spell */
int mndx = otmp->corpsenm;
pm = &mons[mndx];
/* activating a figurine provides one way to exceed the maximum
number of the target critter created--unless it has a special
limit (erinys, Nazgul) */
if ((mvitals[mndx].mvflags & G_EXTINCT) &&
mbirth_limit(mndx) != MAXMONNO) {
if (!quietly)
/* have just been given "You <do something with> the
figurine and it transforms." message */
pline("... into a pile of dust.");
break; /* mtmp is null */
}
} else if (!rn2(3)) {
pm = &mons[pet_type(NULL)];
} else {
pm = rndmonst(&u.uz, rng_t_create_monster);
if (!pm) {
if (!quietly)
pline
("There seems to be nothing available for a familiar.");
break;
}
}
mtmp = makemon(pm, level, x, y, MM_EDOG | MM_IGNOREWATER |
(otmp ? 0 : (MM_CREATEMONSTER | MM_CMONSTER_T)));
if (otmp && !mtmp) { /* monster was genocided or square occupied */
if (!quietly)
pline("The figurine writhes and then shatters into pieces!");
break;
}
} while (!mtmp && --trycnt > 0);
if (!mtmp)
return NULL;
if (is_pool(level, mtmp->mx, mtmp->my) && minliquid(mtmp))
return NULL;
initedog(mtmp);
mtmp->msleeping = 0;
if (otmp) { /* figurine; resulting monster might not become a pet */
chance = rn2_on_rng(10, rng_figurine_effect);
/* 0: tame, 1: peaceful, 2: hostile, 3+: matching BCU; this gives
an 80% chance of the desired effect, 10% of each other effect */
if (chance > 2)
chance = otmp->blessed ? 0 : !otmp->cursed ? 1 : 2;
if (chance > 0) {
mtmp->mtame = 0; /* not tame after all */
if (chance == 2) { /* hostile (cursed figurine) */
if (!quietly)
pline("You get a bad feeling about this.");
msethostility(mtmp, TRUE, TRUE);
}
}
/* if figurine has been named, give same name to the monster */
if (otmp->onamelth)
mtmp = christen_monst(mtmp, ONAME(otmp));
}
set_malign(mtmp); /* more alignment changes */
newsym(mtmp->mx, mtmp->my);
/* must wield weapon immediately since pets will otherwise drop it */
if (mtmp->mtame && attacktype(mtmp->data, AT_WEAP)) {
mtmp->weapon_check = NEED_HTH_WEAPON;
mon_wield_item(mtmp);
}
return mtmp;
}
