/* NetHack 3.7 timeout.c $NHDT-Date: 1606243387 2020/11/24 18:43:07 $ $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.122 $ */

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */

/*-Copyright (c) Robert Patrick Rankin, 2018. */

/* NetHack may be freely redistributed. See license for details. */

#include "hack.h"

static void NDECL(stoned_dialogue);

static void NDECL(vomiting_dialogue);

static void NDECL(choke_dialogue);

static void NDECL(levitation_dialogue);

static void NDECL(slime_dialogue);

static void FDECL(slimed_to_death, (struct kinfo *));

static void NDECL(phaze_dialogue);

static void FDECL(done_timeout, (int, int));

static void NDECL(slip_or_trip);

static void FDECL(see_lamp_flicker, (struct obj *, const char *));

static void FDECL(lantern_message, (struct obj *));

static void FDECL(cleanup_burn, (ANY_P *, long));

/* used by wizard mode #timeout and #wizintrinsic; order by 'interest'

for timeout countdown, where most won't occur in normal play */

const struct propname {

int prop_num;

const char *prop_name;

} propertynames[] = {

{ INVULNERABLE, "invulnerable" },

{ STONED, "petrifying" },

{ SLIMED, "becoming slime" },

{ STRANGLED, "strangling" },

{ SICK, "fatally sick" },

{ STUNNED, "stunned" },

{ CONFUSION, "confused" },

{ HALLUC, "hallucinating" },

{ BLINDED, "blinded" },

{ DEAF, "deafness" },

{ VOMITING, "vomiting" },

{ GLIB, "slippery fingers" },

{ WOUNDED_LEGS, "wounded legs" },

{ SLEEPY, "sleepy" },

{ TELEPORT, "teleporting" },

{ POLYMORPH, "polymorphing" },

{ LEVITATION, "levitating" },

{ FAST, "very fast" }, /* timed 'FAST' is very fast */

{ CLAIRVOYANT, "clairvoyant" },

{ DETECT_MONSTERS, "monster detection" },

{ SEE_INVIS, "see invisible" },

{ INVIS, "invisible" },

/* timed displacement is possible via eating a displacer beast corpse */

{ DISPLACED, "displaced" },

/* timed pass-walls is a potential prayer result if surrounded by stone

with nowhere to be safely teleported to */

{ PASSES_WALLS, "pass thru walls" },

/*

* Properties beyond here don't have timed values during normal play,

* so there's not much point in trying to order them sensibly.

* They're either on or off based on equipment, role, actions, &c.

*/

{ FIRE_RES, "fire resistance" },

{ COLD_RES, "cold resistance" },

{ SLEEP_RES, "sleep resistance" },

{ DISINT_RES, "disintegration resistance" },

{ SHOCK_RES, "shock resistance" },

{ POISON_RES, "poison resistance" },

{ ACID_RES, "acid resistance" },

{ STONE_RES, "stoning resistance" },

{ DRAIN_RES, "drain resistance" },

{ SICK_RES, "sickness resistance" },

{ ANTIMAGIC, "magic resistance" },

{ HALLUC_RES, "hallucination resistance" },

{ FUMBLING, "fumbling" },

{ HUNGER, "voracious hunger" },

{ TELEPAT, "telepathic" },

{ WARNING, "warning" },

{ WARN_OF_MON, "warn: monster type or class" },

{ WARN_UNDEAD, "warn: undead" },

{ SEARCHING, "searching" },

{ INFRAVISION, "infravision" },

{ ADORNED, "adorned (+/- Cha)" },

{ STEALTH, "stealthy" },

{ AGGRAVATE_MONSTER, "monster aggravation" },

{ CONFLICT, "conflict" },

{ JUMPING, "jumping" },

{ TELEPORT_CONTROL, "teleport control" },

{ FLYING, "flying" },

{ WWALKING, "water walking" },

{ SWIMMING, "swimming" },

{ MAGICAL_BREATHING, "magical breathing" },

{ SLOW_DIGESTION, "slow digestion" },

{ HALF_SPDAM, "half spell damage" },

{ HALF_PHDAM, "half physical damage" },

{ REGENERATION, "HP regeneration" },

{ ENERGY_REGENERATION, "energy regeneration" },

{ PROTECTION, "extra protection" },

{ PROT_FROM_SHAPE_CHANGERS, "protection from shape changers" },

{ POLYMORPH_CONTROL, "polymorph control" },

{ UNCHANGING, "unchanging" },

{ REFLECTING, "reflecting" },

{ FREE_ACTION, "free action" },

{ FIXED_ABIL, "fixed abilities" },

{ LIFESAVED, "life will be saved" },

{ 0, 0 },

};

