| blob | ae4a168896d1cf841163a6bbbcf824150d7de990 |
1 /* NetHack 3.7 zap.c $NHDT-Date: 1737344505 2025/01/19 19:41:45 $ $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.562 $ */
2 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3 /*-Copyright (c) Robert Patrick Rankin, 2013. */
4 /* NetHack may be freely redistributed. See license for details. */
8 /* Disintegration rays have special treatment; corpses are never left.
9 * But the routine which calculates the damage is separate from the routine
10 * which kills the monster. The damage routine returns this cookie to
11 * indicate that the monster should be disintegrated.
12 */
13 #define MAGIC_COOKIE 1000
34 /* all callers of boxlock_invent() pass a NONNULL obj, and boxlock
35 * boxlock_invent() calls boxlock() which has nonnull arg. */
43 #define ZT_MAGIC_MISSILE (AD_MAGM - 1)
44 #define ZT_FIRE (AD_FIRE - 1)
45 #define ZT_COLD (AD_COLD - 1)
46 #define ZT_SLEEP (AD_SLEE - 1)
48 #define ZT_LIGHTNING (AD_ELEC - 1)
49 #define ZT_POISON_GAS (AD_DRST - 1)
50 #define ZT_ACID (AD_ACID - 1)
51 /* 8 and 9 are currently unassigned */
53 #define ZT_WAND(x) (x)
54 #define ZT_SPELL(x) (10 + (x))
55 #define ZT_BREATH(x) (20 + (x))
57 #define is_hero_spell(type) ((type) >= 10 && (type) < 20)
59 #define M_IN_WATER(ptr) ((ptr)->mlet == S_EEL || cant_drown(ptr))
63 /*
64 * A positive index means zapped/cast/breathed by hero.
65 * A negative index means zapped/cast/breathed by a monster, with value
66 * index fixup beyond abs() needed for wand zaps. Wand zaps for monster
67 * use -39..-30 rather than -9..-0 because -0 is ambiguous (same as 0).
68 */
83 };
85 /* convert monster zap/spell/breath value to hero zap/spell/breath value */
86 staticfn int
88 {
91 * will yield 0..9 (hero wand zap) for it */
94 }
96 /*
97 * Recognizing unseen wands by zapping: in 3.4.3 and earlier, zapping
98 * most wand types while blind would add that type to the discoveries
99 * list even if it had never been seen (ie, picked up while blinded
100 * and shown in inventory as simply "a wand"). This behavior has been
101 * changed; now such wands won't be discovered. But if the type is
102 * already discovered, then the individual wand whose effect was just
103 * observed will be flagged as if seen. [You already know wands of
104 * striking; you zap "a wand" and observe striking effect (presumably
105 * by sound or touch); it'll become shown in inventory as "a wand of
106 * striking".]
107 *
108 * Unfortunately, the new behavior isn't really correct either. There
109 * should be an `eknown' bit for "effect known" added for wands (and
110 * for potions since quaffing one of a stack is similar) so that the
111 * particular wand which has been zapped would have its type become
112 * known (it would change from "a wand" to "a wand of striking", for
113 * example) without the type becoming discovered or other unknown wands
114 * of that type showing additional information. When blindness ends,
115 * all objects in inventory with the eknown bit set would be discovered
116 * and other items of the same type would become known as such.
117 */
119 /* wand discovery gets special handling when hero is blinded */
120 void
122 {
123 /* For a wand (or wand-like tool) zapped by the player, if the
124 effect was observable (determined by caller; usually seen, but
125 possibly heard or felt if the hero is blinded) then discover the
126 object type provided that the object itself is known (as more
127 than just "a wand"). If object type is already discovered and
128 we observed the effect, mark the individual wand as having been
129 seen. Suppress spells (which use fake spellbook object for `obj')
130 so that casting a spell won't re-discover its forgotten book. */
132 /* if type already discovered, treat this item has having been seen
133 even if hero is currently blinded (skips redundant makeknown) */
137 /* otherwise discover it if item itself has been or can be seen */
139 /* in case it was picked up while blind and then zapped without
140 examining inventory after regaining sight (bypassing xname) */
143 /* make the discovery iff we know what we're manipulating */
146 }
148 }
149 }
151 /*
152 * Routines for IMMEDIATE wands and spells.
153 * Also RAY or NODIR for wands that are being broken rather than zapped.
154 */
156 /* bhitm: monster mtmp was hit by the effect of wand or spell otmp */
157 int
159 {
170 /* box_or_door(): mimic appearances that have locks */
171 #define box_or_door(monst) \
172 ((M_AP_TYPE(monst) == M_AP_OBJECT \
173 && ((monst)->mappearance == CHEST \
174 || (monst)->mappearance == LARGE_BOX)) \
175 || (M_AP_TYPE(monst) == M_AP_FURNITURE \
178 && is_cmap_door((monst)->mappearance)))
189 FALLTHROUGH;
190 /*FALLTHRU*/
199 /* 3.7: used to 'break' to avoid setting learn_it here */
211 }
225 }
226 }
234 }
235 /* wake but don't anger a peaceful target */
255 }
256 }
262 /* if a long worm has mcorpsenm set, it was polymorphed by
263 the current zap and shouldn't be affected if hit again */
264 ;
266 /* magic resistance protects from polymorph traps, so make
267 it guard against involuntary polymorph attacks too... */
271 give_msg = (!Hallucination
275 /* dropped inventory (due to death by system shock,
276 or loss of wielded weapon and/or worn armor due to
277 limitations of new shape) won't be hit by this zap */
282 /* natural shapechangers aren't affected by system shock
283 (unless protection from shapechangers is interfering
284 with their metabolism...) */
289 }
290 /* svc.context.bypasses = TRUE; ## for make_corpse() */
291 /* no corpse after system shock */
301 /* if shapechange failed because there aren't
302 enough eligible candidates (most likely for
303 vampshifter), try reverting to original form */
310 }
311 }
313 /* do this even if polymorphed failed (otherwise using
314 flags.mon_polycontrol prompting to force mtmp to remain
315 'long worm' would prompt again if zap hit another segment) */
319 /* flag to indicate that mtmp became a long worm
320 on current zap, so further hits (on mtmp's new
321 tail) don't do further transforms */
323 /* flag to indicate that cleanup is needed; object
324 bypass cleanup also clears mon->mextra->mcorpsenm
325 for all long worms on the level */
327 }
328 }
350 /* format monster's name before altering its visibility */
358 /* keep the immediate effects of make invisible and teleportation
359 ambiguous by using the same message that's used if we
360 teleported mtmp (and it ended up somewhere you can't see) */
362 }
364 }
383 /* zapping either holder/holdee or self [zapyourself()] will
384 release hero from holder's grasp or holdee from hero's grasp */
388 /* zap which hits steed will only release saddle if it
389 doesn't hit a holding or falling trap; playability
390 here overrides the more logical target ordering */
394 /* mtmp might now be on the migrating monsters list */
407 }
411 }
424 }
426 }
438 /* plain healing must be blessed to cure blindness; extra
439 healing only needs to not be cursed, so spell always cures
440 [potions quaffed by monsters behave slightly differently;
441 we use the rules for the hero here...] */
447 /* it can do better now */
455 }
459 }
462 }
464 /* Pestilence will always resist; damage is half of (healamt/2) */
466 }
468 }
473 }
476 /* [wakeup() doesn't rouse victims of temporary sleep,
477 so it's okay to leave `wake' set to TRUE here;
478 revealing concealed mimic is handled by sleep_monst()] */
486 /* FIXME: mimics disguished as stone furniture or stone object
487 should be taken out of concealment. */
491 /* turn into flesh golem */
498 }
516 /* die if already level 0, regardless of hit points */
523 }
524 }
532 }
541 }
542 /* note: gb.bhitpos won't be set if swallowed, but that's okay since
543 * reveal_invis will be false. We can't use mtmp->mx, my since it
544 * might be an invisible worm hit on the tail.
545 */
550 }
551 /* if effect was observable then discover the wand type provided
552 that the wand itself has been seen */
556 #undef box_or_door
557 }
559 /* hero is held by a monster or engulfed or holding a monster and has zapped
560 opening/unlocking magic at holder/engulfer/holdee or at self */
561 void
563 {
572 else
574 }
575 /* gives "you get regurgitated" or "you get expelled from <mon>" */
578 /* order matters if 'holding' status condition is enabled;
579 set_ustuck() will set flag for botl update, You() pline will
580 trigger a status update with "UHold" removed */
589 else
592 }
593 }
595 staticfn void
597 {
606 }
607 }
609 void
611 {
623 }
624 }
626 /*
627 * Return the object's physical location. This only makes sense for
628 * objects that are currently on the level (i.e. migrating objects
629 * are nowhere). By default, only things that can be seen (in hero's
630 * inventory, monster's inventory, or on the ground) are reported.
631 * By adding BURIED_TOO and/or CONTAINED_TOO flags, you can also get
632 * the location of buried and contained objects. Note that if an
633 * object is carried by a monster, its reported position may change
634 * from turn to turn. This function returns FALSE if the position
635 * is not available or subject to the constraints above.
636 */
637 boolean
642 {
657 }
664 }
670 }
673 }
675 boolean
680 {
692 }
693 }
695 /* used by revive() and animate_statue() */
701 * True: nearby is allowed */
702 {
707 /* save_mtraits() validated mtmp2->mnum */
713 /* in case mtmp2 is a long worm; saved traits for
714 long worm don't include tail segments so don't
715 give mtmp any; it will be given a new 'wormno'
716 though (unless those are exhausted) so be able
717 to grow new tail segments */
720 }
722 /* mtmp2 is a copy of obj's object->oextra->omonst extension
723 and is not on the map or on any monst lists */
726 }
728 /* heal the monster; lower than normal level might come from
729 adj_lev() but we assume it has come from 'mtmp' being level
730 drained before finally killed; give a chance to restore
731 some levels so that trolls and Riders can't be drained to
732 level 0 and then trivially killed repeatedly */
740 }
742 }
743 }
747 /* Get these ones from mtmp */
749 /* monster ID is available if the monster died in the current
750 game, but will be zero if the corpse was in a bones level
751 (we cleared it when loading bones) */
754 /* might be bringing quest leader back to life */
756 /* leader_is_dead implies leader_m_id is valid */
759 }
775 /* set these ones explicitly */
784 /* most cancelled monsters return to normal,
785 but some need to stay cancelled */
793 /* when traits are for a shopkeeper, dummy monster 'mtmp' won't
794 have necessary eshk data for replmon() -> replshk() */
802 }
806 /* in case Protection_from_shape_changers is different
807 now than it was when the traits were stored */
809 }
811 }
813 /*
814 * get_container_location() returns the following information
815 * about the outermost container:
816 * loc argument gets set to:
817 * OBJ_INVENT if in hero's inventory; return 0.
818 * OBJ_FLOOR if on the floor; return 0.
819 * OBJ_BURIED if buried; return 0.
820 * OBJ_MINVENT if in monster's inventory; return monster.
821 * container_nesting is updated with the nesting depth of the containers
822 * if applicable.
823 */
829 {
836 }
841 }
843 }
845 /* can zombie dig the location at x,y */
846 staticfn boolean
848 {
857 }
859 }
861 /*
862 * Attempt to revive the given corpse, return the revived monster if
863 * successful. Note: this does NOT use up the corpse if it fails.
864 * If corpse->quan is more than 1, only one corpse will be affected
865 * and only one monster will be resurrected.
866 */
869 {
873 coord xy;
875 boolean one_of;
878 boolean is_zomb;
883 }
885 /* treat buried auto-reviver (troll, Rider?) like a zombie
886 so that it can dig itself out of the ground if it revives */
890 /* if this corpse is being eaten, stop doing that; this should be done
891 after makemon() succeeds and skipped if it fails, but waiting until
892 we know the result for that would be too late */
899 /* only for invent, minvent, or floor, or if zombie, buried */
903 /* deal with corpses in [possibly nested] containers */
908 carrier =
922 }
923 }
928 /* Rules for revival from containers:
929 * - the container cannot be locked
930 * - the container cannot be heavily nested (>2 is arbitrary)
931 * - the container cannot be a statue or bag of holding
932 * (except in very rare cases for the latter)
933 */
937 /* if buried zombie cannot dig itself out, do not revive */
941 /* prepare for the monster */
943 /* [should probably handle recorporealization first; if corpse and
944 ghost are at same location, revived creature shouldn't be bumped
945 to an adjacent spot by ghost which joins with it] */
949 }
957 }
959 /* applicable when montraits/corpse->oextra->omonst aren't used */
967 /* make a zombie or doppelganger instead */
968 /* note: montype has changed; mptr keeps old value for newcham() */
971 /* skip ghost handling */
977 /* change shape to match the corpse */
982 }
983 }
985 /* use saved traits */
991 /* make a new monster */
993 }
997 /* hiders shouldn't already be re-hidden when they revive */
1001 }
1009 /* if this is caused by the hero there might be a shop charge */
1022 /* shk_your: "the " or "your " or "<mon>'s " or "<Shk>'s ".
1023 If the result is "Shk's " then it will be ambiguous:
1024 is Shk the mon carrying it, or does Shk's shop own it?
1025 Let's not worry about that... */
1035 /* need some prior description of the corpse since
1036 stolen_value() will refer to the object as "it" */
1038 }
1039 /* don't charge for shopkeeper's own corpse if we just revived him */
1042 FALSE);
1044 /* [we don't give any comparable message about the corpse for
1045 the !by_hero case because caller might have already done so] */
1046 }
1048 /* handle recorporealization of an active ghost */
1060 /* transfer the ghost's inventory along with it */
1064 }
1065 /* tame the revived monster if its ghost was tame */
1068 /* ghost's edog data is ignored */
1070 }
1071 }
1072 /* was ghost, now alive, it's all very confusing */
1074 /* separate ghost monster no longer exists */
1076 }
1078 }
1080 /* monster retains its name */
1083 /* partially eaten corpse yields wounded monster */
1086 /* track that this monster was revived at least once */
1089 /* finally, get rid of the corpse--it's gone now */
1095 /* not useupf(), which charges;
1096 delobj() won't use up a Rider's corpse, delobj_core(,TRUE) will */
1103 /* obj_extract_self() will update corpse->ocontainer->owt */
1112 }
1113 FALLTHROUGH;
1114 /*FALLTHRU*/
1121 }
1124 }
1126 staticfn void
1128 {
1129 /*
1130 * Note: generic eggs with corpsenm set to NON_PM will never hatch.
1131 */
1136 }
1138 /* try to revive all corpses and eggs carried by `mon' */
1139 int
1141 {
1159 /* save the name; the object is liable to go away */
1162 /* shk_your/Shk_Your produces a value with a trailing space */
1168 }
1169 /* for a stack, only one is revived; if is_u, revive() calls
1170 useup() which calls update_inventory() but not encumber_msg() */
1172 /* norevive applies to revive timer, not to explicit unturn_dead() */
1178 /* might get revived as a zombie rather than corpse's monster */
1181 /* when hero zaps undead turning at self (or breaks
1182 non-empty wand), revive() reports "[one of] your <mon>
1183 corpse[s] glows iridescently"; override saved corpse
1184 and owner names to say "It comes alive" [note: we did
1185 earlier setup because corpse gets used up but need to
1186 do the override here after revive() sets 'last_msg'] */
1189 }
1198 /* revival failed; corpse 'otmp' is intact */
1200 }
1201 }
1206 }
1208 void
1210 {
1218 }
1219 }
1221 /* cancel obj, possibly carried by you or a monster */
1222 void
1224 {
1228 /* handle items being worn by hero */
1234 }
1240 }
1246 }
1264 }
1271 }
1277 }
1278 }
1279 /* cancelled item might not be in hero's possession but
1280 cancellation is presumed to be instigated by hero */
1287 /* not magic; cancels to blank spellbook */
1298 }
1309 /* cancelling a novel is more involved than a spellbook */
1312 }
1318 /* sickness is "biologically contaminated" fruit juice;
1319 cancel it and it just becomes fruit juice...
1320 whereas see invisible tastes like "enchanted" fruit
1321 juice, it similarly cancels */
1326 }
1328 }
1329 }
1330 /* cancelling a troll's corpse prevents it from reviving (on its own;
1331 does not affect undead turning induced revival) */
1340 }
1341 }
1346 }
1348 /* soaking or cancelling a novel converts it into a blank spellbook but
1349 needs more than just changing its otyp (caller is responsible for that) */
1350 void
1352 {
1354 /* novelidx overloads corpsenm, not used for spellbooks */
1357 /* a blank spellbook weighs more than a novel; update obj's weight and
1358 recursively the weight of any container holding it */
1360 }
1362 /* Remove a positive enchantment or charge from obj,
1363 * possibly carried by you or a monster
1364 */
1365 boolean
1367 {
1368 boolean u_ring;
1370 /* Is this a charged/enchanted object? */
1380 /* Charge for the cost of the object */
1384 /* Drain the object and any implied effects */
1392 }
1398 }
1404 }
1423 }
1429 }
1433 }
1439 }
1441 boolean
1445 {
1456 }
1457 }
1459 boolean
1461 {
1473 else
1476 /* adjust for "large" quantities of identical things */
1481 }
1483 /* Use up at least minwt number of things made of material mat.
1484 * There's also a chance that other stuff will be used up. Finally,
1485 * there's a random factor here to keep from always using the stuff
1486 * at the top of the pile.
1487 */
1488 staticfn void
1490 {
1501 #ifdef MAIL_STRUCTURES
1504 #endif
1508 /* appropriately add damage to bill */
1512 else
1514 FALSE);
1515 }
1518 else
1521 }
1522 }
1523 }
1525 /*
1526 * Polymorph some of the stuff in this pile into a monster, preferably
1527 * a golem of the kind okind.
1528 */
1529 staticfn void
1531 {
1538 /* this is approximate because the "no golems" !obj->nexthere
1539 check below doesn't understand bypassed objects; but it
1540 should suffice since bypassed objects always end up as a
1541 consecutive group at the top of their pile */
1544 }
1546 /* no golems if you zap only one object -- not enough stuff */
1550 /* some of these choices are arbitrary */
1568 /* there is no flesh type, but all food is type 0, so we use it */
1601 /* if all else fails... */
1605 }
1616 }
1617 }
1619 /* Assumes obj is on the floor. */
1620 void
1622 {
1625 #ifdef MAIL_STRUCTURES
1628 #endif
1632 /* some may metamorphosize */
1637 }
1638 }
1640 /* if quan > 1 then some will survive intact */
1644 else
1646 }
1648 /* appropriately add damage to bill */
1652 else
1654 }
1656 /* zap the object */
1658 }
1660 /* Returns TRUE if obj resists polymorphing */
1661 boolean
1663 {
1667 }
1669 /* classes of items whose current charge count carries over across polymorph
1670 */
1674 /*
1675 * Polymorph the object to the given object ID. If the ID is STRANGE_OBJECT
1676 * then pick random object from the source's class (this is the standard
1677 * "polymorph" case). If ID is set to a specific object, inhibit fusing
1678 * n objects into 1. This could have been added as a flag, but currently
1679 * it is tied to not being the standard polymorph case. The new polymorphed
1680 * object replaces obj in its link chains. Return value is a pointer to
1681 * the new object.
1682 *
1683 * This should be safe to call for an object anywhere.
1684 */
1687 {
1702 /* Try up to 3 times to make the magic-or-not status of
1703 the new item be the same as it was for the old one. */
1712 /* literally replace obj with this new thing */
1714 /* Actually more things use corpsenm but they polymorph differently */
1715 #define USES_CORPSENM(typ) \
1716 ((typ) == CORPSE || (typ) == STATUE || (typ) == FIGURINE)
1720 #undef USES_CORPSENM
1721 }
1723 /* preserve quantity */
1725 /* preserve the shopkeepers (lack of) interest */
1727 /* preserve inventory letter if in inventory */
1730 #ifdef MAIL_STRUCTURES
1731 /* You can't send yourself 100 mail messages and then
1732 * polymorph them into useful scrolls
1733 */
1737 }
1738 #endif
1740 /* avoid abusing eggs laid by you */
1744 /* first, turn into a generic egg */
1750 }
1754 /* now change it into something laid by the hero */
1761 }
1762 }
1763 }
1765 /* keep special fields (including charges on wands) */
1780 }
1782 /* Keep chest/box traps and poisoned ammo if we may */
1789 /* turn crocodile corpses into shoes */
1798 }
1799 }
1803 /* clear m_id before delobj(), to avoid o_unleash() by obfree() */
1806 /* obfree() would do this if we didn't do it here */
1808 }
1809 }
1811 /* no box contents --KAA */
1815 /* 'n' merged objects may be fused into 1 object */
1827 }
1828 /* don't care about the recharge count of other tools */
1834 /* altering the object tends to degrade its quality
1835 (analogous to spellbook `read count' handling) */
1843 /* potions of oil use obj->age field differently from other potions */
1851 /* reduce spellbook abuse; non-blank books degrade;
1852 3.7: novels don't use spestudied so shouldn't degrade to blank
1853 (but don't force spestudied to zero for them since a non-zero
1854 value could get passed along to a future polymorph) */
1859 /* writing a new book over it will yield an unstudied
1860 one; re-polymorphing this one as-is may or may not
1861 get something non-blank */
1863 }
1864 }
1873 }
1875 }
1877 /* update the weight */
1880 /*
1881 * ** we are now done adjusting the object (except possibly wearing it) **
1882 */
1886 /* swap otmp for obj */
1889 /*
1890 * We may need to do extra adjustments for the hero if we're
1891 * messing with the hero's inventory. The following calls are
1892 * equivalent to calling freeinv() on obj and addinv_nomerge()
1893 * on otmp, while doing an in-place swap of the actual objects.
1894 */
1898 /*
1899 * Handle polymorph of worn item. Stone-to-flesh cast on self can
1900 * affect multiple objects at once, but their new forms won't
1901 * produce any side-effects. A single worn item dipped into potion
1902 * of polymorph can produce side-effects but those won't yield out
1903 * of sequence messages because current polymorph is finished.
1904 */
1908 /* wearslot() expects us to deal with wielded/alt-wep/quivered
1909 items in case they're not weapons; for other slots it might
1910 return multiple bits (ring left|right); narrow that down to
1911 the bit(s) currently in use */
1915 /* if the new form can be worn in the same slot, make it so */
1930 /* set_wear() might result in otmp being destroyed if
1931 worn amulet has been turned into an amulet of change */
1934 }
1941 /* leaving boulder in liquid would trigger sanity_check warning */
1946 }
1947 }
1949 /* note: if otmp is gone, billing for it was handled by useup() */
1966 }
1969 }
1970 }
1973 }
1975 /* stone-to-flesh spell hits and maybe transforms or animates obj */
1976 staticfn int
1978 {
1989 /* Heart of Ahriman usually resists; ordinary items rarely do */
1994 /* add more if stone objects are added.. */
2006 /* Don't animate monsters that aren't flesh */
2010 }
2012 /* animate_statue() forces all golems to become flesh golems */
2024 }
2029 else
2034 }
2035 }
2038 /* this golem handling is redundant... */
2041 NC_VIA_WAND_OR_SPELL);
2043 /* didn't revive but can't leave corpse either */
2046 /* unlikely to get here since genociding monsters also
2047 sets the G_NOCORPSE flag; drop statue's contents */
2052 }
2054 }
2057 }
2059 /* maybe add weird things to become? */
2073 FALLTHROUGH;
2074 /*FALLTHRU*/
2078 }
2082 /* non-meat eaters smell meat, meat eaters smell its flavor;
2083 monks are considered non-meat eaters regardless of behavior;
2084 other roles are non-meat eaters if they haven't broken
2085 vegetarian conduct yet (or if poly'd into non-carnivorous/
2086 non-omnivorous form, regardless of whether it's herbivorous,
2087 non-eating, or something stranger) */
2091 else
2093 }
2096 }
2098 /*
2099 * Object obj was hit by the effect of the wand/spell otmp. Return
2100 * non-zero if the wand/spell had any effect.
2101 */
2102 int
2104 {
2108 /* fundamental: a wand effect hitting itself doesn't do anything;
2109 otherwise we need to guard against accessing otmp after something
2110 strange has happened to it (along the lines of polymorph or
2111 stone-to-flesh [which aren't good examples since polymorph wands
2112 aren't affected by polymorph zaps and stone-to-flesh isn't
2113 available in wand form, but the concept still applies...]) */
2118 /* The bypass bit is currently only used as follows:
2119 *
2120 * POLYMORPH - When a monster being polymorphed drops something
2121 * from its inventory as a result of the change.
2122 * If the items fall to the floor, they are not
2123 * subject to direct subsequent polymorphing
2124 * themselves on that same zap. This makes it
2125 * consistent with items that remain in the monster's
2126 * inventory. They are not polymorphed either.
2127 * UNDEAD_TURNING - When an undead creature gets killed via
2128 * undead turning, prevent its corpse from being
2129 * immediately revived by the same effect.
2130 * STONE_TO_FLESH - If a statue can't be revived, its
2131 * contents get dropped before turning it into
2132 * meat; prevent those contents from being hit.
2133 * retouch_equipment() - bypass flag is used to track which
2134 * items have been handled (bhito isn't involved).
2135 * menu_drop(), askchain() - inventory traversal where multiple
2136 * Drop can alter the invent chain while traversal
2137 * is in progress (bhito isn't involved).
2138 * destroy_items() - inventory traversal where item destruction can
2139 * trigger drop or destruction of other item(s) and alter
2140 * the invent or mon->minvent chain, possibly recursively.
2141 *
2142 * The bypass bit on all objects is reset each turn, whenever
2143 * svc.context.bypasses is set.
2144 *
2145 * We check the obj->bypass bit above AND svc.context.bypasses
2146 * as a safeguard against any stray occurrence left in an obj
2147 * struct someplace, although that should never happen.
2148 */
2154 }
2155 }
2157 /*
2158 * Some parts of this function expect the object to be on the floor
2159 * obj->{ox,oy} to be valid. The exception to this (so far) is
2160 * for the STONE_TO_FLESH spell.
2161 */
2180 }
2181 /* KMH, conduct */
2186 /* any saved lock context will be dangerously obsolete */
2198 /* eek - your cover might have been blown */
2202 }
2208 /* target object has now been "seen (up close)" */
2212 /* plural handling here is superfluous because containers
2213 and statues don't stack */
2220 /* we don't want to force alive vs dead
2221 determination for Schroedinger's Cat here,
2222 so just make probing be inconclusive for it */
2225 /* unfortunately, we can't tell whether rndmonnam()
2226 picks a form which can't leave a corpse */
2232 /* view contents (not recursively) */
2236 }
2239 /* don't learn wand if tin is already known */
2245 /* if egg is unhatchable, probing it won't learn wand
2246 because even when flagged as known, it's just "an egg" */
2250 /* [should this call learn_egg_type()?] */
2251 }
2257 /* learn the type if you see or hear something break
2258 (the sound could be implicit) */
2264 else
2272 else
2276 }
2283 else
2284 /* obj broke; force redisplay in case it was the only--
2285 or last--item under non-breaking pile-top; top item
2286 here might now be a lone object rather than a pile */
2289 }
2303 {
2308 }
2324 /* get corpse's location before revive() uses it up */
2328 /* explicit revival magic overrides timer-based no-revive */
2343 /* saw corpse but don't see monster: maybe
2344 mtmp is invisible, or has been placed at
2345 a different spot than <ox,oy> */
2349 }
2351 /* couldn't see corpse's location */
2358 else
2361 }
2363 /* didn't see corpse but do see monster: it
2364 has been placed somewhere other than <ox,oy>
2365 or blind hero spots it with ESP */
2367 }
2370 }
2371 }
2379 else
2398 }
2399 /* if effect was observable then discover the wand type provided
2400 that the wand itself has been seen */
2404 }
2406 /* returns nonzero if something was hit */
2407 int
2413 {
2421 /* if hiding underneath an object and zapping up or down, the top item
2422 is either the only thing hit (up) or is skipped (down) */
2430 /* We can't settle for the default calling sequence of
2431 bhito(otmp) -> break_statue(otmp) -> activate_statue_trap(ox,oy)
2432 because that last call might end up operating on our `next_obj'
2433 (below), rather than on the current object, if it happens to
2434 encounter a statue which mustn't become animated. */
2438 /* assume zapping up or down while hiding under the top item can
2439 still activate the trap even if it's below (when zapping up)
2440 or above (when zapping down) */
2443 }
2454 /* !first */
2457 }
2458 }
2462 }
2467 /* when boulders are present they're expected to be on top; with
2468 multiple boulders it's possible for some to have been changed into
2469 non-boulders (polymorph, stone-to-flesh) while ones beneath resist,
2470 so re-stack pile if there are any non-boulders above boulders */
2476 }
2478 }
2486 }
2488 /*
2489 * zappable - returns 1 if zap is available, 0 otherwise.
2490 * it removes a charge from the wand if zappable.
2491 * added by GAN 11/03/86
2492 */
2493 int
2495 {
2502 }
2504 void
2506 {
2512 }
2514 /*
2515 * zapnodir - zaps a NODIR wand/spell.
2516 * Won't get here if wand has no charges (unless wresting 1 last charge).
2517 */
2518 void
2520 {
2526 /* FIXME? wand of light becoming discovered should be contingent upon
2527 seeing at least one previously unlit spot become lit */
2534 /* findit() gives sufficient feedback to discover the wand even when
2535 blinded or when it fails to find anything */
2540 /* create_critters() returns True iff hero sees a new monster appear */
2551 /* wand of wishing asks player what to wish for so always becomes
2552 discovered (unless it hasn't been seen) */
2554 }
2558 /* do_enlightenmnt_effect() always describes enlightenment */
2563 }
2568 /* effect was observable; discover the wand type provided
2569 that the wand itself has been seen */
2571 }
2572 }
2574 staticfn void
2576 {
2584 }
2586 /* getobj callback for object to zap */
2587 staticfn int
2589 {
2593 }
2595 /* #zap command, 'z' (or 'y' if numbed_pad==-1) */
2596 int
2598 {
2605 }
2620 /* 'obj' is gone; skip update_inventory() because
2621 backfire() -> useupall() -> freeinv() did it */
2626 /* make him pay for knowing !NODIR */
2634 }
2636 /* Are we having fun yet?
2637 * weffects -> buzz(obj->otyp) -> zhitm (temple priest) ->
2638 * attack -> hitum -> known_hitum -> ghod_hitsu ->
2639 * buzz(AD_ELEC) -> destroy_items(AD_ELEC) ->
2640 * useup -> obfree -> dealloc_obj -> free(obj)
2641 */
2646 }
2653 }
2655 /* Lock or unlock all boxes in inventory */
2656 staticfn void
2658 {
2662 /* (un)lock carried boxes */
2668 }
2669 }
2672 }
2674 int
2676 {
2697 }
2713 }
2735 }
2756 }
2771 }
2779 }
2791 }
2796 /* have to test before changing HInvis but must change
2797 * HInvis before doing newsym().
2798 */
2802 /* A mummy wrapping absorbs it and protects you */
2805 }
2811 }
2813 }
2816 /* no longer gives intrinsic, but gives very fast speed instead */
2831 else
2835 }
2843 }
2849 /* same criteria as when mounted (zap_steed) */
2862 }
2866 /* probably don't need these to be urgent; player just gave input
2867 without subsequent opportunity to dismiss --More-- with ESC */
2870 /* They might survive with an amulet of life saving */
2886 /* assert( !ordinary ); */
2888 FALLTHROUGH;
2889 /*FALLTHRU*/
2902 /* zapping either self or holder/holdee [bhitm()] will release
2903 holder's grasp from the hero or hero's grasp from holdee */
2906 }
2910 }
2911 /* invent is hit iff hero doesn't escape from a trap */
2914 /* trigger previously escaped trapdoor */
2916 }
2920 /* similar logic to opening; invent is hit iff no trap triggered */
2923 }
2938 boolean didmerge;
2943 }
2947 }
2948 /* but at a cost.. */
2953 }
2954 /*
2955 * It is possible that we can now merge some inventory.
2956 * Do a highly paranoid merge. Restart from the beginning until
2957 * no merges. Don't merge worn items (in case of stone-to-flesh
2958 * of rocks wielded in differing weapon/alt-wep/quiver slot).
2959 */
2969 }
2970 }
2973 }
2977 }
2978 /* if effect was observable then discover the wand type provided
2979 that the wand itself has been seen */
2983 }
2985 /* called when poly'd hero uses breath attack against self */
2986 void
2988 {
2992 }
2994 /* light damages hero in gremlin form */
2995 int
3000 {
3006 /* reduce high values (from destruction of wand with many charges) */
3013 /* [composing killer/reason is superfluous here; if fatal, cause
3014 of death will always be "killed while stuck in creature form"] */
3022 /* might rehumanize(); could be fatal, but only for Unchanging */
3024 }
3026 }
3028 /* light[ning] causes blindness */
3029 boolean
3031 {
3038 }
3039 /* if blinding is resisted due to magical equipment (Sunsword), give
3040 a sparkle animation (even if also resisted due to being blind)
3041 _unless_ this is lightning-induced; we don't want a double sparkle
3042 if hero is both lightning resistant and blindness resistant, or
3043 worse, have a single sparkle where the player confuses blindness
3044 resistance for lightning resistance */
3048 }
3050 }
3052 /* you've zapped a wand downwards while riding
3053 * Return TRUE if the steed was hit by the wand.
3054 * Return FALSE if the steed was not hit by the wand.
3055 */
3056 staticfn boolean
3058 {
3064 /*
3065 * Wands that are allowed to hit the steed
3066 * Carefully test the results of any that are
3067 * moved here from the bottom section.
3068 */
3076 /* you go together */
3078 /* same criteria as when unmounted (zapyourself) */
3085 /* Default processing via bhitm() for these */
3109 }
3111 }
3113 /*
3114 * cancel a monster (possibly the hero). inventory is cancelled only
3115 * if the monster is zapping itself directly, since otherwise the
3116 * effect is too strong. currently non-hero monsters do not zap
3117 * themselves with cancellation.
3118 */
3119 boolean
3122 {
3123 static const char
3142 /* update_inventory(); -- handled by caller */
3143 }
3144 }
3146 /* now handle special cases */
3149 /*
3150 * Return to normal form unless Unchanging.
3151 * Hero in clay golem form dies if Unchanging.
3152 * Does not cure lycanthropy or stop timed random polymorph.
3153 */
3160 }
3163 else
3165 }
3168 /* force shapeshifter into its base form or mimic to unhide */
3174 /* !allow_cancel_kill is for Magicbane, where clay golem
3175 will be killed somewhere back up the call/return chain... */
3179 else
3181 }
3182 }
3183 }
3185 }
3187 /* you've zapped an immediate type wand up or down */
3188 staticfn boolean
3190 {
3199 /* some wands have special effects other than normal bhitpile */
3200 /* drawbridge might change <u.ux,u.uy> */
3215 /* sequencing: zap_map() calls force_decor() for ice or furniture;
3216 we need to call it before probing for buried objects */
3219 /*map_zapped = TRUE; // not needed due to early return*/
3226 }
3229 }
3240 }
3241 /* up or down, but at closed portcullis only */
3246 /* can't use the stairs down to quest level 2 until
3247 leader "unlocks" them; give feedback if you try */
3251 }
3252 /* down will release you from bear trap or web */
3255 /* down will trigger trapdoor, hole, or [spiked-] pit */
3258 }
3263 FALLTHROUGH;
3264 /*FALLTHRU*/
3267 /* down at open bridge or up or down at open portcullis */
3274 else
3281 /* similar to zap_dig() */
3289 }
3295 /* striking transforms trapdoor into hole */
3303 }
3307 /* might fall down hole */
3310 /* locking transforms hole into trapdoor */
3320 }
3321 /* hadn't fallen down hole; won't fall now */
3322 }
3323 }
3332 /*
3333 Print this message only if there wasn't an engraving
3334 affected here. If water or ice, act like waterlevel case.
3335 */
3340 else
3345 }
3346 }
3350 }
3353 /* zapping downward */
3356 /* note: engraving handling that used to be here has been moved
3357 to zap_map() */
3362 /* zapping upward */
3364 /* game flavor: if you're hiding under "something"
3365 * a zap upward should hit that "something".
3366 */
3376 }
3377 }
3378 }
3381 }
3383 /* used by do_break_wand() was well as by weffects() */
3384 void
3386 {
3388 }
3390 void
3392 {
3393 /* if do_osshock() set obj_zapped while polying, give a message now */
3397 }
3399 /* called for various wand and spell effects - M. Stephenson */
3400 void
3402 {
3414 /* [how about `bhitpile(u.ustuck->minvent)' effect?] */
3420 }
3427 /* neither immediate nor directionless */
3436 else
3439 }
3444 }
3446 }
3448 /* augment damage for a spell based on the hero's intelligence (and level) */
3449 int
3452 {
3455 /* Punish low intelligence before low level else low intelligence
3456 gets punished only when high level */
3458 /* -3 penalty, but never reduce combined amount below 1
3459 (if dmg is 0 for some reason, we're careful to leave it there) */
3468 else
3472 }
3474 /*
3475 * Generate the to hit bonus for a spell. Based on the hero's skill in
3476 * spell class and dexterity.
3477 */
3478 staticfn int
3480 {
3498 }
3507 /* Will change when print stuff below removed */
3509 else
3510 /* Even increment for dexterous heroes (see weapon.c abon) */
3514 }
3518 {
3519 /* force == 0 occurs e.g. with sleep ray */
3520 /* note that large force is usual with wands so that !! would
3521 require information about hand/weapon/wand */
3523 }
3525 void
3530 {
3538 }
3540 void
3542 {
3546 }
3548 staticfn void
3550 {
3558 }
3560 /* Maybe explode a trap hit by object otmp's effect;
3561 cancellation beam hitting a magical trap causes an explosion.
3562 Might delete the trap; won't destroy otmp. */
3563 staticfn void
3568 {
3580 }
3584 /* note: this explosion mustn't destroy otmp */
3591 }
3592 }
3593 }
3595 /* zap_map() occurs before hitting monsters or objects and handles wands or
3596 spells that don't dish out 'elemental' damage */
3597 staticfn void
3601 {
3606 /*
3607 * We handle drawbridge for lateral zaps; zap_updown() handles up/down.
3608 * Engravings only get hit by down zaps and we handle that here.
3609 */
3611 /* cancellation */
3619 /* subset of engraving effects; none sets `disclose' */
3638 /* only affects things in stone */
3643 }
3651 }
3652 }
3661 /* dbwall: 'closed door' of raised drawbridge */
3666 }
3670 /* drawbridge_down: span of lowered drawbridge */
3678 /* !drawbridge_up: not spot in front of raised bridge,
3679 so either span of lowered bridge or portcullis */
3683 }
3685 }
3690 /*
3691 * Probing, either up/down or lateral.
3692 */
3693 schar ltyp;
3696 /* map terrain; might reveal a special room which is already within
3697 view that hasn't been entered yet */
3702 /* TODO: ought to give some message */
3704 }
3706 /* secret door gets revealed, converted into regular door */
3716 }
3718 /* secret corridor likewise, although only ones within view will
3719 still be secret; for the !cansee(x,y) case, show_map_spot()
3720 above has already converted the spot to regular corridor */
3728 /* if on or over ice, describe it ("solid ice", "thin ice", &c);
3729 likewise for furniture in case hero is levitating while blind */
3734 }
3735 }
3736 /*
3737 * Probing reveals undiscovered traps.
3738 *
3739 * FIXME? This finds floor traps even when zapping up and
3740 * ceiling traps even when zapping down.
3741 */
3747 /* should probably be changed to use sense_trap(detect.c)
3748 so that trap can temporarily be forced to be shown and
3749 map browsing can take place before it reverts to being
3750 covered by monster or object(s) */
3763 }
3770 }
3772 /*
3773 * Called for the following distance effects:
3774 * when a weapon is thrown (weapon == THROWN_WEAPON)
3775 * when an object is kicked (KICKED_WEAPON)
3776 * when an IMMEDIATE wand is zapped (ZAPPED_WAND)
3777 * when a light beam is flashed (FLASHED_LIGHT)
3778 * when a mirror is applied (INVIS_BEAM)
3779 * A thrown/kicked object falls down at end of its range or when a monster
3780 * is hit. The variable 'gb.bhitpos' is set to the final position of the
3781 * weapon thrown/zapped. The ray of a wand may affect (by calling a provided
3782 * function) several objects and monsters on its path. The return value
3783 * is the monster hit (weapon != ZAPPED_WAND), or a null monster pointer.
3784 *
3785 * Thrown and kicked objects (THROWN_WEAPON or KICKED_WEAPON) may be
3786 * destroyed and *pobj set to NULL to indicate this.
3787 *
3788 * Check !u.uswallow before calling bhit().
3789 * This function reveals the absence of a remembered invisible monster in
3790 * necessary cases (throwing or kicking weapons). The presence of a real
3791 * one is revealed for a weapon, but if not a weapon is left up to fhitm().
3792 *
3793 * If fhitm returns non-zero value, stops the beam and returns the monster
3794 */
3802 * if object is destroyed */
3803 {
3807 uchar typ;
3816 /* object starts one square in front of player */
3819 range--;
3823 }
3828 }
3851 }
3858 }
3862 /* WATER aka "wall of water" stops items */
3866 }
3868 /* iron bars will block anything big enough and break some things */
3875 /* caveat: obj might now be null... */
3881 }
3885 }
3888 /* cancellation/opening/locking/striking/probing */
3890 /* terrain might have changed (exposed secret door|corridor) */
3892 }
3903 }
3907 }
3909 /*
3910 * skipping rocks
3911 *
3912 * skiprange_start is only set if this is a thrown rock
3913 */
3920 else
3922 skipcount++;
3925 }
3926 }
3937 }
3938 }
3940 /* if mtmp is a shade and missile passes harmlessly through it,
3941 give message and skip it in order to keep going;
3942 if attack is light and mtmp is a mimic pretending to be an
3943 object, behave as if there is no monster here (if pretending
3944 to be furniture, it will be revealed by flash_hits_mon()) */
3954 /* FLASHED_LIGHT hitting invisible monster should pass
3955 through instead of stop so we call flash_hits_mon()
3956 directly rather than returning mtmp back to caller.
3957 That allows the flash to keep on going. Note that we
3958 use mtmp->minvis not canspotmon() because it makes no
3959 difference whether hero can see the monster or not. */
3967 }
3969 /* Like FLASHED_LIGHT, INVIS_BEAM should continue
3970 through invisible targets; unlike it, we aren't
3971 prepared for multiple hits so just get first one
3972 that's either visible or could see its invisible
3973 self. [No tmp_at() cleanup is needed here.] */
3977 }
3979 /* THROWN_WEAPON, KICKED_WEAPON */
3988 /* ZAPPED_WAND */
3992 }
3994 }
4000 }
4001 }
4004 range--;
4011 }
4012 }
4028 }
4029 }
4031 }
4032 }
4037 }
4039 /* 'I' present but no monster: erase */
4040 /* do this before the tmp_at() */
4044 }
4047 /* kicked objects fall in pools */
4052 }
4053 /* limit range of ball so hero won't make an invalid move */
4066 /* nb: it didn't hit anything directly */
4073 /* hero falls into the trap, so ball stops */
4075 }
4076 }
4077 }
4079 /* thrown/kicked missile has moved away from its starting spot */
4081 }
4090 bhit_done:
4091 /* note: for FLASHED_LIGHT, _caller_ must call transient_light_cleanup()
4092 after possibly calling flash_hits_mon() */
4097 }
4099 /* process thrown boomerang, which travels a curving path...
4100 * A multi-shot volley ought to have all missiles in flight at once,
4101 * but we're called separately for each one. We terminate the volley
4102 * early on a failed catch since continuing to throw after being hit
4103 * is too obviously silly.
4104 */
4107 {
4113 /* counterclockwise traversal patterns, from @ to 1 then on through to 9
4114 * ..........................54.................................
4115 * ..................43.....6..3....765.........................
4116 * ..........32.....5..2...7...2...8...4....87..................
4117 * .........4..1....6..1...8..1....9...3...9..6.....98..........
4118 * ..21@....5...@...7..@....9@......@12....@...5...@..7.....@9..
4119 * .3...9....6..9....89.....................1..4...1..6....1..8.
4120 * .4...8.....78.............................23....2..5...2...7.
4121 * ..567............................................34....3..6..
4122 * ........................................................45...
4123 * (invert rows for corresponding clockwise patterns)
4124 */
4143 }
4148 }
4154 }
4157 /* we hit ourselves */
4166 }
4167 }
4176 }
4177 /* ct==0, initial position, we want next delta to be same;
4178 ct==5, opposite position, repeat delta undoes first one */
4181 }
4184 }
4186 /* used by buzz(); also used by munslime(muse.c); returns damage applied
4187 to mon; note: caller is responsible for killing mon if damage is fatal */
4188 int
4194 {
4206 }
4215 }
4226 }
4227 }
4233 }
4244 /* resistance and shield effect and revealing concealed mimic are
4245 handled by sleep_monst() */
4258 }
4261 /* similar to player */
4264 }
4272 /* destroy shield; victim survives */
4275 /* destroy suit, also cloak if present */
4280 /* no suit, victim dies; destroy cloak
4281 and shirt now in case target gets life-saved */
4287 }
4290 }
4301 /* can still blind the monster */
4302 }
4306 /* sufficiently powerful lightning blinds monsters */
4311 else
4313 }
4321 }
4328 }
4335 }
4349 }
4351 staticfn void
4356 {
4370 }
4382 }
4389 }
4401 }
4413 }
4425 }
4428 /* destroy shield; other possessions are safe */
4432 /* destroy suit; if present, cloak goes too */
4437 }
4438 /* no shield or suit, you're dead; wipe out cloak
4439 and/or shirt in case of life-saving or bones */
4453 }
4457 /* when killed by disintegration breath, don't leave corpse */
4472 }
4489 }
4490 /* using two weapons at once makes both of them more vulnerable */
4498 }
4500 /*
4501 * 3.7: when fatal, this used to yield "Killed by <fltxt>." without any
4502 * information about who was responsible. Now 'buzzer' is used to try
4503 * to supply "zapped/cast/breathed by <mon> [imitating <other_mon>]."
4504 *
4505 * Room for improvement: there is no monster available when player is
4506 * hit by divine lighting or by Plane of Air thunderstorm so cause of
4507 * death remains "killed by a bolt of lightning" w/o extra explanation.
4508 *
4509 * Wand of death, spell of finger of death, and disintegration breath
4510 * don't use this routine so don't include 'inflicted by'.
4511 */
4512 {
4515 /* fire horn and frost horn get handled as wands by caller */
4524 /* if gb.buzzer is Null, kbuf[] will end up with just <fltxt> */
4526 /* change "death inflicted by mon" to "death <verb> by mon" */
4530 /* FIXME: "zapped by herself" is suitable for a rebound;
4531 "zapped at herself" would be better if player explicitly
4532 targeted hero */
4534 }
4535 /* Half_spell_damage protection yields half-damage for wands & spells,
4536 including hero's own ricochets; breath attacks do full damage */
4540 }
4542 }
4544 /*
4545 * burn objects (such as scrolls and spellbooks) on floor
4546 * at position x,y; return the number of objects burned
4547 */
4548 int
4552 boolean u_caused)
4553 {
4571 delquan++;
4573 /* save name before potential delobj() */
4584 }
4585 /* useupf(), which charges, only if hero caused damage */
4597 else
4599 }
4600 }
4601 }
4602 }
4603 /* This also ignites floor items, but does not change cnt
4604 because they weren't consumed. */
4607 }
4609 /* will zap/spell/breath attack score a hit against armor class `ac'? */
4610 staticfn int
4614 {
4618 /* small chance for naked target to avoid being hit */
4622 /* very high armor protection does not achieve invulnerability */
4626 }
4628 staticfn void
4633 {
4639 else
4641 }
4643 /* note: worn amulet of life saving must be preserved in order to operate */
4644 #define oresist_disintegration(obj) \
4645 (objects[obj->otyp].oc_oprop == DISINT_RES || obj_resists(obj, 5, 50) \
4646 || is_quest_artifact(obj) || obj == m_amulet)
4653 }
4654 }
4656 #undef oresist_disintegration
4660 else
4662 }
4664 void
4666 {
4668 }
4670 void
4672 {
4674 }
4676 /*
4677 * type == 0 to 9 : you zapping a wand
4678 * type == 10 to 19 : you casting a spell
4679 * type == 20 to 29 : you breathing as a monster
4680 * type == -10 to -19 : monster casting spell
4681 * type == -20 to -29 : monster breathing at you
4682 * type == -30 to -39 : monster zapping a wand
4683 * called with dx = dy = 0 for vertical bolts
4684 */
4685 void
4692 {
4696 coord save_bhitpos;
4704 /* if it's a Hero Spell then get its SPE_TYPE */
4718 /* Using disintegration from the inside only makes a hole... */
4723 }
4725 }
4744 /* reveal/unreveal invisible monsters before tmp_at() */
4753 }
4755 /* hit() and miss() need gb.bhitpos to match the target */
4758 /* fireballs only damage when they explode; poison gas leaves
4759 a trail of 1x1 clouds via zap_over_floor(), but that gets
4760 skipped for a hit that is reflected so is deferred until we
4761 know whether reflection is happening */
4764 /* zap with fire -> melt ice -> drown monster, so monster
4765 found and cached above might not be here any more */
4767 }
4774 buzzmonst:
4785 }
4803 }
4806 }
4814 }
4816 }
4822 /* mon has just been killed by another monster */
4827 /* killed by hero; we know 'type' isn't negative;
4828 if it's fire, highly flammable monsters leave
4829 no corpse; don't bother reporting that they
4830 "burn completely" -- unnecessary verbosity */
4832 /* paper golem or straw golem */
4836 }
4839 /* normal non-fatal hit */
4843 /* some armor was destroyed; no damage done */
4849 }
4854 }
4855 }
4860 }
4882 /* flash_str here only used for killer; suppress
4883 * hallucination */
4886 }
4891 }
4896 }
4897 /* gas that missed or that hit without being reflected will leave
4898 a 1x1 cloud here; the earlier zap_over_floor() was deferred */
4905 uchar rmn;
4907 make_bounce:
4926 }
4946 FALLTHROUGH;
4947 /*FALLTHRU*/
4954 }
4956 }
4957 }
4958 }
4965 /* "damage" indicates wall rather than door */
4969 FALSE);
4971 }
4973 void
4975 {
4987 }
5005 /* try again if there's another boulder and pool didn't fill */
5008 }
5013 }
5015 #define MIN_ICE_TIME 50
5016 #define MAX_ICE_TIME 2000
5017 /*
5018 * Usually start a melt_ice timer; sometimes the ice will become
5019 * permanent instead.
5020 */
5021 void
5025 {
5033 /* random timeout; surrounding ice locations ought to be a factor... */
5038 /* if we're within MAX_ICE_TIME, install a melt timer;
5039 otherwise, omit it to leave this ice permanent */
5044 }
5045 }
5046 #undef MIN_ICE_TIME
5047 #undef MAX_ICE_TIME
5049 /*
5050 * Called when ice has melted completely away.
5051 */
5052 void
5054 {
5059 /* melt_ice -> minliquid -> mondead|xkilled shouldn't credit/blame hero */
5063 /* melt_ice does newsym when appropriate */
5066 }
5068 /* Burn floor scrolls, evaporate pools, etc... in a single square.
5069 * Used both for normal bolts of fire, cold, etc... and for fireballs.
5070 * Sets shopdamage to TRUE if a shop door is destroyed, and returns the
5071 * amount by which range is reduced (value is negative and will be added
5072 * to remaining range by caller; ignored by fireballs and poison gas).
5073 */
5074 int
5081 * when a lit potion of oil explodes */
5082 {
5092 /* this won't have any effect on the floor */
5094 }
5100 /* a burning web is too flimsy to notice if you can't see it */
5106 }
5117 /* don't create steam clouds on Plane of Water; air bubble
5118 movement and gas regions don't understand each other */
5123 }
5135 /*if (t) -- this was before the vapor cloud was added --
5136 t->tseen = 1;*/
5139 }
5145 /* probably ought to do some hefty damage to any
5146 creature caught in boiling water;
5147 at a minimum, eels are forced out of hiding */
5150 }
5151 }
5154 /* if water walking/swimming/magical breathing, maybe fall
5155 into the new pit (after the water evaporation message);
5156 if flying or levitating, nothing will happen */
5161 }
5162 }
5169 }
5179 /* For now, don't let WATER freeze. */
5184 else
5203 else
5209 }
5210 }
5214 }
5221 else
5226 }
5229 /* leave the no longer existent water */
5241 }
5242 }
5244 /* probably ought to do some hefty damage to any
5245 non-ice creature caught in freezing water;
5246 at a minimum, eels are forced out of hiding */
5250 }
5251 }
5255 }
5261 /* Already ice here, so just firm it up. */
5262 /* Now ensure that only ice that is already timed is affected */
5266 }
5267 }
5271 /* poison gas with range 1: green dragon/iron golem breath (AD_DRST);
5272 caller is placing a series of 1x1 clouds along the zap's path;
5273 <x,y> for wall locations might be included--reject those */
5279 FALLTHROUGH;
5280 /*FALLTHRU*/
5290 /* but nothing actually happens... */
5301 }
5302 }
5303 }
5308 }
5310 /* set up zap text for possible door feedback; for exploding wand, we
5311 want "the blast" rather than "your blast" even if hero caused it */
5323 /* breakobj() -> explode_oil() -> splatter_burning_oil()
5324 -> explode(ZT_SPELL(ZT_FIRE), BURNING_OIL)
5325 -> zap_over_floor(ZT_SPELL(ZT_FIRE), POT_OIL) */
5326 /* leave zapverb as "blast"; exploding_wand_typ was nonzero, so
5327 'yourzap' is FALSE and the result will be "the blast" */
5329 }
5331 /* secret door gets revealed, converted into regular door */
5335 /* target spot will now pass closed_door() test below
5336 (except on rogue level) */
5343 }
5345 /* regular door absorbs remaining zap range, possibly gets destroyed */
5363 /* death spells/wands don't disintegrate */
5376 def_case:
5378 /* Magical explosion from misc exploding wand */
5384 }
5385 }
5387 /* "the door absorbs the blast" would be
5388 inaccurate for an exploding wand since
5389 other adjacent locations still get hit */
5392 else
5394 zapverb);
5398 }
5406 }
5419 }
5420 }
5421 }
5427 }
5431 }
5433 /* monster has cast flames or frost at target on <x,y>; called by mcastu() */
5434 void
5439 {
5440 /* "shower of missiles" or [hypothetical] "acid rain" attack:
5441 thoroughly clobber an engraving (unless its type makes it be
5442 scuff-protected); zap_over_floor() doesn't handle this */
5449 /* hero and player will still remember prior text until the spot
5450 is re-examined (lookhere or move off and back on) */
5451 }
5453 /* hit items and/or terrain; only matters for AD_FIRE and AD_COLD but
5454 accept any basic damage type that zap_over_floor() might handle */
5457 * though it's only used when zapdmgtyp
5458 * is non-negative (hero's fault) */
5465 adtyp);
5466 }
5467 }
5469 /* fractured by pick-axe or wand of striking or by vault guard or shopkeeper */
5470 void
5472 {
5481 /* shop message says "you owe <shk> <$> for it!" so we need
5482 to precede that with a message explaining what "it" is */
5484 /* breakobj won't destroy fracturing statue or boulder but
5485 will charge for shop goods */
5487 }
5488 }
5505 /* need immediate update in case this is a striking/force bolt
5506 zap that is about hit more things */
5508 }
5511 }
5512 }
5514 /* handle statue hit by striking/force bolt/pick-axe */
5515 boolean
5517 {
5518 /* [obj is assumed to be on floor, so no get_obj_location() needed] */
5526 /* drop any objects contained inside the statue */
5530 }
5535 }
5539 }
5541 /* Return TRUE if obj is eligible to pass to maybe_destroy_item given
5542 * the type of elemental damage it's being subjected to.
5543 * Note that things like the Book of the Dead are eligible even though they
5544 * won't get destroyed, because it will attempt to be destroyed but print a
5545 * special message instead. */
5546 staticfn boolean
5548 {
5550 /* don't destroy artifacts */
5552 }
5554 /* not available for destroying */
5556 }
5558 /* fire-magic items are immune */
5561 }
5565 }
5567 /* non-water potions don't freeze and shatter */
5570 }
5574 }
5575 /* electric-magic items are immune */
5578 }
5579 /* There used to be a commented out bit of code that would exclude
5580 * gc.current_wand, but it wasn't used, so it wasn't moved into this
5581 * function. */
5582 }
5584 }
5586 /* convert attack damage AD_foo to property resistance */
5587 staticfn int
5589 {
5603 }
5605 }
5607 /* Is hero wearing or wielding an object with resistance to attack
5608 damage type? Returns the percentage protection that the object gives. */
5609 int
5611 {
5617 /* Items that give an extrinsic resistance give 99% protection to
5618 your items */
5622 /* Dwarvish cloaks give a 90% protection to items against heat and cold */
5628 }
5630 /* Rolls to see whether an object in inventory resists damage from the
5631 given damage type, due to an equipped item protecting it. Use
5632 u_adtyp_resistance_obj to discover whether objects are protected in
5633 general (e.g. for enlightenment) and this function to actually do
5634 the roll to see whether a specific object is protected.
5636 This function doesn't check for other reasons why an object might
5637 be protected; you will usually need to do an obj_resists() call
5638 too. */
5639 boolean
5641 {
5648 }
5650 /* for enlightenment; currently only useful in wizard mode; cf from_what() */
5653 {
5682 else
5686 }
5687 /* format the output to be ready for enl_msg() to append it to
5688 "Your items {are,were} protected against <damage-type>" */
5691 }
5693 }
5695 /*
5696 * destroy_strings[dindx][0:singular,1:plural,2:killer_reason]
5697 * [0] freezing potion
5698 * [1] boiling potion other than oil
5699 * [2] boiling potion of oil
5700 * [3] burning scroll
5701 * [4] burning spellbook
5702 * [5] shocked ring
5703 * [6] shocked wand
5704 * (books, rings, and wands don't stack so don't need plural form;
5705 * crumbling ring doesn't do damage so doesn't need killer reason)
5706 * externally referenced from trap.c.
5707 */
5709 /* also used in trap.c */
5717 };
5719 /* guts of destroy_items();
5720 caller must decide whether obj is eligible, though there's one case (Book
5721 of the Dead) in which an eligible item shouldn't be destroyed (it prints a
5722 special message instead).
5723 Returns the amount of damage done, but it's used differently depending on
5724 whether it's the player or a monster having an item destroyed: players lose
5725 the HP and possibly die in this function, and the return value is unused,
5726 whereas monsters return the damage to their caller to be taken off later */
5727 staticfn int
5732 {
5741 /* lint suppression */
5745 /* external worn item protects inventory? */
5765 }
5767 }
5786 }
5796 skip++;
5801 }
5809 }
5815 }
5818 /* FIXME: recharge only handles items in hero's inventory */
5823 destroyed */
5828 cnt++;
5842 }
5848 }
5852 else
5854 }
5857 }
5858 }
5862 else
5864 }
5868 }
5880 }
5881 }
5882 }
5884 }
5886 /* scaling factor; dmg/5 stacks will be subjected to destroy_items() */
5887 #define DMG_DESTROY_SCALE 5
5888 /* largest amount of stacks that will be destroyed in a single call */
5889 #define MAX_ITEMS_DESTROYED 20
5891 /* target items of specified class in mon's inventory for possible destruction
5892 return total amount of damage inflicted, though this is unused if mon is
5893 the player */
5894 int
5897 * destruction */
5900 {
5907 boolean deferred;
5911 /* this is a struct obj** because we might destroy the first item in it */
5916 /* initialize items_to_destroy */
5918 /* 0 should not be a valid o_id for anything */
5922 }
5924 /* don't straight up destroy all items with an equal chance; limit it
5925 based on the amount of damage being dealt by the source of the item
5926 destruction */
5930 }
5932 /* in case of incredibly high damage, prevent from overflowing
5933 * items_to_destroy */
5935 }
5938 }
5940 /* Sometimes destroying an item can change inventory aside from
5941 * the item itself (cited case was a potion of unholy water; when
5942 * boiled, potionbreathe() caused hero to transform into were-beast
5943 * form and that resulted in dropping or destroying some worn armor).
5944 *
5945 * Unlike other uses of the object bypass mechanism, destroy_items()
5946 * can be called multiple times for the same event. So we have to
5947 * explicitly clear it before each use and hope no other section of
5948 * code expects it to retain previous value.
5949 *
5950 * Destruction of a ring of levitation or form change which pushes
5951 * off levitation boots could drop hero onto a fire trap that
5952 * could destroy other items and we'll get called recursively. Or
5953 * onto a trap which transports hero elsewhere, which won't disrupt
5954 * traversal but could yield message sequencing issues. So we
5955 * defer handling such things until after rest of inventory has
5956 * been processed. If some other combination of items and events
5957 * triggers a recursive call, rest of inventory after the triggering
5958 * item will be skipped by the outer call since the inner one will
5959 * have set the bypass bits of the whole list.
5960 *
5961 * [Unfortunately, death while poly'd into flyer and subsequent
5962 * rehumanization could also drop hero onto a trap, and there's no
5963 * straightforward way to defer that. Things could be improved by
5964 * redoing this to use two passes, first to collect a list or array
5965 * of o_id and quantity of what is targeted for destruction,
5966 * second pass to handle the destruction.]
5967 */
5974 /* obj is eligible; maybe add it to items_to_destroy */
5976 /* do this afterwards to avoid not filling items_to_destroy[0] */
5977 elig_stacks++;
5979 /* random index was too high; mollify analyzer by including < 0 */
5981 }
5989 /* if loss of this item might dump us onto a trap, hold off
5990 until later because potential recursive destroy_items() will
5991 result in setting bypass bits on whole chain--we would skip
5992 the rest as already processed once control returns here */
5997 /* destroyed wands and potions of polymorph don't trigger
5998 polymorph so don't need to be deferred */
6004 }
6005 }
6008 }
6010 /* if we saved some items for later (most likely just a worn ring
6011 of levitation) and they're still in inventory, handle them on the
6012 second iteration of the loop */
6020 }
6021 }
6022 }
6023 /* almost certainly not everything was destroyed; clear bypass bit after
6024 it was set earlier */
6027 }
6029 int
6031 {
6035 /* fake players always pass resistance test against Conflict
6036 (this doesn't guarantee that they're never affected by it) */
6040 /* attack level */
6063 }
6064 /* defense level */
6076 }
6083 else
6085 }
6086 }
6088 }
6090 #define MAXWISHTRY 5
6092 DISABLE_WARNING_FORMAT_NONLITERAL
6094 staticfn void
6096 {
6098 wishinfo[] = {
6115 },
6117 retry_info[] =
6120 suppress_cmdassist[] =
6125 winid win;
6149 }
6151 RESTORE_WARNING_FORMAT_NONLITERAL
6153 void
6155 {
6167 retry:
6180 }
6181 /*
6182 * Note: if they wished for and got a non-object successfully,
6183 * otmp == &hands_obj. That includes an artifact which has been
6184 * denied. Wishing for "nothing" requires a separate value to remain
6185 * distinct.
6186 */
6198 /* explicitly wished for "nothing", presumably attempting
6199 to retain wishless conduct */
6203 /* wizard mode terrain wish: skip livelogging, etc */
6205 }
6208 /* update artifact bookkeeping; doesn't produce a livelog event */
6210 }
6212 /* wisharti conduct handled in readobjnam() */
6215 /* KMH, conduct */
6222 else
6224 /* TODO? maybe generate a second event describing what was received since
6225 these just echo player's request rather than show actual result */
6244 /* The(aobjnam()) is safe since otmp is unidentified -dlc */
6248 }
6250 /* Fills buf with the appropriate string for this ray.
6251 * In the hallucination case, insert "blast of <silly thing>".
6252 * Assumes that the caller will specify typ in the appropriate range for
6253 * wand/spell/breath weapon. */
6258 {
6263 /* always return "blast of foo" for simplicity;
6264 this could be extended with hallucinatory rays, but probably
6265 not worth it at this time */
6269 }
6271 }
6273 /*zap.c*/