| blob | e62b8d333db099bde2983b34fe2567e6c366118f |
1 /* NetHack 3.6 hack.c $NHDT-Date: 1464485934 2016/05/29 01:38:54 $ $NHDT-Branch: NetHack-3.6.0 $:$NHDT-Revision: 1.168 $ */
2 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3 /* NetHack may be freely redistributed. See license for details. */
20 #define IS_SHOP(x) (rooms[x].rtype >= SHOPBASE)
24 anything *
27 {
31 }
33 anything *
36 {
40 }
42 anything *
45 {
49 }
51 anything *
54 {
58 }
60 boolean
64 {
67 coord cc;
75 /* move any living monster already at that location */
81 }
82 }
84 /* this location might not be safe, if not, move revived monster */
90 }
91 /* else impossible? */
92 }
95 }
97 STATIC_OVL int
99 {
107 /* make sure that this boulder is visible as the top object */
118 /* Give them a chance to climb over it? */
120 }
126 }
134 /* KMH -- Sokoban doesn't let you push boulders diagonally */
141 }
157 }
162 }
165 /* if a trap operates on the boulder, don't attempt
166 to move any others at this location; return -1
167 if another boulder is in hero's way, or 0 if he
168 should advance to the vacated boulder position */
179 /* if the boulder remains, it should fill the pit */
184 }
189 /* vision kludge to get messages right;
190 the pit will temporarily be seen even
191 if this is one among multiple boulders */
196 }
205 else
225 d_level dest;
230 /* trap didn't work; skip "disappears" message */
232 }
236 else
248 }
251 }
254 }
255 }
261 /*
262 * Re-link at top of fobj chain so that pile order is preserved
263 * when level is restored.
264 */
268 }
270 {
274 #else
275 /* note: reset to zero after save/restore cycle */
277 #endif
278 dopush:
290 }
292 /* Move the boulder *after* the message. */
301 }
303 nopushmsg:
307 else
311 cannot_push:
323 }
325 }
338 }
339 }
341 }
343 /*
344 * still_chewing()
345 *
346 * Chew on a wall, door, or boulder. Returns TRUE if still eating, FALSE
347 * when done.
348 */
349 STATIC_OVL int
352 {
378 /* solid rock takes more work & time to dig through */
385 boulder
400 boulder
412 }
414 /* Okay, you've chewed through something */
422 /*
423 * The location could still block because of
424 * 1. More than one boulder
425 * 2. Boulder stuck in a wall/stone/door.
426 *
427 * [perhaps use does_block() below (from vision.c)]
428 */
432 /* reset dig state */
436 }
442 }
451 }
465 }
472 }
479 }
484 }
495 }
497 void
501 {
502 /* optimize by leaving on the fobj chain? */
507 }
511 STATIC_OVL void
513 {
526 /* fake removal of levitation in advance so that final
527 disclosure will be right in case this turns out to
528 be fatal; fortunately the fact that rings and boots
529 are really still worn has no effect on bones data */
540 NO_KILLER_PREFIX);
542 }
545 }
547 /*
548 * Interrupt multi-turn putting on/taking off of armor (in which
549 * case we reached the sink due to being teleported while busy;
550 * in 3.4.3, Boots_on()/Boots_off() [called via (*aftermv)() when
551 * 'multi' reaches 0] triggered a crash if we were donning/doffing
552 * levitation boots [because the Boots_off() below causes 'uarmf'
553 * to be null by the time 'aftermv' gets called]).
554 *
555 * Interrupt donning/doffing if we fall onto the sink, or if the
556 * code below is going to remove levitation boots even when we
557 * haven't fallen (innate floating or flying becoming unblocked).
558 */
561 /* recalculate in case uarmf just got set to null */
563 }
565 /* remove worn levitation items */
568 HLevitation++;
573 }
578 }
583 }
584 HLevitation--;
585 /* probably moot; we're either still levitating or went
586 through float_down(), but make sure BFlying is up to date */
588 }
590 /* intended to be called only on ROCKs or TREEs */
591 boolean
594 {
599 }
601 boolean
604 {
607 }
609 boolean
613 {
619 }
621 /* caller has already decided that it's a tight diagonal; check whether a
622 monster--who might be the hero--can fit through, and if not then return
623 the reason why: 1: can't fit, 2: possessions won't fit, 3: sokoban
624 returns 0 if we can squeeze through */
625 int
628 {
632 /* too big? */
638 /* lugging too much junk? */
644 /* Sokoban restriction applies to hero only */
648 /* can squeeze through */
650 }
652 boolean
655 {
658 }
660 /* return TRUE if (dx,dy) is an OK place to move
661 * mode is one of DO_MOVE, TEST_MOVE, TEST_TRAV, or TEST_TRAP
662 */
663 boolean
667 {
674 /*
675 * Check for physical obstacles. First, the place we are going.
676 */
687 }
692 }
694 /* Eat the rock. */
699 /* MRKR: Automatic digging when wielding the appropriate tool */
707 /* sokoban restriction stays even after puzzle is solved */
713 }
715 }
726 /* Eat the door. */
747 }
750 }
754 }
756 testdiag:
759 /* Diagonal moves into a door are not allowed. */
763 }
764 }
765 }
768 /* Move at a diagonal. */
784 }
786 /* consecutive long worm segments are at <ux,y> and <x,uy> */
790 }
791 /* Pick travel path that does not require crossing a trap.
792 * Avoid water and lava using the usual running rules.
793 * (but not u.ux/u.uy because findtravelpath walks toward u.ux/u.uy) */
802 }
809 /* Now see if other things block our way . . */
812 /* Can't move at a diagonal out of a doorway with door. */
814 }
821 /* tunneling monsters will chew before pushing */
831 /* never travel through boulders in Sokoban */
835 /* don't pick two boulders in a row, unless there's a way thru */
843 }
844 }
845 /* assume you'll be able to push it when you get there... */
846 }
848 /* OK, it is a legal place to move. */
850 }
852 #ifdef DEBUG
855 /* in this case, toggle display of travel debug info */
857 {
860 }
863 /*
864 * Find a path from the destination (u.tx,u.ty) back to (u.ux,u.uy).
865 * A shortest path is returned. If guess is TRUE, consider various
866 * inaccessible locations as valid intermediate path points.
867 * Returns TRUE if a path was found.
868 */
869 STATIC_OVL boolean
871 boolean guess;
872 {
873 /* if travel to adjacent, reachable location, use normal movement rules */
883 }
885 }
896 /* If guessing, first find an "obvious" goal location. The obvious
897 * goal is the position the player knows of, or might figure out
898 * (couldsee) that is closest to the target on a straight path.
899 */
910 }
912 noguess:
925 /* no diagonal movement for grid bugs */
933 /*
934 * When guessing and trying to travel as close as possible
935 * to an unreachable target space, don't include spaces
936 * that would never be picked as a guessed target in the
937 * travel matrix describing hero-reachable spaces.
938 * This stops travel from getting confused and moving
939 * the hero back and forth in certain degenerate
940 * configurations of sight-blocking obstacles, e.g.
941 *
942 * T 1. Dig this out and carry enough to not be
943 * #### able to squeeze through diagonal gaps.
944 * #--.--- Stand at @ and target travel at space T.
945 * @.....
946 * |.....
947 *
948 * T 2. couldsee() marks spaces marked a and x
949 * #### as eligible guess spaces to move the hero
950 * a--.--- towards. Space a is closest to T, so it
951 * @xxxxx gets chosen. Travel system moves @ right
952 * |xxxxx to travel to space a.
953 *
954 * T 3. couldsee() marks spaces marked b, c and x
955 * #### as eligible guess spaces to move the hero
956 * a--c--- towards. Since findtravelpath() is called
957 * b@xxxx repeatedly during travel, it doesn't
958 * |xxxxx remember that it wanted to go to space a,
959 * so in comparing spaces b and c, b is
960 * chosen, since it seems like the closest
961 * eligible space to T. Travel system moves @
962 * left to go to space b.
963 *
964 * 4. Go to 2.
965 *
966 * By limiting the travel matrix here, space a in the
967 * example above is never included in it, preventing
968 * the cycle.
969 */
975 /* closed doors and boulders usually
976 * cause a delay, so prefer another path */
981 /* don't change travel matrix! */
982 nn++;
984 }
986 }
987 }
997 /* reset run so domove run checks work */
1000 }
1002 }
1007 nn++;
1008 }
1009 }
1010 }
1011 }
1013 #ifdef DEBUG
1015 /* Use of warning glyph is arbitrary. It stands out. */
1019 }
1024 }
1026 }
1031 radius++;
1032 }
1034 /* if guessing, find best location in travel matrix and go there */
1048 /* prefer non-zigzag path */
1052 }
1058 }
1059 }
1062 /* no guesses, just go in the general direction */
1068 }
1069 #ifdef DEBUG
1071 /* Use of warning glyph is arbitrary. It stands out. */
1080 }
1082 }
1092 }
1094 }
1096 found:
1101 }
1103 /* try to escape being stuck in a trapped state by walking out of it;
1104 return true iff moving should continue to intended destination
1105 (all failures and most successful escapes leave hero at original spot) */
1106 STATIC_OVL boolean
1110 {
1111 boolean anchored;
1124 else
1126 }
1127 /* [why does diagonal movement give quickest escape?] */
1135 /* try to escape; position stays same regardless of success */
1143 }
1149 else
1151 }
1155 else
1157 }
1164 else
1166 }
1174 else
1177 }
1178 }
1185 coord cc;
1188 /* can move normally within radius 1 of buried ball */
1190 /* ugly hack: we need to issue some message here
1191 in case "you are chained to the buried ball"
1192 was the most recent message given, otherwise
1193 our next attempt to move out of tether range
1194 after this successful move would have its
1195 can't-do-that message suppressed by Norep */
1199 }
1200 }
1209 }
1213 culprit);
1214 else
1216 culprit);
1219 }
1224 else
1229 }
1235 }
1237 }
1239 boolean
1241 {
1249 }
1251 }
1253 void
1255 {
1261 boolean on_ice;
1273 }
1287 }
1307 }
1309 }
1311 /* check slippery ice */
1326 }
1327 }
1340 }
1345 }
1346 /* turbulence might alter your actual destination */
1352 }
1355 }
1359 }
1369 }
1373 /* perhaps it fled (or was teleported or ... ) */
1376 /* When polymorphed into a sticking monster,
1377 * u.ustuck means it's stuck to you, not you to it.
1378 */
1382 /* If holder is asleep or paralyzed:
1383 * 37.5% chance of getting away,
1384 * 12.5% chance of waking/releasing it;
1385 * otherwise:
1386 * 7.5% chance of getting away.
1387 * [strength ought to be a factor]
1388 * If holder is tame and there is no conflict,
1389 * guaranteed escape.
1390 */
1395 pull_free:
1401 /* it's free to move on next turn */
1404 }
1405 /*FALLTHRU*/
1412 }
1413 }
1414 }
1418 /* Don't attack if you're running, and can see it */
1419 /* It's fine to displace pets, though */
1420 /* We should never get here if forcefight */
1429 }
1430 }
1431 }
1439 /* attack monster */
1441 /* don't stop travel when displacing pets; if the
1442 displace fails for some reason, attack() in uhitm.c
1443 will stop travel rather than domove */
1446 /* only attack if we know it's there */
1447 /* or if we used the 'F' command to fight blindly */
1448 /* or if it hides_under, in which case we call attack() to print
1449 * the Wait! message.
1450 * This is different from ceiling hiders, who aren't handled in
1451 * attack().
1452 */
1454 /* If they used a 'm' command, trying to move onto a monster
1455 * prints the below message and wastes a turn. The exception is
1456 * if the monster is unseen and the player doesn't remember an
1457 * invisible monster--then, we fall through to attack() and
1458 * attack_check(), which still wastes a turn, but prints a
1459 * different message and makes the player remember the monster.
1460 */
1468 else
1471 }
1475 /* try to attack; note that it might evade */
1476 /* also, we don't attack tame when _safepet_ */
1479 }
1480 }
1488 else
1491 }
1494 }
1496 /* specifying 'F' with no monster wastes a turn */
1498 /* remembered an 'I' && didn't use a move command */
1508 /* if a statue is displayed at the target location,
1509 player is attempting to attack it [and boulder
1510 handling below is suitable for handling that] */
1515 /* force fight at boulder/statue or wall/door while wielding
1516 pick: start digging to break the boulder or wall */
1518 /* can we dig? */
1520 /* should we dig? */
1524 }
1525 }
1527 /* about to become known empty -- remove 'I' if present */
1537 /* Underwater, targetting non-water; the map just shows blank
1538 because you don't see remembered terrain while underwater;
1539 although the hero can attack an adjacent monster this way,
1540 assume he can't reach out far enough to distinguish terrain */
1545 /* glyph might indicate unseen terrain if hero is blind;
1546 unlike searching, this won't reveal what that terrain is
1547 (except for solid rock, where the glyph would otherwise
1548 yield ludicrous "dark part of a room") */
1555 /* note: 'solid' is misleadingly named and catches pools
1556 of water and lava as well as rock and walls */
1557 else
1568 }
1570 }
1574 }
1575 /* not attacking an animal, so we try to move */
1579 }
1587 }
1593 }
1595 }
1597 /* Move ball and chain. */
1603 /* Check regions entering/leaving */
1607 /* now move the hero */
1611 /* Move your steed, too */
1616 }
1618 /*
1619 * If safepet at destination then move the pet to the hero's
1620 * previous location using the same conditions as in attack().
1621 * there are special extenuating circumstances:
1622 * (1) if the pet dies then your god angers,
1623 * (2) if the pet gets trapped then your god may disapprove,
1624 * (3) if the pet was already trapped and you attempt to free it
1625 * not only do you encounter the trap but you may frighten your
1626 * pet causing it to go wild! moral: don't abuse this privilege.
1627 *
1628 * Ceiling-hiding pets are skipped by this section of code, to
1629 * be caught by the normal falling-monster code.
1630 */
1632 /* if trapped, there's a chance the pet goes wild */
1641 }
1642 }
1652 /* can't swap places with pet pinned in a pit by a boulder */
1655 /* can't swap places when pet can't move to your spot */
1661 /* can't swap places when pet won't fit thru the opening */
1667 /* save its current description in case of polymorph */
1676 pnambuf);
1678 /* check for displacing it into pools and traps */
1684 /* there's already been a trap message, reinforce it */
1689 /* drowned or died...
1690 * you killed your pet by direct action, so get experience
1691 * and possibly penalties;
1692 * we want the level gain message, if it happens, to occur
1693 * before the guilt message below
1694 */
1695 {
1696 /* minliquid() and mintrap() call mondead() rather than
1697 killed() so we duplicate some of the latter here */
1705 }
1706 /* That's no way to treat a pet! Your god gets angry.
1707 *
1708 * [This has always been pretty iffy. Why does your
1709 * patron deity care at all, let alone enough to get mad?]
1710 */
1715 }
1720 }
1721 }
1722 }
1730 }
1736 /*
1737 * Mimics (or whatever) become noticeable if they move and are
1738 * imitating something that doesn't move. We could extend this
1739 * to non-moving monsters...
1740 */
1749 /* Clean old position -- vision_recalc() will print our new one. */
1751 /* Since the hero has moved, adjust what can be seen/unseen. */
1754 }
1761 /* delay next move because of ball dragging */
1762 /* must come after we finished picking up, in spoteffects() */
1767 }
1770 /* display every step or every 7th step depending upon mode */
1781 }
1782 }
1783 }
1784 }
1786 /* combat increases metabolism */
1787 boolean
1789 {
1790 /* this used to be part of domove() when moving to a monster's
1791 position, but is now called by attack() so that it doesn't
1792 execute if you decline to attack a peaceful monster */
1803 }
1804 }
1806 }
1808 void
1810 {
1811 /* a special clue-msg when on the Invocation position */
1821 else
1829 }
1830 }
1832 /* moving onto different terrain;
1833 might be going into solid rock, inhibiting levitation or flight,
1834 or coming back out of such, reinstating levitation/flying */
1835 STATIC_OVL void
1837 {
1843 /* called from spoteffects(), skip float_down() */
1851 }
1852 /* the same terrain that blocks levitation also blocks flight */
1860 /* [minor bug: we don't know whether this is beginning flight or
1861 resuming it; that could be tracked so that this message could
1862 be adjusted to "resume flying", but isn't worth the effort...] */
1865 }
1866 }
1868 /* extracted from spoteffects; called by spoteffects to check for entering or
1869 leaving a pool of water/lava, and by moveloop to check for staying on one;
1870 returns true to skip rest of spoteffects */
1871 boolean
1874 {
1875 /* check for leaving water */
1884 else
1897 }
1905 }
1906 }
1907 }
1909 /* check for entering water or lava */
1914 /* floating or clinging steed keeps hero safe (is_flyer() test
1915 is redundant; it can't be true since Flying yielded false) */
1918 /* steed enters pool */
1920 /* dismount_steed() -> float_down() -> pickup()
1921 (float_down doesn't do autopickup on Air or Water) */
1924 /* even if we actually end up at same location, float_down()
1925 has already done spoteffect()'s trap and pickup actions */
1929 }
1930 /* not mounted */
1932 /* drown(),lava_effects() return true if hero changes
1933 location while surviving the problem */
1941 }
1942 }
1944 }
1946 void
1948 boolean pick;
1949 {
1959 /* prevent recursion from affecting the hero all over again
1960 [hero poly'd to iron golem enters water here, drown() inflicts
1961 damage that triggers rehumanize() which calls spoteffects()...] */
1963 /* except when reason is transformed terrain (ice -> water) */
1965 /* or transformed trap (land mine -> pit) */
1973 /* moving onto different terrain might cause Levitation to toggle */
1984 boolean pit;
1986 /* if levitation is due to time out at the end of this
1987 turn, allowing it to do so could give the perception
1988 that a trap here is being triggered twice, so adjust
1989 the timeout to prevent that */
1996 /* levitation has ended; we've already triggered
1997 any trap and [usually] performed autopickup */
2000 }
2001 }
2002 }
2003 /*
2004 * If not a pit, pickup before triggering trap.
2005 * If pit, trigger trap before pickup.
2006 */
2012 /*
2013 * dotrap on a fire trap calls melt_ice() which triggers
2014 * spoteffects() (again) which can trigger the same fire
2015 * trap (again). Use static spottrap to prevent that.
2016 * We track spottraptyp because some traps morph
2017 * (landmine to pit) and any new trap type
2018 * should get triggered.
2019 */
2026 }
2027 }
2030 }
2031 /* Warning alerts you to ice danger */
2037 };
2044 }
2052 ;
2068 }
2081 }
2083 }
2084 spotdone:
2088 }
2090 }
2092 /* returns first matching monster */
2097 {
2106 }
2108 }
2114 {
2120 #define goodtype(rno) \
2121 (!typewanted \
2122 || (typefound = rooms[rno - ROOMOFFSET].rtype) == typewanted \
2123 || (typewanted == SHOPBASE && typefound > SHOPBASE))
2138 }
2173 }
2175 }
2177 /* is (x,y) in a town? */
2178 boolean
2181 {
2189 /*
2190 * See if (x,y) is in a room with subrooms, if so, assume it's the
2191 * town. If there are no subrooms, the whole level is in town.
2192 */
2198 }
2199 }
2202 }
2204 STATIC_OVL void
2207 {
2219 }
2231 }
2232 }
2237 /* filter u.ushops0 -> u.ushops_left */
2242 }
2244 /* possibly deliver a one-time room entry message */
2245 void
2248 {
2260 /* Did we just enter a shop? */
2268 /* Did we just enter some other special room? */
2269 /* vault.c insists that a vault remain a VAULT,
2270 * and temples should remain TEMPLEs,
2271 * but everything else gives a message only the first time */
2308 else
2316 else
2322 }
2325 /*FALLTHRU*/
2330 }
2337 /* No more room of that type */
2360 }
2361 }
2368 }
2369 }
2370 }
2373 }
2375 /* the ',' command */
2376 int
2378 {
2382 /* awful kludge to work around parse()'s pre-decrement */
2385 /* uswallow case added by GAN 01/29/87 */
2398 }
2399 }
2409 }
2410 }
2419 }
2420 }
2434 else
2437 }
2445 else
2448 }
2451 }
2453 /* stop running if we see something interesting */
2454 /* turn around a corner if that is the only way we can proceed */
2455 /* do not turn left or right twice */
2456 void
2458 {
2465 /* Grid bugs stop if trying to move diagonal, even if blind. Maybe */
2466 /* they polymorphed while in the middle of a long move. */
2470 }
2489 }
2506 bcorr:
2520 }
2521 }
2522 corrct++;
2523 }
2532 /* water and lava only stop you if directly in front, and stop
2533 * you even if you are running
2534 */
2537 /* No Wwalking check; otherwise they'd be able
2538 * to test boots by trying to SHIFT-direction
2539 * into a pool and seeing if the game allowed it
2540 */
2553 }
2554 stop:
2563 /* make sure that we do not turn too far */
2567 else
2572 else
2578 else
2580 }
2587 }
2588 }
2589 }
2591 /* check for a doorway which lacks its door (NODOOR or BROKEN) */
2592 STATIC_OVL boolean
2595 {
2600 /* all rogue level doors are doorless but disallow diagonal access, so
2601 we treat them as if their non-existant doors were actually present */
2605 }
2607 /* used by drown() to check whether hero can crawl from water to <x,y> */
2608 boolean
2611 {
2612 /* is location ok in general? */
2616 /* orthogonal movement is unrestricted when destination is ok */
2620 /* diagonal movement has some restrictions */
2625 /* pool could be next to a door, conceivably even inside a shop */
2628 /* finally, are we trying to squeeze through a too-narrow gap? */
2631 }
2633 /* something like lookaround, but we are not running */
2634 /* react only to monsters that might hit us */
2635 int
2637 {
2641 /* Also see the similar check in dochugw() in monmove.c */
2654 }
2656 }
2658 void
2661 {
2670 }
2672 /* called when a non-movement, multi-turn action has completed */
2673 void
2676 {
2690 }
2692 STATIC_OVL void
2694 {
2718 who);
2719 }
2723 }
2724 }
2726 void
2730 boolean k_format;
2731 {
2742 }
2747 else
2758 }
2759 }
2761 int
2763 {
2768 /* consistent with can_carry() in mon.c */
2777 }
2790 }
2793 }
2795 }
2799 /* returns how far beyond the normal capacity the player is currently. */
2800 /* inv_weight() is negative if the player is below normal capacity. */
2801 int
2803 {
2813 }
2816 }
2818 /*
2819 * Returns 0 if below normal capacity, or the number of "capacity units"
2820 * over the normal capacity the player is loaded. Max is 5.
2821 */
2822 int
2825 {
2834 }
2836 int
2838 {
2840 }
2842 int
2844 {
2848 }
2850 boolean
2853 {
2857 else
2860 }
2862 }
2864 int
2866 boolean incl_gold;
2867 {
2873 ct++;
2875 }
2877 }
2879 /* Counts the money in an object chain. */
2880 /* Intended use is for your or some monster's inventory, */
2881 /* now that u.gold/m.gold is gone.*/
2882 /* Counting money in a container might be possible too. */
2883 long
2886 {
2888 /* Must change when silver & copper is implemented: */
2892 }
2894 }
2896 /*hack.c*/