/* He is being petrified - dialogue by inmet!tower */

static NEARDATA const char *const stoned_texts[] = {

"You are slowing down.", /* 5 */

"Your limbs are stiffening.", /* 4 */

"Your limbs have turned to stone.", /* 3 */

"You have turned to stone.", /* 2 */

"You are a statue." /* 1 */

};

static void

stoned_dialogue()

{

register long i = (Stoned & TIMEOUT);

if (i > 0L && i <= SIZE(stoned_texts)) {

char buf[BUFSZ];

Strcpy(buf, stoned_texts[SIZE(stoned_texts) - i]);

if (nolimbs(g.youmonst.data) && strstri(buf, "limbs"))

(void) strsubst(buf, "limbs", "extremities");

pline1(buf);

}

switch ((int) i) {

case 5: /* slowing down */

HFast = 0L;

if (g.multi > 0)

nomul(0);

break;

case 4: /* limbs stiffening */

/* just one move left to save oneself so quit fiddling around;

don't stop attempt to eat tin--might be lizard or acidic */

if (!Popeye(STONED))

stop_occupation();

if (g.multi > 0)

nomul(0);

break;

case 3: /* limbs turned to stone */

stop_occupation();

nomul(-3); /* can't move anymore */

g.multi_reason = "getting stoned";

g.nomovemsg = You_can_move_again; /* not unconscious */

/* "your limbs have turned to stone" so terminate wounded legs */

if (Wounded_legs && !u.usteed)

heal_legs(2);

break;

case 2: /* turned to stone */

if ((HDeaf & TIMEOUT) > 0L && (HDeaf & TIMEOUT) < 5L)

set_itimeout(&HDeaf, 5L); /* avoid Hear_again at tail end */

/* if also vomiting or turning into slime, stop those (no messages) */

if (Vomiting)

make_vomiting(0L, FALSE);

if (Slimed)

make_slimed(0L, (char *) 0);

break;

default:

break;

}

exercise(A_DEX, FALSE);

}

/* hero is getting sicker and sicker prior to vomiting */

static NEARDATA const char *const vomiting_texts[] = {

"are feeling mildly nauseated.", /* 14 */

"feel slightly confused.", /* 11 */

"can't seem to think straight.", /* 8 */

"feel incredibly sick.", /* 5 */

"are about to vomit." /* 2 */

};

static void

vomiting_dialogue()

{

const char *txt = 0;

char buf[BUFSZ];

long v = (Vomiting & TIMEOUT);

/* note: nhtimeout() hasn't decremented timed properties for the

current turn yet, so we use Vomiting-1 here */

switch ((int) (v - 1L)) {

case 14:

txt = vomiting_texts[0];

break;

case 11:

txt = vomiting_texts[1];

if (strstri(txt, " confused") && Confusion)

txt = strsubst(strcpy(buf, txt), " confused", " more confused");

break;

case 6:

make_stunned((HStun & TIMEOUT) + (long) d(2, 4), FALSE);

if (!Popeye(VOMITING))

stop_occupation();

/*FALLTHRU*/

case 9:

make_confused((HConfusion & TIMEOUT) + (long) d(2, 4), FALSE);

if (g.multi > 0)

nomul(0);

break;

case 8:

txt = vomiting_texts[2];

if (strstri(txt, " think") && Stunned)

txt = strsubst(strcpy(buf, txt), "can't seem to ", "can't ");

break;

case 5:

txt = vomiting_texts[3];

break;

case 2:

txt = vomiting_texts[4];

if (cantvomit(g.youmonst.data))

txt = "gag uncontrollably.";

else if (Hallucination)

/* "hurl" is short for "hurl chunks" which is slang for

relatively violent vomiting... */

txt = "are about to hurl!";

break;

case 0:

stop_occupation();

if (!cantvomit(g.youmonst.data)) {

morehungry(20);

/* case 2 used to be "You suddenly vomit!" but it wasn't sudden

since you've just been through the earlier messages of the

countdown, and it was still possible to move around between

that message and "You can move again." (from vomit()'s

nomul(-2)) with no intervening message; give one here to

have more specific point at which hero became unable to move

[vomit() issues its own message for the cantvomit() case

and for the FAINTING-or-worse case where stomach is empty] */

if (u.uhs < FAINTING)

You("%s!", !Hallucination ? "vomit" : "hurl chunks");

}

vomit();

break;

default:

break;

}

if (txt)

You1(txt);

exercise(A_CON, FALSE);

}

