| blob | 1c7e44804809f298e977a7c0d618f816907c78ae |
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)
22 /* mode values for findtravelpath() */
23 #define TRAVP_TRAVEL 0
24 #define TRAVP_GUESS 1
25 #define TRAVP_VALID 2
29 anything *
32 {
36 }
38 anything *
41 {
45 }
47 anything *
50 {
54 }
56 anything *
59 {
63 }
65 boolean
69 {
72 coord cc;
80 /* move any living monster already at that location */
86 }
87 }
89 /* this location might not be safe, if not, move revived monster */
95 }
96 /* else impossible? */
97 }
100 }
102 STATIC_OVL int
104 {
112 /* make sure that this boulder is visible as the top object */
123 /* Give them a chance to climb over it? */
125 }
131 }
139 /* KMH -- Sokoban doesn't let you push boulders diagonally */
146 }
162 }
167 }
170 /* if a trap operates on the boulder, don't attempt
171 to move any others at this location; return -1
172 if another boulder is in hero's way, or 0 if he
173 should advance to the vacated boulder position */
184 /* if the boulder remains, it should fill the pit */
189 }
194 /* vision kludge to get messages right;
195 the pit will temporarily be seen even
196 if this is one among multiple boulders */
201 }
210 else
230 d_level dest;
235 /* trap didn't work; skip "disappears" message */
237 }
241 else
253 }
256 }
259 }
260 }
266 /*
267 * Re-link at top of fobj chain so that pile order is preserved
268 * when level is restored.
269 */
273 }
275 {
279 #else
280 /* note: reset to zero after save/restore cycle */
282 #endif
283 dopush:
295 }
297 /* Move the boulder *after* the message. */
306 }
308 nopushmsg:
312 else
316 cannot_push:
328 }
330 }
343 }
344 }
346 }
348 /*
349 * still_chewing()
350 *
351 * Chew on a wall, door, or boulder. Returns TRUE if still eating, FALSE
352 * when done.
353 */
354 STATIC_OVL int
357 {
383 /* solid rock takes more work & time to dig through */
390 boulder
405 boulder
417 }
419 /* Okay, you've chewed through something */
427 /*
428 * The location could still block because of
429 * 1. More than one boulder
430 * 2. Boulder stuck in a wall/stone/door.
431 *
432 * [perhaps use does_block() below (from vision.c)]
433 */
437 /* reset dig state */
441 }
447 }
456 }
470 }
477 }
484 }
489 }
500 }
502 void
506 {
507 /* optimize by leaving on the fobj chain? */
512 }
516 STATIC_OVL void
518 {
531 /* fake removal of levitation in advance so that final
532 disclosure will be right in case this turns out to
533 be fatal; fortunately the fact that rings and boots
534 are really still worn has no effect on bones data */
545 NO_KILLER_PREFIX);
547 }
550 }
552 /*
553 * Interrupt multi-turn putting on/taking off of armor (in which
554 * case we reached the sink due to being teleported while busy;
555 * in 3.4.3, Boots_on()/Boots_off() [called via (*aftermv)() when
556 * 'multi' reaches 0] triggered a crash if we were donning/doffing
557 * levitation boots [because the Boots_off() below causes 'uarmf'
558 * to be null by the time 'aftermv' gets called]).
559 *
560 * Interrupt donning/doffing if we fall onto the sink, or if the
561 * code below is going to remove levitation boots even when we
562 * haven't fallen (innate floating or flying becoming unblocked).
563 */
566 /* recalculate in case uarmf just got set to null */
568 }
570 /* remove worn levitation items */
573 HLevitation++;
578 }
583 }
588 }
589 HLevitation--;
590 /* probably moot; we're either still levitating or went
591 through float_down(), but make sure BFlying is up to date */
593 }
595 /* intended to be called only on ROCKs or TREEs */
596 boolean
599 {
604 }
606 boolean
609 {
612 }
614 boolean
618 {
624 }
626 /* caller has already decided that it's a tight diagonal; check whether a
627 monster--who might be the hero--can fit through, and if not then return
628 the reason why: 1: can't fit, 2: possessions won't fit, 3: sokoban
629 returns 0 if we can squeeze through */
630 int
633 {
637 /* too big? */
643 /* lugging too much junk? */
649 /* Sokoban restriction applies to hero only */
653 /* can squeeze through */
655 }
657 boolean
660 {
663 }
665 /* return TRUE if (dx,dy) is an OK place to move
666 * mode is one of DO_MOVE, TEST_MOVE, TEST_TRAV, or TEST_TRAP
667 */
668 boolean
672 {
679 /*
680 * Check for physical obstacles. First, the place we are going.
681 */
688 /* note: if water_friction() changes direction due to
689 turbulence, new target destination will always be water,
690 so we won't get here, hence don't need to worry about
691 "there" being somewhere the player isn't sure of */
700 }
705 }
707 /* Eat the rock. */
712 /* MRKR: Automatic digging when wielding the appropriate tool */
720 /* sokoban restriction stays even after puzzle is solved */
728 }
730 }
745 /* Eat the door. */
766 }
769 }
773 }
775 testdiag:
778 /* Diagonal moves into a door are not allowed. */
784 }
786 }
787 }
788 }
791 /* Move at a diagonal. */
807 }
809 /* consecutive long worm segments are at <ux,y> and <x,uy> */
813 }
814 /* Pick travel path that does not require crossing a trap.
815 * Avoid water and lava using the usual running rules.
816 * (but not u.ux/u.uy because findtravelpath walks toward u.ux/u.uy) */
825 }
832 /* Now see if other things block our way . . */
835 /* Can't move at a diagonal out of a doorway with door. */
839 }
846 /* tunneling monsters will chew before pushing */
856 /* never travel through boulders in Sokoban */
860 /* don't pick two boulders in a row, unless there's a way thru */
868 }
869 }
870 /* assume you'll be able to push it when you get there... */
871 }
873 /* OK, it is a legal place to move. */
875 }
877 #ifdef DEBUG
880 /* in this case, toggle display of travel debug info */
882 {
885 }
888 /*
889 * Find a path from the destination (u.tx,u.ty) back to (u.ux,u.uy).
890 * A shortest path is returned. If guess is TRUE, consider various
891 * inaccessible locations as valid intermediate path points.
892 * Returns TRUE if a path was found.
893 */
894 STATIC_OVL boolean
897 {
898 /* if travel to adjacent, reachable location, use normal movement rules */
909 }
911 }
914 }
925 /* If guessing, first find an "obvious" goal location. The obvious
926 * goal is the position the player knows of, or might figure out
927 * (couldsee) that is closest to the target on a straight path.
928 */
939 }
941 noguess:
954 /* no diagonal movement for grid bugs */
962 /*
963 * When guessing and trying to travel as close as possible
964 * to an unreachable target space, don't include spaces
965 * that would never be picked as a guessed target in the
966 * travel matrix describing hero-reachable spaces.
967 * This stops travel from getting confused and moving
968 * the hero back and forth in certain degenerate
969 * configurations of sight-blocking obstacles, e.g.
970 *
971 * T 1. Dig this out and carry enough to not be
972 * #### able to squeeze through diagonal gaps.
973 * #--.--- Stand at @ and target travel at space T.
974 * @.....
975 * |.....
976 *
977 * T 2. couldsee() marks spaces marked a and x
978 * #### as eligible guess spaces to move the hero
979 * a--.--- towards. Space a is closest to T, so it
980 * @xxxxx gets chosen. Travel system moves @ right
981 * |xxxxx to travel to space a.
982 *
983 * T 3. couldsee() marks spaces marked b, c and x
984 * #### as eligible guess spaces to move the hero
985 * a--c--- towards. Since findtravelpath() is called
986 * b@xxxx repeatedly during travel, it doesn't
987 * |xxxxx remember that it wanted to go to space a,
988 * so in comparing spaces b and c, b is
989 * chosen, since it seems like the closest
990 * eligible space to T. Travel system moves @
991 * left to go to space b.
992 *
993 * 4. Go to 2.
994 *
995 * By limiting the travel matrix here, space a in the
996 * example above is never included in it, preventing
997 * the cycle.
998 */
1005 /* closed doors and boulders usually
1006 * cause a delay, so prefer another path */
1011 /* don't change travel matrix! */
1012 nn++;
1014 }
1016 }
1017 }
1028 /* reset run so domove run checks work */
1031 }
1033 }
1038 nn++;
1039 }
1040 }
1041 }
1042 }
1044 #ifdef DEBUG
1046 /* Use of warning glyph is arbitrary. It stands out. */
1050 }
1055 }
1057 }
1062 radius++;
1063 }
1065 /* if guessing, find best location in travel matrix and go there */
1079 /* prefer non-zigzag path */
1083 }
1089 }
1090 }
1093 /* no guesses, just go in the general direction */
1099 }
1100 #ifdef DEBUG
1102 /* Use of warning glyph is arbitrary. It stands out. */
1111 }
1113 }
1123 }
1125 }
1127 found:
1132 }
1134 boolean
1137 {
1140 boolean ret;
1153 }
1155 /* try to escape being stuck in a trapped state by walking out of it;
1156 return true iff moving should continue to intended destination
1157 (all failures and most successful escapes leave hero at original spot) */
1158 STATIC_OVL boolean
1162 {
1163 boolean anchored;
1176 else
1178 }
1179 /* [why does diagonal movement give quickest escape?] */
1187 /* try to escape; position stays same regardless of success */
1195 }
1201 else
1203 }
1207 else
1209 }
1216 else
1218 }
1226 else
1229 }
1230 }
1237 coord cc;
1240 /* can move normally within radius 1 of buried ball */
1242 /* ugly hack: we need to issue some message here
1243 in case "you are chained to the buried ball"
1244 was the most recent message given, otherwise
1245 our next attempt to move out of tether range
1246 after this successful move would have its
1247 can't-do-that message suppressed by Norep */
1251 }
1252 }
1261 }
1265 culprit);
1266 else
1268 culprit);
1271 }
1276 else
1281 }
1287 }
1289 }
1291 boolean
1293 {
1301 }
1303 }
1305 void
1307 {
1313 boolean on_ice;
1325 }
1339 }
1359 }
1361 }
1363 /* check slippery ice */
1378 }
1379 }
1392 }
1397 }
1398 /* turbulence might alter your actual destination */
1404 }
1407 }
1411 }
1424 }
1425 }
1431 }
1435 /* perhaps it fled (or was teleported or ... ) */
1438 /* When polymorphed into a sticking monster,
1439 * u.ustuck means it's stuck to you, not you to it.
1440 */
1444 /* If holder is asleep or paralyzed:
1445 * 37.5% chance of getting away,
1446 * 12.5% chance of waking/releasing it;
1447 * otherwise:
1448 * 7.5% chance of getting away.
1449 * [strength ought to be a factor]
1450 * If holder is tame and there is no conflict,
1451 * guaranteed escape.
1452 */
1457 pull_free:
1463 /* it's free to move on next turn */
1466 }
1467 /*FALLTHRU*/
1474 }
1475 }
1476 }
1480 /* Don't attack if you're running, and can see it */
1481 /* It's fine to displace pets, though */
1482 /* We should never get here if forcefight */
1491 }
1492 }
1493 }
1501 /* attack monster */
1503 /* don't stop travel when displacing pets; if the
1504 displace fails for some reason, attack() in uhitm.c
1505 will stop travel rather than domove */
1508 /* only attack if we know it's there */
1509 /* or if we used the 'F' command to fight blindly */
1510 /* or if it hides_under, in which case we call attack() to print
1511 * the Wait! message.
1512 * This is different from ceiling hiders, who aren't handled in
1513 * attack().
1514 */
1516 /* If they used a 'm' command, trying to move onto a monster
1517 * prints the below message and wastes a turn. The exception is
1518 * if the monster is unseen and the player doesn't remember an
1519 * invisible monster--then, we fall through to attack() and
1520 * attack_check(), which still wastes a turn, but prints a
1521 * different message and makes the player remember the monster.
1522 */
1530 else
1533 }
1537 /* try to attack; note that it might evade */
1538 /* also, we don't attack tame when _safepet_ */
1541 }
1542 }
1550 else
1553 }
1556 }
1558 /* specifying 'F' with no monster wastes a turn */
1560 /* remembered an 'I' && didn't use a move command */
1570 /* if a statue is displayed at the target location,
1571 player is attempting to attack it [and boulder
1572 handling below is suitable for handling that] */
1577 /* force fight at boulder/statue or wall/door while wielding
1578 pick: start digging to break the boulder or wall */
1580 /* can we dig? */
1582 /* should we dig? */
1586 }
1587 }
1589 /* about to become known empty -- remove 'I' if present */
1599 /* Underwater, targetting non-water; the map just shows blank
1600 because you don't see remembered terrain while underwater;
1601 although the hero can attack an adjacent monster this way,
1602 assume he can't reach out far enough to distinguish terrain */
1607 /* glyph might indicate unseen terrain if hero is blind;
1608 unlike searching, this won't reveal what that terrain is
1609 (except for solid rock, where the glyph would otherwise
1610 yield ludicrous "dark part of a room") */
1617 /* note: 'solid' is misleadingly named and catches pools
1618 of water and lava as well as rock and walls */
1619 else
1630 }
1632 }
1636 }
1637 /* not attacking an animal, so we try to move */
1641 }
1649 }
1655 }
1657 }
1659 /* Move ball and chain. */
1665 /* Check regions entering/leaving */
1669 /* now move the hero */
1673 /* Move your steed, too */
1678 }
1680 /*
1681 * If safepet at destination then move the pet to the hero's
1682 * previous location using the same conditions as in attack().
1683 * there are special extenuating circumstances:
1684 * (1) if the pet dies then your god angers,
1685 * (2) if the pet gets trapped then your god may disapprove,
1686 * (3) if the pet was already trapped and you attempt to free it
1687 * not only do you encounter the trap but you may frighten your
1688 * pet causing it to go wild! moral: don't abuse this privilege.
1689 *
1690 * Ceiling-hiding pets are skipped by this section of code, to
1691 * be caught by the normal falling-monster code.
1692 */
1694 /* if trapped, there's a chance the pet goes wild */
1703 }
1704 }
1714 /* can't swap places with pet pinned in a pit by a boulder */
1717 /* can't swap places when pet can't move to your spot */
1723 /* can't swap places when pet won't fit thru the opening */
1729 /* save its current description in case of polymorph */
1738 pnambuf);
1740 /* check for displacing it into pools and traps */
1746 /* there's already been a trap message, reinforce it */
1751 /* drowned or died...
1752 * you killed your pet by direct action, so get experience
1753 * and possibly penalties;
1754 * we want the level gain message, if it happens, to occur
1755 * before the guilt message below
1756 */
1757 {
1758 /* minliquid() and mintrap() call mondead() rather than
1759 killed() so we duplicate some of the latter here */
1767 }
1768 /* That's no way to treat a pet! Your god gets angry.
1769 *
1770 * [This has always been pretty iffy. Why does your
1771 * patron deity care at all, let alone enough to get mad?]
1772 */
1777 }
1782 }
1783 }
1784 }
1792 }
1798 /*
1799 * Mimics (or whatever) become noticeable if they move and are
1800 * imitating something that doesn't move. We could extend this
1801 * to non-moving monsters...
1802 */
1811 /* Clean old position -- vision_recalc() will print our new one. */
1813 /* Since the hero has moved, adjust what can be seen/unseen. */
1816 }
1823 /* delay next move because of ball dragging */
1824 /* must come after we finished picking up, in spoteffects() */
1829 }
1832 /* display every step or every 7th step depending upon mode */
1843 }
1844 }
1845 }
1846 }
1848 /* combat increases metabolism */
1849 boolean
1851 {
1852 /* this used to be part of domove() when moving to a monster's
1853 position, but is now called by attack() so that it doesn't
1854 execute if you decline to attack a peaceful monster */
1865 }
1866 }
1868 }
1870 void
1872 {
1873 /* a special clue-msg when on the Invocation position */
1883 else
1891 }
1892 }
1894 /* moving onto different terrain;
1895 might be going into solid rock, inhibiting levitation or flight,
1896 or coming back out of such, reinstating levitation/flying */
1897 STATIC_OVL void
1899 {
1905 /* called from spoteffects(), skip float_down() */
1913 }
1914 /* the same terrain that blocks levitation also blocks flight */
1922 /* [minor bug: we don't know whether this is beginning flight or
1923 resuming it; that could be tracked so that this message could
1924 be adjusted to "resume flying", but isn't worth the effort...] */
1927 }
1928 }
1930 /* extracted from spoteffects; called by spoteffects to check for entering or
1931 leaving a pool of water/lava, and by moveloop to check for staying on one;
1932 returns true to skip rest of spoteffects */
1933 boolean
1936 {
1937 /* check for leaving water */
1946 else
1959 }
1967 }
1968 }
1969 }
1971 /* check for entering water or lava */
1976 /* floating or clinging steed keeps hero safe (is_flyer() test
1977 is redundant; it can't be true since Flying yielded false) */
1980 /* steed enters pool */
1982 /* dismount_steed() -> float_down() -> pickup()
1983 (float_down doesn't do autopickup on Air or Water) */
1986 /* even if we actually end up at same location, float_down()
1987 has already done spoteffect()'s trap and pickup actions */
1991 }
1992 /* not mounted */
1994 /* drown(),lava_effects() return true if hero changes
1995 location while surviving the problem */
2003 }
2004 }
2006 }
2008 void
2010 boolean pick;
2011 {
2021 /* prevent recursion from affecting the hero all over again
2022 [hero poly'd to iron golem enters water here, drown() inflicts
2023 damage that triggers rehumanize() which calls spoteffects()...] */
2025 /* except when reason is transformed terrain (ice -> water) */
2027 /* or transformed trap (land mine -> pit) */
2035 /* moving onto different terrain might cause Levitation to toggle */
2046 boolean pit;
2048 /* if levitation is due to time out at the end of this
2049 turn, allowing it to do so could give the perception
2050 that a trap here is being triggered twice, so adjust
2051 the timeout to prevent that */
2058 /* levitation has ended; we've already triggered
2059 any trap and [usually] performed autopickup */
2062 }
2063 }
2064 }
2065 /*
2066 * If not a pit, pickup before triggering trap.
2067 * If pit, trigger trap before pickup.
2068 */
2074 /*
2075 * dotrap on a fire trap calls melt_ice() which triggers
2076 * spoteffects() (again) which can trigger the same fire
2077 * trap (again). Use static spottrap to prevent that.
2078 * We track spottraptyp because some traps morph
2079 * (landmine to pit) and any new trap type
2080 * should get triggered.
2081 */
2088 }
2089 }
2092 }
2093 /* Warning alerts you to ice danger */
2099 };
2106 }
2114 ;
2130 }
2143 }
2145 }
2146 spotdone:
2150 }
2152 }
2154 /* returns first matching monster */
2159 {
2168 }
2170 }
2176 {
2182 #define goodtype(rno) \
2183 (!typewanted \
2184 || (typefound = rooms[rno - ROOMOFFSET].rtype) == typewanted \
2185 || (typewanted == SHOPBASE && typefound > SHOPBASE))
2200 }
2235 }
2237 }
2239 /* is (x,y) in a town? */
2240 boolean
2243 {
2251 /*
2252 * See if (x,y) is in a room with subrooms, if so, assume it's the
2253 * town. If there are no subrooms, the whole level is in town.
2254 */
2260 }
2261 }
2264 }
2266 STATIC_OVL void
2269 {
2281 }
2293 }
2294 }
2299 /* filter u.ushops0 -> u.ushops_left */
2304 }
2306 /* possibly deliver a one-time room entry message */
2307 void
2310 {
2322 /* Did we just enter a shop? */
2330 /* Did we just enter some other special room? */
2331 /* vault.c insists that a vault remain a VAULT,
2332 * and temples should remain TEMPLEs,
2333 * but everything else gives a message only the first time */
2370 else
2378 else
2384 }
2387 /*FALLTHRU*/
2392 }
2399 /* No more room of that type */
2422 }
2423 }
2430 }
2431 }
2432 }
2435 }
2437 /* the ',' command */
2438 int
2440 {
2444 /* awful kludge to work around parse()'s pre-decrement */
2447 /* uswallow case added by GAN 01/29/87 */
2460 }
2461 }
2471 }
2472 }
2481 }
2482 }
2496 else
2499 }
2507 else
2510 }
2513 }
2515 /* stop running if we see something interesting */
2516 /* turn around a corner if that is the only way we can proceed */
2517 /* do not turn left or right twice */
2518 void
2520 {
2527 /* Grid bugs stop if trying to move diagonal, even if blind. Maybe */
2528 /* they polymorphed while in the middle of a long move. */
2533 }
2554 }
2555 }
2572 }
2575 bcorr:
2589 }
2590 }
2591 corrct++;
2592 }
2602 }
2604 }
2607 /* water and lava only stop you if directly in front, and stop
2608 * you even if you are running
2609 */
2612 /* No Wwalking check; otherwise they'd be able
2613 * to test boots by trying to SHIFT-direction
2614 * into a pool and seeing if the game allowed it
2615 */
2620 }
2632 }
2633 stop:
2642 }
2645 /* make sure that we do not turn too far */
2649 else
2654 else
2660 else
2662 }
2669 }
2670 }
2671 }
2673 /* check for a doorway which lacks its door (NODOOR or BROKEN) */
2674 STATIC_OVL boolean
2677 {
2682 /* all rogue level doors are doorless but disallow diagonal access, so
2683 we treat them as if their non-existant doors were actually present */
2687 }
2689 /* used by drown() to check whether hero can crawl from water to <x,y> */
2690 boolean
2693 {
2694 /* is location ok in general? */
2698 /* orthogonal movement is unrestricted when destination is ok */
2702 /* diagonal movement has some restrictions */
2707 /* pool could be next to a door, conceivably even inside a shop */
2710 /* finally, are we trying to squeeze through a too-narrow gap? */
2713 }
2715 /* something like lookaround, but we are not running */
2716 /* react only to monsters that might hit us */
2717 int
2719 {
2723 /* Also see the similar check in dochugw() in monmove.c */
2736 }
2738 }
2740 void
2743 {
2752 }
2754 /* called when a non-movement, multi-turn action has completed */
2755 void
2758 {
2772 }
2774 STATIC_OVL void
2776 {
2800 who);
2801 }
2805 }
2806 }
2808 void
2812 boolean k_format;
2813 {
2824 }
2829 else
2840 }
2841 }
2843 int
2845 {
2850 /* consistent with can_carry() in mon.c */
2859 }
2872 }
2875 }
2877 }
2881 /* returns how far beyond the normal capacity the player is currently. */
2882 /* inv_weight() is negative if the player is below normal capacity. */
2883 int
2885 {
2895 }
2898 }
2900 /*
2901 * Returns 0 if below normal capacity, or the number of "capacity units"
2902 * over the normal capacity the player is loaded. Max is 5.
2903 */
2904 int
2907 {
2916 }
2918 int
2920 {
2922 }
2924 int
2926 {
2930 }
2932 boolean
2935 {
2939 else
2942 }
2944 }
2946 int
2948 boolean incl_gold;
2949 {
2955 ct++;
2957 }
2959 }
2961 /* Counts the money in an object chain. */
2962 /* Intended use is for your or some monster's inventory, */
2963 /* now that u.gold/m.gold is gone.*/
2964 /* Counting money in a container might be possible too. */
2965 long
2968 {
2970 /* Must change when silver & copper is implemented: */
2974 }
2976 }
2978 /*hack.c*/