![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chase.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / urogue|
Return to chase.c CVS log | Up to [contributed] / early-roguelike / urogue |
1.1 rubenllo 1: /*
2: chase.c - Code for one creature to chase another
3:
4: UltraRogue: The Ultimate Adventure in the Dungeons of Doom
5: Copyright (C) 1985, 1986, 1992, 1993, 1995 Herb Chong
6: All rights reserved.
7:
8: Based on "Advanced Rogue"
9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka
10: All rights reserved.
11:
12: Based on "Rogue: Exploring the Dungeons of Doom"
13: Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
14: All rights reserved.
15:
16: See the file LICENSE.TXT for full copyright and licensing information.
17: */
18:
19: #include <stdlib.h>
20: #include <ctype.h>
21: #include <limits.h>
22: #include "rogue.h"
23:
24: /*
25: do_chase()
26: Make one thing chase another.
27: */
28:
29: void
30: do_chase(struct thing *th, int flee)
31: {
32: struct room *rer; /* room of chaser */
33: struct room *ree; /* room of chasee */
34: struct room *old_room; /* old room of monster */
35: struct room *new_room; /* new room of monster */
36:
37: int i, mindist = INT_MAX, maxdist = INT_MIN, dist = INT_MIN;
38:
39: int last_door = -1; /* Door we just came from */
40: int stoprun = FALSE; /* TRUE means we are there */
41: int rundoor; /* TRUE means run to a door */
42: int hit_bad = FALSE; /* TRUE means hit bad monster */
43: int mon_attack; /* TRUE means find a monster to hit */
44:
45: char sch;
46: struct linked_list *item;
47: coord this; /* Temporary destination for chaser */
48:
49: if (!th->t_ischasing)
50: return;
51:
52: /* Make sure the monster can move */
53:
54: if (th->t_no_move != 0)
55: {
56: th->t_no_move--;
57: return;
58: }
59:
60: /*
61: * Bad monsters check for a good monster to hit, friendly monsters
62: * check for a bad monster to hit.
63: */
64:
65: mon_attack = FALSE;
66:
67: if (good_monster(*th))
68: {
69: hit_bad = TRUE;
70: mon_attack = TRUE;
71: }
72: else if (on(*th, ISMEAN))
73: {
74: hit_bad = FALSE;
75: mon_attack = TRUE;
76: }
77:
78: if (mon_attack)
79: {
80: struct linked_list *mon_to_hit;
81:
82: mon_to_hit = f_mons_a(th->t_pos.y, th->t_pos.x, hit_bad);
83:
84: if (mon_to_hit)
85: {
86: mon_mon_attack(th, mon_to_hit, pick_weap(th), NOTHROWN);
87: return;
88: }
89: }
90:
91: /* no nearby monster to hit */
92:
93: rer = roomin(th->t_pos); /* Find room of chaser */
94: ree = roomin(th->t_chasee->t_pos); /* Find room of chasee */
95:
96: /*
97: * We don't count doors as inside rooms for this routine
98: */
99:
100: if (mvwinch(stdscr, th->t_pos.y, th->t_pos.x) == DOOR)
101: rer = NULL;
102:
103: this = th->t_chasee->t_pos;
104:
105: /*
106: * If we are not in a corridor and not a phasing monster, then if we
107: * are running after the player, we run to a door if he is not in the
108: * same room. If we are fleeing, we run to a door if he IS in the
109: * same room. Note: We don't bother with doors in mazes. Phasing
110: * monsters don't need to look for doors. There are no doors in mazes
111: * and throne rooms.
112: */
113:
114: if (levtype != MAZELEV && levtype != THRONE && rer != NULL && off(*th, CANINWALL))
115: {
116: if (flee)
117: rundoor = (rer == ree);
118: else
119: rundoor = (rer != ree);
120: }
121: else
122: rundoor = FALSE;
123:
124: if (rundoor)
125: {
126: coord d_exit; /* A particular door */
127: int exity, exitx; /* Door's coordinates */
128:
129: if (th->t_doorgoal != -1)
130: { /* Do we already have the goal? */
131: this = rer->r_exit[th->t_doorgoal];
132: dist = 0; /* Indicate that we have our door */
133: }
134: else
135: for (i = 0; i < rer->r_nexits; i++)
136: { /* Loop through doors */
137: d_exit = rer->r_exit[i];
138: exity = d_exit.y;
139: exitx = d_exit.x;
140:
141: /* Avoid secret doors */
142: if (mvwinch(stdscr, exity, exitx) == DOOR)
143: {
144: /* Were we just on this door? */
145: if (ce(d_exit, th->t_oldpos))
146: last_door = i;
147: else
148: {
149: dist = DISTANCE(th->t_chasee->t_pos, d_exit);
150:
151: /*
152: * If fleeing, we want to
153: * maximize distance from
154: * door to what we flee, and
155: * minimize distance from
156: * door to us.
157: */
158:
159: if (flee)
160: dist-=DISTANCE(th->t_pos,d_exit);
161:
162: /*
163: * Maximize distance if
164: * fleeing, otherwise
165: * minimize it
166: */
167:
168: if ((flee && (dist > maxdist)) ||
169: (!flee && (dist < mindist)))
170: {
171: th->t_doorgoal = i; /* Use this door */
172: this = d_exit;
173: mindist = maxdist = dist;
174: }
175: }
176: }
177: }
178:
179: /* Could we not find a door? */
180: if (dist == INT_MIN)
181: {
182: /* If we were on a door, go ahead and use it */
183: if (last_door != -1)
184: {
185: th->t_doorgoal = last_door;
186: this = th->t_oldpos;
187: dist = 0; /* Indicate that we found a door */
188: }
189: }
190:
191: /* Indicate that we do not want to flee from the door */
192: if (dist != INT_MIN)
193: flee = FALSE;
194: }
195: else
196: th->t_doorgoal = -1; /* Not going to any door */
197:
198: /*
199: * this now contains what we want to run to this time so we run to
200: * it. If we hit it we either want to fight it or stop running
201: */
202:
203: if (!chase(th, &this, flee))
204: {
205: if (ce(th->t_nxtpos, hero))
206: {
207: /* merchants try to sell something */
208:
209: if (on(*th, CANSELL))
210: {
211: sell(th);
212: return;
213: }
214: else if (off(*th, ISFRIENDLY) && off(*th, ISCHARMED)
215: && (off(*th, CANFLY) || (on(*th, CANFLY) && rnd(2))))
216: attack(th, pick_weap(th), FALSE);
217: return;
218: }
219: else if (on(*th, NOMOVE))
220: stoprun = TRUE;
221: }
222:
223: if (!curr_mons)
224: return; /* Did monster get itself killed? */
225:
226: if (on(*th, NOMOVE))
227: return;
228:
229: /* If we have a scavenger, it can pick something up */
230:
231: if ((item = find_obj(th->t_nxtpos.y, th->t_nxtpos.x)) != NULL)
232: {
233: struct linked_list *node, *top = item;
234: struct object *obt;
235:
236: while(top)
237: {
238: /* grab all objects that qualify */
239:
240: struct object *obj = OBJPTR(item);
241:
242: obt = OBJPTR(top);
243: node = obt->next_obj;
244:
245: if (on(*th, ISSCAVENGE) ||
246: ((on(*th, CANWIELD) || on(*th, CANSHOOT)) &&
247: (obj->o_type == WEAPON || obj->o_type == ARMOR)) ||
248: (on(*th, CANCAST) && is_magic(obj)))
249: {
250: rem_obj(top, FALSE);
251: attach(th->t_pack, top);
252: }
253:
254: top = node;
255: }
256:
257: light(&hero);
258: }
259:
260: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
261: sch = CCHAR( mvwinch(cw, th->t_nxtpos.y, th->t_nxtpos.x) );
262:
263: /* Get old and new room of monster */
264: old_room = roomin(th->t_pos);
265: new_room = roomin(th->t_nxtpos);
266:
267: /* If the monster can illuminate rooms, check for a change */
268: if (on(*th, HASFIRE))
269: {
270: /* Is monster entering a room? */
271: if (old_room != new_room && new_room != NULL)
272: {
273: new_room->r_flags |= HASFIRE;
274: new_room->r_fires++;
275: if (cansee(th->t_nxtpos.y, th->t_nxtpos.x) && new_room->r_fires==1)
276: light(&hero);
277: }
278:
279: /* Is monster leaving a room? */
280: if (old_room != new_room && old_room != NULL)
281: {
282: if (--(old_room->r_fires) <= 0)
283: {
284: old_room->r_flags &= ~HASFIRE;
285: if (cansee(th->t_pos.y, th->t_pos.x))
286: light(&th->t_pos);
287: }
288: }
289: }
290:
291: /*
292: * If monster is entering player's room and player can see it, stop
293: * the player's running.
294: */
295:
296: if (new_room != old_room && new_room != NULL &&
297: new_room == ree && cansee(th->t_nxtpos.y, th->t_nxtpos.x) &&
298: (off(*th, ISINVIS) || (off(*th, ISSHADOW) || rnd(10) == 0) ||
299: on(player, CANSEE)) && off(*th, CANSURPRISE))
300: running = FALSE;
301:
302: if (rer != NULL && (rer->r_flags & ISDARK) &&
303: !(rer->r_flags & HASFIRE) && sch == FLOOR &&
304: DISTANCE(th->t_nxtpos, th->t_pos) < see_dist &&
305: off(player, ISBLIND))
306: th->t_oldch = ' ';
307: else
308: th->t_oldch = sch;
309:
310: if (cansee(th->t_nxtpos.y, th->t_nxtpos.x) &&
311: off(*th, ISINWALL) &&
312: ((off(*th, ISINVIS) && (off(*th, ISSHADOW) || rnd(100) < 10)) ||
313: on(player, CANSEE)) &&
314: off(*th, CANSURPRISE))
315: mvwaddch(cw, th->t_nxtpos.y, th->t_nxtpos.x, th->t_type);
316:
317: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
318: mvwaddch(mw, th->t_nxtpos.y, th->t_nxtpos.x, th->t_type);
319:
320: /* Record monster's last position (if new one is different) */
321:
322: if (!ce(th->t_nxtpos, th->t_pos))
323: th->t_oldpos = th->t_pos;
324:
325: th->t_pos = th->t_nxtpos; /* Mark the monster's new position */
326:
327: /* If the monster is on a trap, trap it */
328:
329: sch = CCHAR(mvinch(th->t_nxtpos.y, th->t_nxtpos.x));
330:
331: if (isatrap(sch))
332: {
333: debug("Monster trapped by %c.", sch);
334:
335: if (cansee(th->t_nxtpos.y, th->t_nxtpos.x))
336: th->t_oldch = sch;
337:
338: be_trapped(th, th->t_nxtpos);
339: }
340:
341: /* And stop running if need be */
342:
343: if (stoprun && ce(th->t_pos, th->t_chasee->t_pos))
344: {
345: th->t_ischasing = FALSE;
346: turn_off(*th, ISRUN);
347: }
348: }
349:
350: /*
351: chase_it()
352: Set a monster running after something or stop it from running (for
353: when it dies)
354: */
355:
356: void
357: chase_it(coord *runner, struct thing *th)
358: {
359: struct linked_list *item;
360: struct thing *tp;
361:
362: /* If we couldn't find him, something is funny */
363:
364: if ((item = find_mons(runner->y, runner->x)) == NULL)
365: {
366: debug("CHASER '%s'", unctrl(winat(runner->y, runner->x)));
367: return;
368: }
369:
370: tp = THINGPTR(item);
371:
372: /* Start the beastie running */
373:
374: tp->t_ischasing = TRUE;
375: tp->t_chasee = th;
376:
377: turn_on(*tp, ISRUN);
378: turn_off(*tp, ISDISGUISE);
379:
380: return;
381: }
382:
383: /*
384: chase()
385: Find the spot for the chaser(er) to move closer to the chasee(ee).
386: Returns TRUE if we want to keep on chasing later, FALSE if we reach the
387: goal.
388: */
389:
390: int
391: chase(struct thing *tp, coord *ee, int flee)
392: {
393: int x, y;
394: int dist, thisdist, monst_dist = INT_MAX;
395: struct linked_list *weapon;
396: coord *er = &tp->t_pos;
397: coord shoot;
398: coord *shootit_dir = NULL;
399: int ch;
400: char mch;
401: int next_player = FALSE;
402:
403: /* Take care of shooting directions */
404:
405: if (on(*tp, CANBREATHE) || on(*tp, CANSHOOT) || on(*tp, CANCAST))
406: {
407: if (good_monster(*tp))
408: {
409: shootit_dir = find_shoot(tp, &shoot); /* find a mean monster */
410:
411: if (wizard && shootit_dir)
412: msg("Found monster to attack towards (%d,%d).",
413: shootit_dir->x, shootit_dir->y);
414: }
415: else
416: shootit_dir = can_shoot(er, ee, &shoot); /* shoot hero */
417: }
418:
419: /*
420: * If the thing is confused, let it move randomly. Some monsters are
421: * slightly confused all of the time.
422: */
423:
424: if ((on(*tp, ISHUH) && rnd(10) < 8) ||
425: ((on(*tp, ISINVIS) || on(*tp, ISSHADOW)) && rnd(100) < 20) ||
426: (on(player, ISINVIS) && off(*tp, CANSEE)))
427: { /* Player is invisible */
428:
429: /* get a valid random move */
430:
431: tp->t_nxtpos = rndmove(tp);
432:
433: dist = DISTANCE(tp->t_nxtpos, *ee);
434:
435: if (on(*tp, ISHUH) && rnd(20) == 0) /* monster might lose confusion */
436: turn_off(*tp, ISHUH);
437:
438: /*
439: * check to see if random move takes creature away from
440: * player if it does then turn off ISHELD
441: */
442:
443: if (dist > 1 && on(*tp, DIDHOLD))
444: {
445: turn_off(*tp, DIDHOLD);
446: turn_on(*tp, CANHOLD);
447:
448: if (--hold_count == 0)
449: turn_off(player, ISHELD);
450: }
451: } /* If we can breathe, we may do so */
452: else if (on(*tp, CANBREATHE) && (shootit_dir) && (rnd(100) < 67) &&
453: (off(player, ISDISGUISE) || (rnd(tp->t_stats.s_lvl) > 6)) &&
454: (DISTANCE(*er, *ee) < BOLT_LENGTH * BOLT_LENGTH))
455: {
456: int chance;
457: char *breath;
458:
459: /* Will it breathe at random */
460:
461: if (on(*tp, CANBRANDOM))
462: {
463: if (rnd(level / 20) == 0 && tp->t_index != nummonst + 1
464: && !(good_monster(*tp)))
465: turn_off(*tp, CANBRANDOM);
466:
467: /* Select type of breath */
468:
469: chance = rnd(100);
470:
471: if (chance < 11)
472: breath = "acid";
473: else if (chance < 22)
474: breath = "flame";
475: else if (chance < 33)
476: breath = "lightning bolt";
477: else if (chance < 44)
478: breath = "chlorine gas";
479: else if (chance < 55)
480: breath = "ice";
481: else if (chance < 66)
482: breath = "nerve gas";
483: else if (chance < 77)
484: breath = "sleeping gas";
485: else if (chance < 88)
486: breath = "slow gas";
487: else
488: breath = "fear gas";
489: } /* Or can it breathe acid? */
490: else if (on(*tp, CANBACID))
491: {
492: if (!good_monster(*tp) && rnd(level / 15) == 0)
493: turn_off(*tp, CANBACID);
494:
495: breath = "acid";
496: } /* Or can it breathe fire */
497: else if (on(*tp, CANBFIRE))
498: {
499: if (!good_monster(*tp) && rnd(level / 15) == 0)
500: turn_off(*tp, CANBFIRE);
501:
502: breath = "flame";
503: } /* Or can it breathe electricity? */
504: else if (on(*tp, CANBBOLT))
505: {
506: if (!good_monster(*tp) && rnd(level / 15) == 0)
507: turn_off(*tp, CANBBOLT);
508:
509: breath = "lightning bolt";
510: } /* Or can it breathe gas? */
511: else if (on(*tp, CANBGAS))
512: {
513: if (!good_monster(*tp) && rnd(level / 15) == 0)
514: turn_off(*tp, CANBGAS);
515:
516: breath = "chlorine gas";
517: } /* Or can it breathe ice? */
518: else if (on(*tp, CANBICE))
519: {
520: if (!good_monster(*tp) && rnd(level / 15) == 0)
521: turn_off(*tp, CANBICE);
522:
523: breath = "ice";
524: }
525: else if (on(*tp, CANBPGAS))
526: {
527: if (!good_monster(*tp) && rnd(level / 15) == 0)
528: turn_off(*tp, CANBPGAS);
529:
530: breath = "nerve gas";
531: }
532: else if (on(*tp, CANBSGAS))
533: {
534: if (!good_monster(*tp) && rnd(level / 15) == 0)
535: turn_off(*tp, CANBSGAS);
536:
537: breath = "sleeping gas";
538: }
539: else if (on(*tp, CANBSLGAS))
540: {
541: if (!good_monster(*tp) && rnd(level / 15) == 0)
542: turn_off(*tp, CANBSLGAS);
543:
544: breath = "slow gas";
545: }
546: else
547: {
548: if (!good_monster(*tp) && rnd(level / 15) == 0)
549: turn_off(*tp, CANBFGAS);
550:
551: breath = "fear gas";
552: }
553:
554: shoot_bolt(tp, *er, *shootit_dir, (tp == THINGPTR(fam_ptr)),
555: tp->t_index, breath, roll(tp->t_stats.s_lvl, 6));
556:
557: tp->t_nxtpos = *er;
558:
559: dist = DISTANCE(tp->t_nxtpos, *ee);
560:
561: if (!curr_mons)
562: return (TRUE);
563: }
564: else if (shootit_dir && on(*tp, CANCAST) &&
565: (off(player, ISDISGUISE) || (rnd(tp->t_stats.s_lvl) > 6)))
566: {
567: /*
568: If we can cast spells we might do so - even if adjacent fleeing
569: monsters are restricted to certain spells
570: */
571:
572: incant(tp, *shootit_dir);
573: tp->t_nxtpos = *er;
574: dist = DISTANCE(tp->t_nxtpos, *ee);
575: }
576: else if (shootit_dir && on(*tp, CANSHOOT))
577: {
578: weapon = get_hurl(tp);
579:
580: if (weapon &&
581: (off(*tp, ISFLEE) || rnd(DISTANCE(*er, *ee)) > 2) &&
582: (off(player, ISDISGUISE) || (rnd(tp->t_stats.s_lvl) > 6)))
583: {
584: /*
585: Should we shoot or throw something? fleeing monsters
586: may to shoot anyway if far enough away
587: */
588:
589: missile(shootit_dir->y, shootit_dir->x, weapon, tp);
590: tp->t_nxtpos = *er;
591: dist = DISTANCE(tp->t_nxtpos, *ee);
592: }
593: }
594: else
595: {
596: /*
597: Otherwise, find the empty spot next to the chaser that is closest
598: to the chasee.
599: */
600: int ey, ex;
601: struct room *rer, *ree;
602: int dist_to_old = INT_MIN; /* Dist from goal to old position */
603:
604: /* Get rooms */
605: rer = roomin(*er);
606: ree = roomin(*ee);
607:
608: /*
609: * This will eventually hold where we move to get closer. If
610: * we can't find an empty spot, we stay where we are.
611: */
612:
613: dist = flee ? 0 : INT_MAX;
614: tp->t_nxtpos = *er;
615:
616: /* Are we at our goal already? */
617:
618: if (!flee && ce(tp->t_nxtpos, *ee))
619: return (FALSE);
620:
621: ey = er->y + 1;
622: ex = er->x + 1;
623:
624: for (x = er->x - 1; x <= ex; x++)
625: for (y = er->y - 1; y <= ey; y++)
626: {
627: coord tryp; /* test position */
628:
629: /* Don't try off the screen */
630:
631: if ((x < 0) || (x >= COLS) || (y < 1) || (y >= LINES - 2))
632: continue;
633:
634: /*
635: * Don't try the player if not going after
636: * the player or he's disguised and monster is dumb
637: */
638:
639: if (((off(*tp, ISFLEE) && !ce(hero, *ee)) ||
640: (on(player, ISDISGUISE) && (rnd(tp->t_stats.s_lvl) < 6))
641: || good_monster(*tp))
642: && x == hero.x && y == hero.y)
643: continue;
644:
645: tryp.x = x;
646: tryp.y = y;
647:
648: /*
649: * Is there a monster on this spot closer to
650: * our goal? Don't look in our spot or where
651: * we were.
652: */
653:
654: if (!ce(tryp, *er) && !ce(tryp, tp->t_oldpos) &&
655: isalpha( (mch = CCHAR(mvwinch(mw, y, x))) ) )
656: {
657: int test_dist;
658:
659: test_dist = DISTANCE(tryp,*ee);
660: if (test_dist <= 25 && /* Let's be fairly close */
661: test_dist < monst_dist)
662: {
663:
664: /* Could we really move there? */
665:
666: mvwaddch(mw, y, x, ' '); /* Temp blank monst */
667:
668: if (diag_ok(er, &tryp, tp))
669: monst_dist = test_dist;
670:
671: mvwaddch(mw, y, x, mch); /* Restore monster */
672: }
673: }
674:
675: if (!diag_ok(er, &tryp, tp))
676: continue;
677:
678: ch = mvwinch(cw, y, x); /* Screen character */
679:
680: /*
681: * Stepping on player is NOT okay if we are
682: * fleeing
683: */
684:
685: if (on(*tp, ISFLEE) && (ch == PLAYER))
686: next_player = TRUE;
687:
688: if (step_ok(y, x, NOMONST, tp) &&
689: (off(*tp, ISFLEE) || ch != PLAYER))
690: {
691:
692: /*
693: * If it is a trap, an intelligent
694: * monster may not step on it (unless
695: * our hero is on top!)
696: */
697:
698: if (isatrap(ch))
699: {
700: if (!(ch == RUSTTRAP) &&
701: !(ch == FIRETRAP && on(*tp, NOFIRE)) &&
702: rnd(10) < tp->t_stats.s_intel &&
703: (y != hero.y || x != hero.x))
704: continue;
705: }
706:
707: /*
708: * OK -- this place counts
709: */
710:
711: thisdist = DISTANCE(tryp, *ee);
712:
713: /*
714: * Adjust distance if we are being
715: * shot at to moving out of line of sight.
716: */
717:
718: if (tp->t_wasshot && tp->t_stats.s_intel > 5 &&
719: ce(hero, *ee))
720: {
721: /* Move out of line of sight */
722: if (straight_shot(tryp.y, tryp.x, ee->y, ee->x, NULL))
723: {
724: if (flee)
725: thisdist -= SHOTPENALTY;
726: else
727: thisdist += SHOTPENALTY;
728: }
729:
730: /*
731: * But do we want to leave
732: * the room?
733: */
734: else if (rer && rer == ree && ch == DOOR)
735: thisdist += DOORPENALTY;
736: }
737:
738: /*
739: * Don't move to the last position if
740: * we can help it
741: */
742:
743: if (ce(tryp, tp->t_oldpos))
744: dist_to_old = thisdist;
745: else if ((flee && (thisdist > dist)) ||
746: (!flee && (thisdist < dist)))
747: {
748: tp->t_nxtpos = tryp;
749: dist = thisdist;
750: }
751: }
752: }
753:
754: /*
755: * If we are running from the player and he is in our way, go
756: * ahead and slug him.
757: */
758:
759: if (next_player && DISTANCE(*er,*ee) < dist &&
760: step_ok(tp->t_chasee->t_pos.y, tp->t_chasee->t_pos.x, NOMONST, tp))
761: {
762: tp->t_nxtpos = tp->t_chasee->t_pos; /* Okay to hit player */
763: return(FALSE);
764: }
765:
766:
767: /*
768: * If we can't get closer to the player (if that's our goal)
769: * because other monsters are in the way, just stay put
770: */
771:
772: if (!flee && ce(hero, *ee) && monst_dist < INT_MAX &&
773: DISTANCE(*er, hero) < dist)
774: tp->t_nxtpos = *er;
775:
776: /* Do we want to go back to the last position? */
777: else if (dist_to_old != INT_MIN && /* It is possible to move back */
778: ((flee && dist == 0) || /* No other possible moves */
779: (!flee && dist == INT_MAX)))
780: {
781: /* Do we move back or just stay put (default)? */
782:
783: dist = DISTANCE(*er,*ee); /* Current distance */
784:
785: if (!flee || (flee && (dist_to_old > dist)))
786: tp->t_nxtpos = tp->t_oldpos;
787: }
788: }
789:
790: /* Make sure we have the real distance now */
791: dist = DISTANCE(tp->t_nxtpos, *ee);
792:
793: /* Mark monsters in a wall */
794:
795: switch(mvinch(tp->t_nxtpos.y, tp->t_nxtpos.x))
796: {
797: case WALL:
798: case '-':
799: case '|':
800: turn_on(*tp, ISINWALL);
801: break;
802: default:
803: turn_off(*tp, ISINWALL);
804: }
805:
806: if (off(*tp, ISFLEE) &&
807: !(!SAME_POS((tp->t_chasee->t_pos),hero) || off(player, ISINWALL) || on(*tp, CANINWALL)))
808: return(dist != 0);
809: else /* May actually hit here from a confused move */
810: return(!ce(tp->t_nxtpos, hero));
811: }
812:
813: /*
814: roomin(coord *cp)
815:
816: Find what room some coordinates are in.
817: NULL means they aren't in any room.
818: */
819:
820: struct room *
821: roomin(coord cp)
822: {
823: struct room *rp;
824: int i;
825:
826: for (i = 0; i < MAXROOMS; i++)
827: {
828: rp = &rooms[i];
829:
830: if ((cp.x <= (rp->r_pos.x + (rp->r_max.x - 1))) &&
831: (cp.y <= (rp->r_pos.y + (rp->r_max.y - 1))) &&
832: (cp.x >= rp->r_pos.x) &&
833: (cp.y >= rp->r_pos.y))
834: {
835: return(rp);
836: }
837: }
838:
839: return(NULL);
840: }
841:
842: /*
843: * find_mons: Find the monster from his corrdinates
844: */
845:
846: struct linked_list *
847: find_mons(int y, int x)
848: {
849: struct linked_list *item;
850:
851: for (item = mlist; item != NULL; item = next(item))
852: {
853: struct thing *th = THINGPTR(item);
854:
855: if (th->t_pos.y == y && th->t_pos.x == x)
856: return item;
857: }
858: return NULL;
859: }
860:
861: /*
862: * Find an unfriendly monster around us to hit
863: */
864:
865: struct linked_list *
866: f_mons_a(int y, int x, int hit_bad)
867: {
868: int row, col;
869: struct linked_list *item;
870: struct thing *tp;
871:
872: for (row = x - 1; row <= x + 1; row++)
873: for (col = y - 1; col <= y + 1; col++)
874: if (row == x && col == y)
875: continue;
876: else if (col > 0 && row > 0 &&
877: isalpha(mvwinch(mw, col, row)) &&
878: ((item = find_mons(col, row)) != NULL))
879: {
880: tp = THINGPTR(item);
881: if ((good_monster(*tp) && !hit_bad) ||
882: (!good_monster(*tp) && hit_bad))
883: return (item);
884: }
885:
886: return (NULL);
887: }
888:
889:
890: /*
891: diag_ok()
892: Check to see if the move is legal if it is diagonal
893: */
894:
895: int
896: diag_ok(coord *sp, coord *ep, struct thing *flgptr)
897: {
898: if (ep->x == sp->x || ep->y == sp->y)
899: return TRUE;
900:
901: return (step_ok(ep->y, sp->x, MONSTOK, flgptr) &&
902: step_ok(sp->y, ep->x, MONSTOK, flgptr));
903: }
904:
905: /*
906: cansee()
907: returns true if the hero can see a certain coordinate.
908: */
909:
910: int
911: cansee(int y, int x)
912: {
913: struct room *rer;
914: coord tp;
915:
916: if (on(player, ISBLIND))
917: return FALSE;
918:
919: tp.y = y;
920: tp.x = x;
921: rer = roomin(tp);
922:
923: /*
924: * We can only see if the hero in the same room as the coordinate and
925: * the room is lit or if it is close.
926: */
927:
928: return ((rer != NULL &&
929: rer == roomin(hero) &&
930: (!(rer->r_flags & ISDARK) || (rer->r_flags & HASFIRE)) &&
931: (levtype != MAZELEV || /* Maze level needs direct line */
932: maze_view(tp.y, tp.x))) ||
933: DISTANCE(tp,hero) < see_dist);
934: }
935:
936: coord *
937: find_shoot(struct thing *tp, coord *dir)
938: {
939: struct room *rtp;
940: int ulx, uly, xmx, ymx, xmon, ymon, tpx, tpy, row, col;
941: struct linked_list *mon;
942: struct thing *ick;
943:
944: rtp = roomin(tp->t_pos); /* Find room of chaser */
945:
946: if (rtp == NULL)
947: return NULL;
948:
949: ulx = rtp->r_pos.x;
950: uly = rtp->r_pos.y;
951: xmx = rtp->r_max.x;
952: ymx = rtp->r_max.y;
953:
954: tpx = tp->t_pos.x;
955: tpy = tp->t_pos.y;
956:
957: for (col = ulx; col < (ulx + xmx); col++)
958: for (row = uly; row < (uly + ymx); row++)
959: {
960: if (row > 0 && col > 0 && isalpha(mvwinch(mw, row, col)))
961: {
962: mon = find_mons(row, col);
963:
964: if (mon)
965: {
966: ick = THINGPTR(mon);
967: xmon = ick->t_pos.x;
968: ymon = ick->t_pos.y;
969:
970: if (!(good_monster(*ick)))
971: {
972: if (straight_shot(tpy, tpx, ymon, xmon, dir))
973: return(dir);
974: }
975: }
976: }
977: }
978:
979: return(NULL);
980: }
981:
982: /*
983: can_shoot()
984: determines if the monster (er) has a direct line of shot at the
985: player (ee). If so, it returns the direction in which to shoot.
986: */
987:
988: coord *
989: can_shoot(coord *er, coord *ee, coord *dir)
990: {
991: int ery, erx, eey, eex;
992:
993: /* Make sure we are chasing the player */
994:
995: if (!ce((*ee), hero))
996: return(NULL);
997:
998: /* They must be in the same room */
999:
1000: if (roomin(*er) != roomin(hero))
1001: return(NULL);
1002:
1003: ery = er->y;
1004: erx = er->x;
1005: eey = ee->y;
1006: eex = ee->x;
1007:
1008: /* Will shoot unless next to player, then 80% prob will fight */
1009:
1010: if ((DISTANCE(*er,*ee) < 4) && (rnd(100) < 80))
1011: return(NULL);
1012:
1013: /* Do we have a straight shot? */
1014:
1015: if (!straight_shot(ery, erx, eey, eex, dir))
1016: return(NULL);
1017: else
1018: return(dir);
1019: }
1020:
1021: /*
1022: straight_shot()
1023: See if there is a straight line of sight between the two
1024: given coordinates. If shooting is not NULL, it is a pointer to a
1025: structure which should be filled with the direction to shoot (if
1026: there is a line of sight). If shooting, monsters get in the way.
1027: Otherwise, they do not.
1028: */
1029:
1030: int
1031: straight_shot(int ery, int erx, int eey, int eex, coord *dir)
1032: {
1033: int dy, dx; /* Deltas */
1034: int ch;
1035:
1036: /* Does the monster have a straight shot at player */
1037:
1038: if ((ery != eey) && (erx != eex) &&
1039: (abs(ery - eey) != abs(erx - eex)))
1040: return (FALSE);
1041:
1042: /* Get the direction to shoot */
1043:
1044: if (eey > ery)
1045: dy = 1;
1046: else if (eey == ery)
1047: dy = 0;
1048: else
1049: dy = -1;
1050:
1051: if (eex > erx)
1052: dx = 1;
1053: else if (eex == erx)
1054: dx = 0;
1055: else
1056: dx = -1;
1057:
1058: /* Make sure we have free area all the way to the player */
1059:
1060: ery += dy;
1061: erx += dx;
1062:
1063: while ((ery != eey) || (erx != eex))
1064: {
1065: switch(ch = winat(ery, erx))
1066: {
1067: case '|':
1068: case '-':
1069: case WALL:
1070: case DOOR:
1071: case SECRETDOOR:
1072: return(FALSE);
1073: default:
1074: if (dir && isalpha(ch))
1075: return(FALSE);
1076: }
1077:
1078: ery += dy;
1079: erx += dx;
1080: }
1081:
1082: if (dir)
1083: { /* If we are shooting -- put in the directions */
1084: dir->y = dy;
1085: dir->x = dx;
1086: }
1087:
1088: return(TRUE);
1089: }
1090:
1091: /*
1092: get_hurl
1093: returns the weapon that the monster will "throw" if it has one
1094: */
1095:
1096: struct linked_list *
1097: get_hurl(struct thing *tp)
1098: {
1099: struct linked_list *arrow, *bolt, *rock, *silverarrow, *fbbolt;
1100: struct linked_list *bullet, *firearrow, *dart, *dagger, *shuriken;
1101: struct linked_list *oil, *grenade;
1102:
1103: struct linked_list *pitem;
1104: int bow = FALSE, crossbow = FALSE, sling = FALSE, footbow = FALSE;
1105:
1106: /* Don't point to anything to begin with */
1107:
1108: arrow = bolt = rock = silverarrow = fbbolt = NULL;
1109: bullet = firearrow = dart = dagger = shuriken = NULL;
1110: oil = grenade = NULL;
1111:
1112: for (pitem = tp->t_pack; pitem != NULL; pitem = next(pitem))
1113: if ((OBJPTR(pitem))->o_type == WEAPON)
1114: switch ((OBJPTR(pitem))->o_which)
1115: {
1116: case BOW:bow = TRUE; break;
1117: case CROSSBOW:crossbow = TRUE; break;
1118: case SLING:sling = TRUE; break;
1119: case FOOTBOW:footbow = TRUE; break;
1120: case ROCK:rock = pitem; break;
1121: case ARROW:arrow = pitem; break;
1122: case SILVERARROW:silverarrow = pitem; break;
1123: case BOLT:bolt = pitem; break;
1124: case FBBOLT:fbbolt = pitem; break;
1125: case BULLET:bullet = pitem; break;
1126: case FLAMEARROW:firearrow = pitem; break;
1127: case DART:dart = pitem; break;
1128: case DAGGER:dagger = pitem; break;
1129: case SHURIKEN:shuriken = pitem; break;
1130: case MOLOTOV:oil = pitem; break;
1131: case GRENADE:shuriken = pitem; break;
1132: }
1133:
1134: if (bow && silverarrow)
1135: return(silverarrow);
1136:
1137: if (crossbow && bolt)
1138: return(bolt);
1139:
1140: if (bow && firearrow)
1141: return(firearrow);
1142:
1143: if (off(*tp, ISCHARMED) && oil)
1144: return(oil);
1145:
1146: if (off(*tp, ISCHARMED) && grenade)
1147: return(grenade);
1148:
1149: if (footbow && fbbolt)
1150: return(fbbolt);
1151:
1152: if (bow && arrow)
1153: return(arrow);
1154:
1155: if (sling && bullet)
1156: return(bullet);
1157:
1158: if (sling && rock)
1159: return(rock);
1160:
1161: if (shuriken)
1162: return(shuriken);
1163:
1164: if (dagger)
1165: return(dagger);
1166:
1167: if (silverarrow)
1168: return(silverarrow);
1169:
1170: if (firearrow)
1171: return(firearrow);
1172:
1173: if (fbbolt)
1174: return(fbbolt);
1175:
1176: if (bolt)
1177: return(bolt);
1178:
1179: if (bullet)
1180: return(bullet);
1181:
1182: if (dart)
1183: return(dart);
1184:
1185: if (rock)
1186: return(rock);
1187:
1188: return(NULL);
1189: }
1190:
1191: /*
1192: pick_weap()
1193: returns the biggest weapon that the monster will wield if it
1194: has a non-launching or non-missile weapon returns NULL if no weapon, or
1195: bare hands is better
1196: */
1197:
1198: struct object *
1199: pick_weap(struct thing *tp)
1200: {
1201: int weap_dam = maxdamage(tp->t_stats.s_dmg);
1202: struct object *ret_obj = NULL;
1203: struct linked_list *pitem;
1204:
1205: if (on(*tp, CANWIELD))
1206: {
1207: for (pitem = tp->t_pack; pitem != NULL; pitem = next(pitem))
1208: {
1209: struct object *obj = OBJPTR(pitem);
1210:
1211: if (obj->o_type != WEAPON && !(obj->o_flags&(ISLAUNCHER|ISMISL)) &&
1212: maxdamage(obj->o_damage) > weap_dam)
1213: {
1214: weap_dam = maxdamage(obj->o_damage);
1215: ret_obj = obj;
1216: }
1217: }
1218: }
1219:
1220: return (ret_obj);
1221: }
1222:
1223: /*
1224: canblink()
1225: checks if the monster can teleport (blink). If so, it will try
1226: to blink the monster next to the player.
1227: */
1228:
1229: int
1230: can_blink(struct thing *tp)
1231: {
1232: int y, x, index = 9;
1233: coord tryp; /* To hold the coordinates for use in diag_ok */
1234: int spots[9], found_one = FALSE;
1235:
1236: /*
1237: * First, can the monster even blink? And if so, there is only a 30%
1238: * chance that it will do so. And it won't blink if it is running.
1239: */
1240:
1241: if (off(*tp, CANBLINK) || (on(*tp, ISHELD)) ||
1242: on(*tp, ISFLEE) ||
1243: (on(*tp, ISSLOW) && off(*tp, ISHASTE) && !(tp->t_turn)) ||
1244: (rnd(10) < 9))
1245: return (FALSE);
1246:
1247: /* Initialize the spots as illegal */
1248:
1249: do
1250: {
1251: spots[--index] = FALSE;
1252: }
1253: while (index > 0);
1254:
1255: /* Find a suitable spot next to the player */
1256:
1257: for (y = hero.y - 1; y < hero.y + 2; y++)
1258: for (x = hero.x - 1; x < hero.x + 2; x++, index++)
1259: {
1260: /*
1261: * Make sure x coordinate is in range and that we are
1262: * not at the player's position
1263: */
1264:
1265: if (x < 0 || x >= COLS || index == 4)
1266: continue;
1267:
1268: /* Is it OK to move there? */
1269:
1270: if (!step_ok(y, x, NOMONST, tp))
1271: spots[index] = FALSE;
1272: else
1273: {
1274:
1275: /*
1276: * OK, we can go here. But don't go there if
1277: * monster can't get at player from there
1278: */
1279:
1280: tryp.y = y;
1281: tryp.x = x;
1282: if (diag_ok(&tryp, &hero, tp))
1283: {
1284: spots[index] = TRUE;
1285: found_one = TRUE;
1286: }
1287: }
1288: }
1289:
1290: /* If we found one, go to it */
1291:
1292: if (found_one)
1293: {
1294: /* Find a legal spot */
1295:
1296: while (spots[index = rnd(9)] == FALSE)
1297: continue;
1298:
1299: /* Get the coordinates */
1300:
1301: y = hero.y + (index / 3) - 1;
1302: x = hero.x + (index % 3) - 1;
1303:
1304: /* Move the monster from the old space */
1305:
1306: mvwaddch(cw, tp->t_pos.y, tp->t_pos.x, tp->t_oldch);
1307:
1308: /* Move it to the new space */
1309:
1310: tp->t_oldch = CCHAR( mvwinch(cw, y, x) );
1311:
1312: if (cansee(y, x) &&
1313: off(*tp, ISINWALL) &&
1314: ((off(*tp, ISINVIS) &&
1315: (off(*tp, ISSHADOW) || rnd(100) < 10)) || on(player, CANSEE)) &&
1316: off(*tp, CANSURPRISE))
1317: mvwaddch(cw, y, x, tp->t_type);
1318:
1319: mvwaddch(mw, tp->t_pos.y,tp->t_pos.x,' '); /*Clear old position */
1320: mvwaddch(mw, y, x, tp->t_type);
1321: tp->t_pos.y = y;
1322: tp->t_pos.x = x;
1323: }
1324:
1325: return (found_one);
1326: }