static NEARDATA const char *const choke_texts[] = {

"You find it hard to breathe.",

"You're gasping for air.",

"You can no longer breathe.",

"You're turning %s.",

"You suffocate."

};

static NEARDATA const char *const choke_texts2[] = {

"Your %s is becoming constricted.",

"Your blood is having trouble reaching your brain.",

"The pressure on your %s increases.",

"Your consciousness is fading.",

"You suffocate."

};

static void

choke_dialogue()

{

register long i = (Strangled & TIMEOUT);

if (i > 0 && i <= SIZE(choke_texts)) {

if (Breathless || !rn2(50))

pline(choke_texts2[SIZE(choke_texts2) - i], body_part(NECK));

else {

const char *str = choke_texts[SIZE(choke_texts) - i];

if (index(str, '%'))

pline(str, hcolor(NH_BLUE));

else

pline1(str);

}

}

exercise(A_STR, FALSE);

}

static NEARDATA const char *const levi_texts[] = {

"You float slightly lower.",

"You wobble unsteadily %s the %s."

};

static void

levitation_dialogue()

{

/* -1 because the last message comes via float_down() */

long i = (((HLevitation & TIMEOUT) - 1L) / 2L);

if (ELevitation)

return;

if (!ACCESSIBLE(levl[u.ux][u.uy].typ)

&& !is_pool_or_lava(u.ux,u.uy))

return;

if (((HLevitation & TIMEOUT) % 2L) && i > 0L && i <= SIZE(levi_texts)) {

const char *s = levi_texts[SIZE(levi_texts) - i];

if (index(s, '%')) {

boolean danger = (is_pool_or_lava(u.ux, u.uy)

&& !Is_waterlevel(&u.uz));

pline(s, danger ? "over" : "in",

danger ? surface(u.ux, u.uy) : "air");

} else

pline1(s);

}

}

static NEARDATA const char *const slime_texts[] = {

"You are turning a little %s.", /* 5 */

"Your limbs are getting oozy.", /* 4 */

"Your skin begins to peel away.", /* 3 */

"You are turning into %s.", /* 2 */

"You have become %s." /* 1 */

};

static void

slime_dialogue()

{

long t = (Slimed & TIMEOUT), i = t / 2L;

if (t == 1L) {

/* display as green slime during "You have become green slime."

but don't worry about not being able to see self; if already

mimicking something else at the time, implicitly be revealed */

g.youmonst.m_ap_type = M_AP_MONSTER;

g.youmonst.mappearance = PM_GREEN_SLIME;

/* no message given when 't' is odd, so no automatic update of

self; force one */

newsym(u.ux, u.uy);

}

if ((t % 2L) != 0L && i >= 0L && i < SIZE(slime_texts)) {

char buf[BUFSZ];

Strcpy(buf, slime_texts[SIZE(slime_texts) - i - 1L]);

if (nolimbs(g.youmonst.data) && strstri(buf, "limbs"))

(void) strsubst(buf, "limbs", "extremities");

if (index(buf, '%')) {

if (i == 4L) { /* "you are turning green" */

if (!Blind) /* [what if you're already green?] */

pline(buf, hcolor(NH_GREEN));

} else

pline(buf,

an(Hallucination ? rndmonnam(NULL) : "green slime"));

} else

pline1(buf);

}

switch (i) {

case 3L: /* limbs becoming oozy */

HFast = 0L; /* lose intrinsic speed */

if (!Popeye(SLIMED))

stop_occupation();

if (g.multi > 0)

nomul(0);

break;

case 2L: /* skin begins to peel */

if ((HDeaf & TIMEOUT) > 0L && (HDeaf & TIMEOUT) < 5L)

set_itimeout(&HDeaf, 5L); /* avoid Hear_again at tail end */

break;

case 1L: /* turning into slime */

/* if also turning to stone, stop doing that (no message) */

if (Stoned)

make_stoned(0L, (char *) 0, KILLED_BY_AN, (char *) 0);

break;

}

exercise(A_DEX, FALSE);

}

void

burn_away_slime()

{

if (Slimed) {

make_slimed(0L, "The slime that covers you is burned away!");

}

}

/* countdown timer for turning into green slime has run out; kill our hero */

static void

slimed_to_death(kptr)

struct kinfo *kptr;

{

uchar save_mvflags;

/* redundant: polymon() cures sliming when polying into green slime */

if (Upolyd && g.youmonst.data == &mons[PM_GREEN_SLIME]) {

dealloc_killer(kptr);

return;

}

/* more sure killer reason is set up */

if (kptr && kptr->name[0]) {

g.killer.format = kptr->format;

Strcpy(g.killer.name, kptr->name);

} else {

g.killer.format = NO_KILLER_PREFIX;

Strcpy(g.killer.name, "turned into green slime");

}

dealloc_killer(kptr);

/*

* Polymorph into a green slime, which might destroy some worn armor

* (potentially affecting bones) and dismount from steed.

* Can't be Unchanging; wouldn't have turned into slime if we were.

* Despite lack of Unchanging, neither done() nor savelife() calls

* rehumanize() if hero dies while polymorphed.

* polymon() undoes the slime countdown's mimick-green-slime hack

* but does not perform polyself()'s light source bookkeeping.

* No longer need to manually increment uconduct.polyselfs to reflect

* [formerly implicit] change of form; polymon() takes care of that.

* Temporarily ungenocide if necessary.

*/

if (emits_light(g.youmonst.data))

del_light_source(LS_MONSTER, monst_to_any(&g.youmonst));

save_mvflags = g.mvitals[PM_GREEN_SLIME].mvflags;

g.mvitals[PM_GREEN_SLIME].mvflags = save_mvflags & ~G_GENOD;

/* become a green slime; also resets youmonst.m_ap_type+.mappearance */

(void) polymon(PM_GREEN_SLIME);

g.mvitals[PM_GREEN_SLIME].mvflags = save_mvflags;

done_timeout(TURNED_SLIME, SLIMED);

/* life-saved; even so, hero still has turned into green slime;

player may have genocided green slimes after being infected */

if ((g.mvitals[PM_GREEN_SLIME].mvflags & G_GENOD) != 0) {

char slimebuf[BUFSZ];

g.killer.format = KILLED_BY;

Strcpy(g.killer.name, "slimicide");

/* vary the message depending upon whether life-save was due to

amulet or due to declining to die in explore or wizard mode */

Strcpy(slimebuf, "green slime has been genocided...");

if (iflags.last_msg == PLNMSG_OK_DONT_DIE)

/* follows "OK, so you don't die." and arg is second sentence */

pline("Yes, you do. %s", upstart(slimebuf));

else

/* follows "The medallion crumbles to dust." */

pline("Unfortunately, %s", slimebuf);

/* die again; no possibility of amulet this time */

done(GENOCIDED); /* [should it be done_timeout(GENOCIDED, SLIMED)?] */

/* could be life-saved again (only in explore or wizard mode)

but green slimes are gone; just stay in current form */

}

return;

}

/* Intrinsic Passes_walls is temporary when your god is trying to fix

all troubles and then TROUBLE_STUCK_IN_WALL calls safe_teleds() but

it can't find anywhere to place you. If that happens you get a small

value for (HPasses_walls & TIMEOUT) to move somewhere yourself.

Message given is "you feel much slimmer" as a joke hint that you can

move between things which are closely packed--like the substance of

solid rock! */

static NEARDATA const char *const phaze_texts[] = {

"You start to feel bloated.",

"You are feeling rather flabby.",

};

static void

phaze_dialogue()

{

long i = ((HPasses_walls & TIMEOUT) / 2L);

if (EPasses_walls || (HPasses_walls & ~TIMEOUT))

return;

if (((HPasses_walls & TIMEOUT) % 2L) && i > 0L && i <= SIZE(phaze_texts))

pline1(phaze_texts[SIZE(phaze_texts) - i]);

}

/* when a status timeout is fatal, keep the status line indicator shown

during end of game rundown (and potential dumplog);

timeout has already counted down to 0 by the time we get here */

static void

done_timeout(how, which)

int how, which;

{

long *intrinsic_p = &u.uprops[which].intrinsic;

*intrinsic_p |= I_SPECIAL; /* affects final disclosure */

done(how);

/* life-saved */

*intrinsic_p &= ~I_SPECIAL;

g.context.botl = TRUE;

}

void

nh_timeout()

{

register struct prop *upp;

struct kinfo *kptr;

boolean was_flying;

int sleeptime;

int m_idx;

int baseluck = (flags.moonphase == FULL_MOON) ? 1 : 0;

if (flags.friday13)

baseluck -= 1;

if (u.uluck != baseluck

&& g.moves % ((u.uhave.amulet || u.ugangr) ? 300 : 600) == 0) {

/* Cursed luckstones stop bad luck from timing out; blessed luckstones

* stop good luck from timing out; normal luckstones stop both;

* neither is stopped if you don't have a luckstone.

* Luck is based at 0 usually, +1 if a full moon and -1 on Friday 13th

*/

register int time_luck = stone_luck(FALSE);

boolean nostone = !carrying(LUCKSTONE) && !stone_luck(TRUE);

if (u.uluck > baseluck && (nostone || time_luck < 0))

u.uluck--;

else if (u.uluck < baseluck && (nostone || time_luck > 0))

u.uluck++;

}

if (u.uinvulnerable)

return; /* things past this point could kill you */

if (Stoned)

stoned_dialogue();

if (Slimed)

slime_dialogue();

if (Vomiting)

vomiting_dialogue();

if (Strangled)

choke_dialogue();

if (HLevitation & TIMEOUT)

levitation_dialogue();

if (HPasses_walls & TIMEOUT)

phaze_dialogue();

if (u.mtimedone && !--u.mtimedone) {

if (Unchanging)

u.mtimedone = rnd(100 * g.youmonst.data->mlevel + 1);

else if (is_were(g.youmonst.data))

you_unwere(FALSE); /* if polycontrl, asks whether to rehumanize */

else

rehumanize();

}

if (u.ucreamed)

u.ucreamed--;

/* Dissipate spell-based protection. */

if (u.usptime) {

if (--u.usptime == 0 && u.uspellprot) {

u.usptime = u.uspmtime;

u.uspellprot--;

find_ac();

if (!Blind)

Norep("The %s haze around you %s.", hcolor(NH_GOLDEN),

u.uspellprot ? "becomes less dense" : "disappears");

}

}

if (u.ugallop) {

if (--u.ugallop == 0L && u.usteed)

pline("%s stops galloping.", Monnam(u.usteed));

}

was_flying = Flying;

for (upp = u.uprops; upp < u.uprops + SIZE(u.uprops); upp++)

if ((upp->intrinsic & TIMEOUT) && !(--upp->intrinsic & TIMEOUT)) {

kptr = find_delayed_killer((int) (upp - u.uprops));

switch (upp - u.uprops) {

case STONED:

if (kptr && kptr->name[0]) {

g.killer.format = kptr->format;

Strcpy(g.killer.name, kptr->name);

} else {

g.killer.format = NO_KILLER_PREFIX;

Strcpy(g.killer.name, "killed by petrification");

}

dealloc_killer(kptr);

/* (unlike sliming, you aren't changing form here) */

done_timeout(STONING, STONED);

break;

case SLIMED:

slimed_to_death(kptr); /* done_timeout(TURNED_SLIME,SLIMED) */

break;

case VOMITING:

make_vomiting(0L, TRUE);

break;

case SICK:

/* You might be able to bounce back from food poisoning, but not

* other forms of illness. */

if ((u.usick_type & SICK_NONVOMITABLE) == 0

&& rn2(100) < ACURR(A_CON)) {

You("have recovered from your illness.");

make_sick(0, NULL, FALSE, SICK_ALL);

exercise(A_CON, FALSE);

adjattrib(A_CON, -1, 1);

break;

}

You("die from your illness.");

if (kptr && kptr->name[0]) {

g.killer.format = kptr->format;

Strcpy(g.killer.name, kptr->name);

} else {

g.killer.format = KILLED_BY_AN;

g.killer.name[0] = 0; /* take the default */

}

dealloc_killer(kptr);

if ((m_idx = name_to_mon(g.killer.name)) >= LOW_PM) {

if (type_is_pname(&mons[m_idx])) {

g.killer.format = KILLED_BY;

} else if (mons[m_idx].geno & G_UNIQ) {

Strcpy(g.killer.name, the(g.killer.name));

g.killer.format = KILLED_BY;

}

}

done_timeout(POISONING, SICK);

u.usick_type = 0;

break;

case FAST:

if (!Very_fast)

You_feel("yourself slow down%s.",

Fast ? " a bit" : "");

break;

case CONFUSION:

/* So make_confused works properly */

set_itimeout(&HConfusion, 1L);

make_confused(0L, TRUE);

if (!Confusion)

stop_occupation();

break;

case STUNNED:

set_itimeout(&HStun, 1L);

make_stunned(0L, TRUE);

if (!Stunned)

stop_occupation();

break;

case BLINDED:

set_itimeout(&Blinded, 1L);

make_blinded(0L, TRUE);

if (!Blind)

stop_occupation();

break;

case DEAF:

set_itimeout(&HDeaf, 1L);

make_deaf(0L, TRUE);

g.context.botl = TRUE;

if (!Deaf)

stop_occupation();

break;

case INVIS:

newsym(u.ux, u.uy);

if (!Invis && !BInvis && !Blind) {

You(!See_invisible

? "are no longer invisible."

: "can no longer see through yourself.");

stop_occupation();

}

break;

case SEE_INVIS:

set_mimic_blocking(); /* do special mimic handling */

see_monsters(); /* make invis mons appear */

newsym(u.ux, u.uy); /* make self appear */

stop_occupation();

break;

case WOUNDED_LEGS:

heal_legs(0);

stop_occupation();

break;

case HALLUC:

set_itimeout(&HHallucination, 1L);

(void) make_hallucinated(0L, TRUE, 0L);

if (!Hallucination)

stop_occupation();

break;

case SLEEPY:

if (unconscious() || Sleep_resistance) {

incr_itimeout(&HSleepy, rnd(100));

} else if (Sleepy) {

You("fall asleep.");

sleeptime = rnd(20);

fall_asleep(-sleeptime, TRUE);

incr_itimeout(&HSleepy, sleeptime + rnd(100));

}

break;

case LEVITATION:

/* timed Flying is via #wizintrinsic only; still, we want to

avoid float_down() reporting "you have stopped levitating

and are now flying" if both are timing out together;

relies on knowing that Lev timeout is handled before Fly */

if ((HFlying & TIMEOUT) == 1L)

--HFlying; /* bypass pending 'case FLYING' */

(void) float_down(I_SPECIAL | TIMEOUT, 0L);

break;

case FLYING:

/* timed Flying is via #wizintrinsic only */

if (was_flying && !Flying) {

g.context.botl = 1;

You("land.");

spoteffects(TRUE);

}

break;

case DISPLACED:

if (!Displaced) /* give a message */

toggle_displacement((struct obj *) 0, 0L, FALSE);

break;

case WARN_OF_MON:

/* timed Warn_of_mon is via #wizintrinsic only */

if (!Warn_of_mon) {

g.context.warntype.speciesidx = NON_PM;

if (g.context.warntype.species) {

You("are no longer warned about %s.",

makeplural(g.context.warntype.species->mname));

g.context.warntype.species = (struct permonst *) 0;

}

}

break;

case PASSES_WALLS:

if (!Passes_walls) {

if (stuck_in_wall())

You_feel("hemmed in again.");

else

pline("You're back to your %s self again.",

!Upolyd ? "normal" : "unusual");

}

break;

case STRANGLED:

g.killer.format = KILLED_BY;

Strcpy(g.killer.name,

(u.uburied) ? "suffocation" : "strangulation");

done_timeout(DIED, STRANGLED);

/* must be declining to die in explore|wizard mode;

treat like being cured of strangulation by prayer */

if (uamul && uamul->otyp == AMULET_OF_STRANGULATION) {

Your("amulet vanishes!");

useup(uamul);

}

break;

case FUMBLING:

/* call this only when a move took place. */

/* otherwise handle fumbling msgs locally. */

if (u.umoved && !(Levitation || Flying)) {

slip_or_trip();

nomul(-2);

g.multi_reason = "fumbling";

g.nomovemsg = "";

/* The more you are carrying the more likely you

* are to make noise when you fumble. Adjustments

* to this number must be thoroughly play tested.

*/

if ((inv_weight() > -500)) {

You("make a lot of noise!");

wake_nearby();

}

}

/* from outside means slippery ice; don't reset

counter if that's the only fumble reason */

HFumbling &= ~FROMOUTSIDE;

if (Fumbling)

incr_itimeout(&HFumbling, rnd(20));

if (iflags.defer_decor) {

/* 'mention_decor' was deferred for message sequencing

reasons; catch up now */

deferred_decor(FALSE);

}

break;

case DETECT_MONSTERS:

see_monsters();

break;

case GLIB:

make_glib(0); /* might update persistent inventory */

break;

}

}

run_timers();

}

void

fall_asleep(how_long, wakeup_msg)

int how_long;

boolean wakeup_msg;

{

stop_occupation();

nomul(how_long);

g.multi_reason = "sleeping";

/* generally don't notice sounds while sleeping */

if (wakeup_msg && g.multi == how_long) {

/* caller can follow with a direct call to Hear_again() if

there's a need to override this when wakeup_msg is true */

incr_itimeout(&HDeaf, how_long);

g.context.botl = TRUE;

g.afternmv = Hear_again; /* this won't give any messages */

}

/* early wakeup from combat won't be possible until next monster turn */

u.usleep = g.monstermoves;

g.nomovemsg = wakeup_msg ? "You wake up." : You_can_move_again;

}

/* Attach an egg hatch timeout to the given egg.

* when = Time to hatch, usually only passed if re-creating an

* existing hatch timer. Pass 0L for random hatch time.

*/

void

attach_egg_hatch_timeout(egg, when)

struct obj *egg;

long when;

{

int i;

/* stop previous timer, if any */

(void) stop_timer(HATCH_EGG, obj_to_any(egg));

/*

* Decide if and when to hatch the egg. The old hatch_it() code tried

* once a turn from age 151 to 200 (inclusive), hatching if it rolled

* a number x, 1<=x<=age, where x>150. This yields a chance of

* hatching > 99.9993%. Mimic that here.

*/

if (!when) {

for (i = (MAX_EGG_HATCH_TIME - 50) + 1; i <= MAX_EGG_HATCH_TIME; i++)

if (rnd(i) > 150) {

/* egg will hatch */

when = (long) i;

break;

}

}

if (when) {

(void) start_timer(when, TIMER_OBJECT, HATCH_EGG, obj_to_any(egg));

}

}

/* prevent an egg from ever hatching */

void

kill_egg(egg)

struct obj *egg;

{

/* stop previous timer, if any */

(void) stop_timer(HATCH_EGG, obj_to_any(egg));

}

/* timer callback routine: hatch the given egg */

void

hatch_egg(arg, timeout)

anything *arg;

long timeout;

{

struct obj *egg;

struct monst *mon, *mon2;

coord cc;

xchar x, y;

boolean yours, silent, knows_egg = FALSE;

boolean cansee_hatchspot = FALSE;

int i, mnum, hatchcount = 0;

egg = arg->a_obj;

/* sterilized while waiting */

if (egg->corpsenm == NON_PM)

return;

mon = mon2 = (struct monst *) 0;

mnum = big_to_little(egg->corpsenm);

/* The identity of one's father is learned, not innate */

yours = (egg->spe || (!flags.female && carried(egg) && !rn2(2)));

silent = (timeout != g.monstermoves); /* hatched while away */

/* only can hatch when in INVENT, FLOOR, MINVENT */

if (get_obj_location(egg, &x, &y, 0)) {

hatchcount = rnd((int) egg->quan);

cansee_hatchspot = cansee(x, y) && !silent;

if (!(mons[mnum].geno & G_UNIQ)

&& !(g.mvitals[mnum].mvflags & (G_GENOD | G_EXTINCT))) {

for (i = hatchcount; i > 0; i--) {

if (!enexto(&cc, x, y, &mons[mnum])

|| !(mon = makemon(&mons[mnum], cc.x, cc.y, NO_MINVENT)))

break;

/* tame if your own egg hatches while you're on the

same dungeon level, or any dragon egg which hatches

while it's in your inventory */

if ((yours && !silent)

|| (carried(egg) && mon->data->mlet == S_DRAGON)) {

if (tamedog(mon, (struct obj *) 0)) {

if (carried(egg) && mon->data->mlet != S_DRAGON)

mon->mtame = 20;

}

}

if (g.mvitals[mnum].mvflags & G_EXTINCT)

break; /* just made last one */

mon2 = mon; /* in case makemon() fails on 2nd egg */

}

if (!mon)

mon = mon2;

hatchcount -= i;

egg->quan -= (long) hatchcount;

}

#if 0

/*

* We could possibly hatch while migrating, but the code isn't

* set up for it...

*/

} else if (obj->where == OBJ_MIGRATING) {

/*

* We can do several things. The first ones that come to

* mind are:

* + Create the hatched monster then place it on the migrating

* mons list. This is tough because all makemon() is made

* to place the monster as well. Makemon() also doesn't lend

* itself well to splitting off a "not yet placed" subroutine.

* + Mark the egg as hatched, then place the monster when we

* place the migrating objects.

* + Or just kill any egg which gets sent to another level.

* Falling is the usual reason such transportation occurs.

*/

cansee_hatchspot = FALSE;

mon = ???;

#endif

}

if (mon) {

char monnambuf[BUFSZ], carriedby[BUFSZ];

boolean siblings = (hatchcount > 1), redraw = FALSE;

if (cansee_hatchspot) {

/* [bug? m_monnam() yields accurate monster type

regardless of hallucination] */

Sprintf(monnambuf, "%s%s", siblings ? "some " : "",

siblings ? makeplural(m_monnam(mon)) : an(m_monnam(mon)));

/* we don't learn the egg type here because learning

an egg type requires either seeing the egg hatch

or being familiar with the egg already,

as well as being able to see the resulting

monster, checked below

*/

}

switch (egg->where) {

case OBJ_INVENT:

knows_egg = TRUE; /* true even if you are blind */

if (!cansee_hatchspot)

You_feel("%s %s from your pack!", something,

locomotion(mon->data, "drop"));

else

You_see("%s %s out of your pack!", monnambuf,

locomotion(mon->data, "drop"));

if (yours) {

pline("%s cries sound like \"%s%s\"",

siblings ? "Their" : "Its",

flags.female ? "mommy" : "daddy", egg->spe ? "." : "?");

} else if (mon->data->mlet == S_DRAGON && !Deaf) {

verbalize("Gleep!"); /* Mything eggs :-) */

}

break;

case OBJ_FLOOR:

if (cansee_hatchspot) {

knows_egg = TRUE;

You_see("%s hatch.", monnambuf);

redraw = TRUE; /* update egg's map location */

}

break;

case OBJ_MINVENT:

if (cansee_hatchspot) {

/* egg carrying monster might be invisible */

mon2 = egg->ocarry;

if (canseemon(mon2)

&& (!mon2->wormno || cansee(mon2->mx, mon2->my))) {

Sprintf(carriedby, "%s pack",

s_suffix(a_monnam(mon2)));

knows_egg = TRUE;

} else if (is_pool(mon->mx, mon->my)) {

Strcpy(carriedby, "empty water");

} else {

Strcpy(carriedby, "thin air");

}

You_see("%s %s out of %s!", monnambuf,

locomotion(mon->data, "drop"), carriedby);

}

break;

#if 0

case OBJ_MIGRATING:

break;

#endif

default:

impossible("egg hatched where? (%d)", (int) egg->where);

break;

}

if (cansee_hatchspot && knows_egg)

learn_egg_type(mnum);

if (egg->quan > 0) {

/* still some eggs left */

/* Instead of ordinary egg timeout use a short one */

attach_egg_hatch_timeout(egg, (long) rnd(12));

} else if (carried(egg)) {

useup(egg);

} else {

/* free egg here because we use it above */

obj_extract_self(egg);

obfree(egg, (struct obj *) 0);

if ((mon = m_at(x,y)) && !hideunder(mon) && cansee(x, y))

redraw = TRUE;

}