![[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 / arogue5|
Return to chase.c CVS log | Up to [contributed] / early-roguelike / arogue5 |
1.1 rubenllo 1: /*
2: * Code for one object to chase another
3: *
4: * Advanced Rogue
5: * Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
6: * All rights reserved.
7: *
8: * Based on "Rogue: Exploring the Dungeons of Doom"
9: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
10: * All rights reserved.
11: *
12: * See the file LICENSE.TXT for full copyright and licensing information.
13: */
14:
15: #include <stdlib.h>
16: #include <ctype.h>
17: #include <limits.h>
18: #include "curses.h"
19: #include "rogue.h"
20: #define MAXINT INT_MAX
21: #define MININT INT_MIN
22:
23: coord ch_ret; /* Where chasing takes you */
24:
25: struct linked_list *get_hurl(struct thing *tp);
26: bool straight_shot(int ery, int erx, int eey, int eex, coord *shooting);
27:
28:
29: /*
30: * Canblink checks if the monster can teleport (blink). If so, it will
31: * try to blink the monster next to the player.
32: */
33:
34: bool
35: can_blink(struct thing *tp)
36: {
37: register int y, x, index=9;
38: coord tryp; /* To hold the coordinates for use in diag_ok */
39: bool spots[9], found_one=FALSE;
40:
41: /*
42: * First, can the monster even blink? And if so, there is only a 50%
43: * chance that it will do so. And it won't blink if it is running or
44: * held.
45: */
46: if (off(*tp, CANBLINK) || (on(*tp, ISHELD)) ||
47: on(*tp, ISFLEE) ||
48: (on(*tp, ISSLOW) && off(*tp, ISHASTE) && !(tp->t_turn)) ||
49: tp->t_no_move ||
50: (rnd(12) < 6)) return(FALSE);
51:
52:
53: /* Initialize the spots as illegal */
54: do {
55: spots[--index] = FALSE;
56: } while (index > 0);
57:
58: /* Find a suitable spot next to the player */
59: for (y=hero.y-1; y<hero.y+2; y++)
60: for (x=hero.x-1; x<hero.x+2; x++, index++) {
61: /* Make sure x coordinate is in range and that we are
62: * not at the player's position
63: */
64: if (x<0 || x >= COLS || index == 4) continue;
65:
66: /* Is it OK to move there? */
67: if (step_ok(y, x, NOMONST, tp) &&
68: (!isatrap(mvwinch(cw, y, x)) ||
69: rnd(10) >= tp->t_stats.s_intel ||
70: on(*tp, ISFLY))) {
71: /* OK, we can go here. But don't go there if
72: * monster can't get at player from there
73: */
74: tryp.y = y;
75: tryp.x = x;
76: if (diag_ok(&tryp, &hero, tp)) {
77: spots[index] = TRUE;
78: found_one = TRUE;
79: }
80: }
81: }
82:
83: /* If we found one, go to it */
84: if (found_one) {
85: char rch; /* What's really where the creatures moves to */
86:
87: /* Find a legal spot */
88: while (spots[index=rnd(9)] == FALSE) continue;
89:
90: /* Get the coordinates */
91: y = hero.y + (index/3) - 1;
92: x = hero.x + (index % 3) - 1;
93:
94: /* Move the monster from the old space */
95: mvwaddch(cw, tp->t_pos.y, tp->t_pos.x, tp->t_oldch);
96:
97: /* Move it to the new space */
98: tp->t_oldch = CCHAR( mvwinch(cw, y, x) );
99:
100: /* Display the creature if our hero can see it */
101: if (cansee(y, x) &&
102: off(*tp, ISINWALL) &&
103: !invisible(tp))
104: mvwaddch(cw, y, x, tp->t_type);
105:
106: /* Fix the monster window */
107: mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, ' '); /* Clear old position */
108: mvwaddch(mw, y, x, tp->t_type);
109:
110: /* Record the new position */
111: tp->t_pos.y = y;
112: tp->t_pos.x = x;
113:
114: /* If the monster is on a trap, trap it */
115: rch = CCHAR( mvinch(y, x) );
116: if (isatrap(rch)) {
117: if (cansee(y, x)) tp->t_oldch = rch;
118: be_trapped(tp, &(tp->t_pos));
119: }
120: }
121:
122: return(found_one);
123: }
124:
125: /*
126: * Can_shoot determines if the monster (er) has a direct line of shot
127: * at the player (ee). If so, it returns the direction in which to shoot.
128: */
129:
130: coord *
131: can_shoot(coord *er, coord *ee)
132: {
133: static coord shoot_dir;
134:
135: /* Make sure we are chasing the player */
136: if (!ce((*ee), hero)) return(NULL);
137:
138: /*
139: * They must be in the same room or very close (at door)
140: */
141: if (roomin(er) != roomin(&hero) && DISTANCE(er->y,er->x,ee->y,ee->x) > 1)
142: return(NULL);
143:
144: /* Do we have a straight shot? */
145: if (!straight_shot(er->y, er->x, ee->y, ee->x, &shoot_dir)) return(NULL);
146: else return(&shoot_dir);
147: }
148:
149: /*
150: * chase:
151: * Find the spot for the chaser(er) to move closer to the
152: * chasee(ee). Returns TRUE if we want to keep on chasing later
153: * FALSE if we reach the goal.
154: */
155:
156: /* flee: True if destination (ee) is player and monster is running
157: * away or the player is in a wall and the monster can't get to it
158: */
159: bool
160: chase(struct thing *tp, coord *ee, bool flee, bool *mdead)
161: {
162: int damage, dist, thisdist, monst_dist = MAXINT;
163: struct linked_list *weapon;
164: register coord *er = &tp->t_pos;
165: coord *shoot_dir;
166: char ch, mch;
167: bool next_player = FALSE;
168:
169: if (mdead != NULL)
170: *mdead = 0;
171:
172: /*
173: * set the distance from the chas(er) to the chas(ee) here and then
174: * we won't have to reset it unless the chas(er) moves (instead of shoots)
175: */
176: dist = DISTANCE(er->y, er->x, ee->y, ee->x);
177:
178: /*
179: * If the thing is confused or it can't see the player,
180: * let it move randomly.
181: */
182: if ((on(*tp, ISHUH) && rnd(10) < 8) ||
183: (on(player, ISINVIS) && off(*tp, CANSEE))) { /* Player is invisible */
184: /*
185: * get a valid random move
186: */
187: ch_ret = *rndmove(tp);
188: dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);
189: /*
190: * check to see if random move takes creature away from player
191: * if it does then turn off ISHELD
192: */
193: if (dist > 2) {
194: if (on(*tp, DIDHOLD)) {
195: turn_off(*tp, DIDHOLD);
196: turn_on(*tp, CANHOLD);
197: if (--hold_count == 0)
198: turn_off(player, ISHELD);
199: }
200:
201: /* If monster was suffocating, stop it */
202: if (on(*tp, DIDSUFFOCATE)) {
203: turn_off(*tp, DIDSUFFOCATE);
204: turn_on(*tp, CANSUFFOCATE);
205: extinguish(suffocate);
206: }
207: }
208: }
209:
210: /* If we can breathe, we may do so */
211: else if (on(*tp, CANBREATHE) &&
212: (dist < BOLT_LENGTH*BOLT_LENGTH) &&
213: (shoot_dir = can_shoot(er, ee)) &&
214: !on(player, ISINWALL) &&
215: (rnd(100) < 75)) {
216: register char *breath = NULL;
217:
218: damage = tp->t_stats.s_hpt;
219: /* Will it breathe at random */
220: if (on(*tp, CANBRANDOM)) {
221: /* Turn off random breath */
222: turn_off(*tp, CANBRANDOM);
223:
224: /* Select type of breath */
225: switch (rnd(10)) {
226: case 0: breath = "acid";
227: turn_on(*tp, NOACID);
228: when 1: breath = "flame";
229: turn_on(*tp, NOFIRE);
230: when 2: breath = "lightning bolt";
231: turn_on(*tp, NOBOLT);
232: when 3: breath = "chlorine gas";
233: turn_on(*tp, NOGAS);
234: when 4: breath = "ice";
235: turn_on(*tp, NOCOLD);
236: when 5: breath = "nerve gas";
237: turn_on(*tp, NOPARALYZE);
238: when 6: breath = "sleeping gas";
239: turn_on(*tp, NOSLEEP);
240: when 7: breath = "slow gas";
241: turn_on(*tp, NOSLOW);
242: when 8: breath = "confusion gas";
243: turn_on(*tp, ISCLEAR);
244: when 9: breath = "fear gas";
245: turn_on(*tp, NOFEAR);
246: }
247: }
248:
249: /* Or can it breathe acid? */
250: else if (on(*tp, CANBACID)) {
251: turn_off(*tp, CANBACID);
252: breath = "acid";
253: }
254:
255: /* Or can it breathe fire */
256: else if (on(*tp, CANBFIRE)) {
257: turn_off(*tp, CANBFIRE);
258: breath = "flame";
259: }
260:
261: /* Or can it breathe electricity? */
262: else if (on(*tp, CANBBOLT)) {
263: turn_off(*tp, CANBBOLT);
264: breath = "lightning bolt";
265: }
266:
267: /* Or can it breathe gas? */
268: else if (on(*tp, CANBGAS)) {
269: turn_off(*tp, CANBGAS);
270: breath = "chlorine gas";
271: }
272:
273: /* Or can it breathe ice? */
274: else if (on(*tp, CANBICE)) {
275: turn_off(*tp, CANBICE);
276: breath = "ice";
277: }
278:
279: else if (on(*tp, CANBPGAS)) {
280: turn_off(*tp, CANBPGAS);
281: breath = "nerve gas";
282: }
283:
284: /* can it breathe sleeping gas */
285: else if (on(*tp, CANBSGAS)) {
286: turn_off(*tp, CANBSGAS);
287: breath = "sleeping gas";
288: }
289:
290: /* can it breathe slow gas */
291: else if (on(*tp, CANBSLGAS)) {
292: turn_off(*tp, CANBSLGAS);
293: breath = "slow gas";
294: }
295: /* can it breathe confusion gas */
296: else if (on(*tp, CANBCGAS)) {
297: turn_off(*tp, CANBCGAS);
298: breath = "confusion gas";
299: }
300: /* can it breathe fear gas */
301: else {
302: turn_off(*tp, CANBFGAS);
303: breath = "fear gas";
304: }
305:
306: /* Now breathe -- sets "monst_dead" if it kills someone */
307: *mdead = shoot_bolt( tp, *er, *shoot_dir, FALSE,
308: tp->t_index, breath, damage);
309:
310: ch_ret = *er;
311: running = FALSE;
312: if (*mdead) return(TRUE);
313: }
314:
315: /* We may shoot missiles if we can */
316: else if (on(*tp, CANMISSILE) &&
317: (shoot_dir = can_shoot(er, ee)) &&
318: !on(player, ISINWALL) &&
319: (rnd(100) < 75)) {
320: static struct object missile =
321: {
322: MISSILE, {0, 0}, "", 0, "", "0d4 " , NULL, 0, WS_MISSILE, 100, 1
323: };
324:
325: sprintf(missile.o_hurldmg, "%dd4", tp->t_stats.s_lvl);
326: do_motion(&missile, shoot_dir->y, shoot_dir->x, tp);
327: hit_monster(unc(missile.o_pos), &missile, tp);
328: turn_off(*tp, CANMISSILE);
329: ch_ret = *er;
330: running = FALSE;
331: }
332:
333: /* We may use a sonic blast if we can */
334: else if (on(*tp, CANSONIC) &&
335: (dist < BOLT_LENGTH*2) &&
336: (shoot_dir = can_shoot(er, ee)) &&
337: !on(player, ISINWALL) &&
338: (rnd(100) < 50)) {
339: static struct object blast =
340: {
341: MISSILE, {0, 0}, "", 0, "", "150" , NULL, 0, 0, 0, 0
342: };
343:
344: turn_off(*tp, CANSONIC);
345: do_motion(&blast, shoot_dir->y, shoot_dir->x, tp);
346: damage = 150;
347: if (save(VS_BREATH, &player, -3))
348: damage /= 2;
349: msg ("The %s's sonic blast hits you", monsters[tp->t_index].m_name);
350: if ((pstats.s_hpt -= damage) <= 0)
351: death(tp->t_index);
352: ch_ret = *er;
353: running = FALSE;
354: }
355: /*
356: * If we have a special magic item, we might use it. We will restrict
357: * this options to uniques with relics for now.
358: */
359: else if (on(*tp, ISUNIQUE) && m_use_item(tp, er, ee)) {
360: ch_ret = *er;
361: running = FALSE;
362: }
363: /*
364: * If we can shoot or throw something, we might do so.
365: * If next to player, then 80% prob will fight.
366: */
367: else if(on(*tp, CANSHOOT) &&
368: (shoot_dir = can_shoot(er, ee)) &&
369: !on(player, ISINWALL) &&
370: (dist > 3 || (rnd(100) > 80)) &&
371: (weapon = get_hurl(tp))) {
372: missile(shoot_dir->y, shoot_dir->x, weapon, tp);
373: ch_ret = *er;
374: }
375:
376: /*
377: * Otherwise, find the empty spot next to the chaser that is
378: * closest to the chasee.
379: */
380: else {
381: register int ey, ex, x, y;
382: register struct room *rer, *ree;
383: int dist_to_old = MININT; /* Dist from goal to old position */
384:
385: /* Get rooms */
386: rer = roomin(er); /* Room the chasER (monster) is in */
387: ree = roomin(ee); /* Room the chasEE is in */
388:
389: /*
390: * This will eventually hold where we move to get closer
391: * If we can't find an empty spot, we stay where we are.
392: */
393: dist = flee ? 0 : MAXINT;
394: ch_ret = *er;
395:
396: /* Are we at our goal already? */
397: if (!flee && ce(ch_ret, *ee)) return(FALSE);
398:
399: ey = er->y + 1;
400: ex = er->x + 1;
401:
402: /* Check all possible moves */
403: for (x = er->x - 1; x <= ex; x++) {
404: if (x < 0 || x >= COLS) /* Don't try off the board */
405: continue;
406: for (y = er->y - 1; y <= ey; y++) {
407: coord tryp;
408:
409: if ((y < 1) || (y >= LINES - 2)) /* Don't try off the board */
410: continue;
411:
412: /* Don't try the player if not going after the player */
413: if ((flee || !ce(hero, *ee)) && x == hero.x && y == hero.y) {
414: next_player = TRUE;
415: continue;
416: }
417:
418: tryp.x = x;
419: tryp.y = y;
420:
421: /* Is there a monster on this spot closer to our goal?
422: * Don't look in our spot or where we were.
423: */
424: if (!ce(tryp, *er) && !ce(tryp, tp->t_oldpos) &&
425: isalpha(mch = CCHAR( mvwinch(mw, y, x) ) )) {
426: int test_dist;
427:
428: test_dist = DISTANCE(y, x, ee->y, ee->x);
429: if (test_dist <= 25 && /* Let's be fairly close */
430: test_dist < monst_dist) {
431: /* Could we really move there? */
432: mvwaddch(mw, y, x, ' '); /* Temporarily blank monst */
433: if (diag_ok(er, &tryp, tp)) monst_dist = test_dist;
434: mvwaddch(mw, y, x, mch); /* Restore monster */
435: }
436: }
437:
438: /* Can we move onto the spot? */
439: if (!diag_ok(er, &tryp, tp)) continue;
440:
441: ch = CCHAR( mvwinch(cw, y, x) ); /* Screen character */
442:
443: /* Stepping on player is NOT okay if we are fleeing */
444: if (step_ok(y, x, NOMONST, tp) &&
445: (off(*tp, ISFLEE) || ch != PLAYER))
446: {
447: /*
448: * If it is a trap, an intelligent monster may not
449: * step on it (unless our hero is on top!)
450: */
451: if ((isatrap(ch)) &&
452: (rnd(10) < tp->t_stats.s_intel) &&
453: (!on(*tp, ISFLY)) &&
454: (y != hero.y || x != hero.x))
455: continue;
456:
457: /*
458: * OK -- this place counts
459: */
460: thisdist = DISTANCE(y, x, ee->y, ee->x);
461:
462: /* Adjust distance if we are being shot at */
463: if (tp->t_wasshot && tp->t_stats.s_intel > 5 &&
464: ce(hero, *ee)) {
465: /* Move out of line of sight */
466: if (straight_shot(tryp.y, tryp.x, ee->y, ee->x, NULL)) {
467: if (flee) thisdist -= SHOTPENALTY;
468: else thisdist += SHOTPENALTY;
469: }
470:
471: /* But do we want to leave the room? */
472: else if (rer && rer == ree && ch == DOOR)
473: thisdist += DOORPENALTY;
474: }
475:
476: /* Don't move to the last position if we can help it
477: * (unless out prey just moved there)
478: */
479: if (ce(tryp, tp->t_oldpos) && (flee || !ce(tryp, hero)))
480: dist_to_old = thisdist;
481:
482: else if ((flee && (thisdist > dist)) ||
483: (!flee && (thisdist < dist)))
484: {
485: ch_ret = tryp;
486: dist = thisdist;
487: }
488: }
489: }
490: }
491:
492: /* If we aren't trying to get the player, but he is in our way,
493: * hit him (unless we have been turned)
494: */
495: if (next_player && off(*tp, WASTURNED) &&
496: ((flee && ce(ch_ret, *er)) ||
497: (!flee && DISTANCE(er->y, er->x, ee->y, ee->x) < dist)) &&
498: step_ok(tp->t_dest->y, tp->t_dest->x, NOMONST, tp)) {
499: /* Okay to hit player */
500: ch_ret = hero;
501: return(FALSE);
502: }
503:
504:
505: /* If we can't get closer to the player (if that's our goal)
506: * because other monsters are in the way, just stay put
507: */
508: if (!flee && ce(hero, *ee) && monst_dist < MAXINT &&
509: DISTANCE(er->y, er->x, hero.y, hero.x) < dist)
510: ch_ret = *er;
511:
512: /* Do we want to go back to the last position? */
513: else if (dist_to_old != MININT && /* It is possible to move back */
514: ((flee && dist == 0) || /* No other possible moves */
515: (!flee && dist == MAXINT))) {
516: /* Do we move back or just stay put (default)? */
517: dist = DISTANCE(er->y, er->x, ee->y, ee->x); /* Current distance */
518: if (!flee || (flee && (dist_to_old > dist))) ch_ret = tp->t_oldpos;
519: }
520: }
521:
522: /* May actually hit here from a confused move */
523: return(!ce(ch_ret, hero));
524: }
525:
526: /*
527: * do_chase:
528: * Make one thing chase another.
529: */
530: /* flee: True if running away or player is inaccessible in wall */
531:
532: void
533: do_chase(struct thing *th, bool flee)
534: {
535: register struct room *rer, *ree, /* room of chaser, room of chasee */
536: *orig_rer, /* Original room of chaser */
537: *new_room; /* new room of monster */
538: int dist = MININT;
539: int mindist = MAXINT, maxdist = MININT;
540: bool stoprun = FALSE, /* TRUE means we are there */
541: rundoor; /* TRUE means run to a door */
542: bool mdead = 0;
543: char rch, sch;
544: coord *last_door=0, /* Door we just came from */
545: this; /* Temporary destination for chaser */
546:
547: /* Make sure the monster can move */
548: if (th->t_no_move != 0) {
549: th->t_no_move--;
550: return;
551: }
552:
553: rer = roomin(&th->t_pos); /* Find room of chaser */
554: ree = roomin(th->t_dest); /* Find room of chasee */
555: orig_rer = rer; /* Original room of chaser (including doors) */
556:
557: /*
558: * We don't count monsters on doors as inside rooms for this routine
559: */
560: if ((sch = CCHAR( mvwinch(stdscr, th->t_pos.y, th->t_pos.x) )) == DOOR ||
561: sch == PASSAGE) {
562: rer = NULL;
563: }
564: this = *th->t_dest;
565:
566: /*
567: * If we are not in a corridor and not a Xorn, then if we are running
568: * after the player, we run to a door if he is not in the same room.
569: * If we are fleeing, we run to a door if he IS in the same room.
570: * Note: We don't bother with doors in mazes.
571: */
572: if (levtype != MAZELEV && rer != NULL && off(*th, CANINWALL)) {
573: if (flee) rundoor = (rer == ree);
574: else rundoor = (rer != ree);
575: }
576: else rundoor = FALSE;
577:
578: if (rundoor) {
579: register struct linked_list *exitptr; /* For looping through exits */
580: coord *exit; /* A particular door */
581: int exity, exitx; /* Door's coordinates */
582: char dch='\0'; /* Door character */
583:
584: if (th->t_doorgoal)
585: dch = CCHAR( mvwinch(stdscr, th->t_doorgoal->y, th->t_doorgoal->x) );
586:
587: /* Do we have a valid goal? */
588: if ((dch == PASSAGE || dch == DOOR) && /* A real door */
589: (!flee || !ce(*th->t_doorgoal, hero))) { /* Player should not
590: * be at door if we are
591: * running away
592: */
593: this = *th->t_doorgoal;
594: dist = 0; /* Indicate that we have our door */
595: }
596:
597: /* Go through all the doors */
598: else for (exitptr = rer->r_exit; exitptr; exitptr = next(exitptr)) {
599: exit = DOORPTR(exitptr);
600: exity = exit->y;
601: exitx = exit->x;
602:
603: /* Make sure it is a real door */
604: dch = CCHAR( mvwinch(stdscr, exity, exitx) );
605: if (dch == PASSAGE || dch == DOOR) {
606: /* Don't count a door if we are fleeing from the player and
607: * he is standing on it
608: */
609: if (flee && ce(*exit, hero)) continue;
610:
611: /* Were we just on this door? */
612: if (ce(*exit, th->t_oldpos)) last_door = exit;
613:
614: else {
615: dist = DISTANCE(th->t_dest->y, th->t_dest->x, exity, exitx);
616:
617: /* If fleeing, we want to maximize distance from door to
618: * what we flee, and minimize distance from door to us.
619: */
620: if (flee)
621: dist -= DISTANCE(th->t_pos.y, th->t_pos.x, exity, exitx);
622:
623: /* Maximize distance if fleeing, otherwise minimize it */
624: if ((flee && (dist > maxdist)) ||
625: (!flee && (dist < mindist))) {
626: th->t_doorgoal = exit; /* Use this door */
627: this = *exit;
628: mindist = maxdist = dist;
629: }
630: }
631: }
632: }
633:
634: /* Could we not find a door? */
635: if (dist == MININT) {
636: /* If we were on a door, go ahead and use it */
637: if (last_door) {
638: th->t_doorgoal = last_door;
639: this = th->t_oldpos;
640: dist = 0; /* Indicate that we found a door */
641: }
642: else th->t_doorgoal = NULL; /* No more door goal */
643: }
644:
645: /* Indicate that we do not want to flee from the door */
646: if (dist != MININT) flee = FALSE;
647: }
648: else th->t_doorgoal = 0; /* Not going to any door */
649:
650: /*
651: * this now contains what we want to run to this time
652: * so we run to it. If we hit it we either want to fight it
653: * or stop running
654: */
655: if (!chase(th, &this, flee, &mdead)) {
656: if (ce(ch_ret, hero)) {
657: /* merchants try to sell something --> others attack */
658: if (on(*th, CANSELL)) sell(th);
659: else attack(th, NULL, FALSE);
660: return;
661: }
662: else if (on(*th, NOMOVE))
663: stoprun = TRUE;
664: }
665:
666: if (mdead) return; /* Did monster kill someone? */
667:
668: if (on(*th, NOMOVE)) return;
669:
670: /* If we have a scavenger, it can pick something up */
671: if (on(*th, ISSCAVENGE)) {
672: register struct linked_list *n_item, *o_item;
673:
674: while ((n_item = find_obj(ch_ret.y, ch_ret.x)) != NULL) {
675: char floor = (roomin(&ch_ret) == NULL) ? PASSAGE : FLOOR;
676: register struct object *n_obj, *o_obj;
677:
678: /*
679: * see if he's got one of this group already
680: */
681: o_item = NULL;
682: n_obj = OBJPTR(n_item);
683: detach(lvl_obj, n_item);
684: if (n_obj->o_group) {
685: for(o_item = th->t_pack; o_item != NULL; o_item = next(o_item)){
686: o_obj = OBJPTR(o_item);
687: if (o_obj->o_group == n_obj->o_group) {
688: o_obj->o_count += n_obj->o_count;
689: o_discard(n_item);
690: break;
691: }
692: }
693: }
694: if (o_item == NULL) { /* didn't find it */
695: attach(th->t_pack, n_item);
696: }
697: if (cansee(ch_ret.y, ch_ret.x))
698: mvwaddch(cw, ch_ret.y, ch_ret.x, floor);
699: mvaddch(ch_ret.y, ch_ret.x, floor);
700: }
701: }
702:
703: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
704: sch = CCHAR( mvwinch(cw, ch_ret.y, ch_ret.x) ); /* What player sees */
705: rch = CCHAR( mvwinch(stdscr, ch_ret.y, ch_ret.x) ); /* What's really there */
706:
707: /* Get new room of monster */
708: new_room=roomin(&ch_ret);
709:
710: /* If we have a tunneling monster, it may be making a tunnel */
711: if (on(*th, CANTUNNEL) &&
712: (rch == SECRETDOOR || rch == WALL || rch == '|' || rch == '-')) {
713: char nch; /* The new look to the tunnel */
714:
715: if (rch == WALL) nch = PASSAGE;
716: else if (levtype == MAZELEV) nch = FLOOR;
717: else nch = DOOR;
718: addch(nch);
719:
720: if (cansee(ch_ret.y, ch_ret.x)) sch = nch; /* Can player see this? */
721:
722: /* Does this make a new exit? */
723: if (rch == '|' || rch == '-') {
724: struct linked_list *newroom;
725: coord *exit;
726:
727: newroom = new_item(sizeof(coord));
728: exit = DOORPTR(newroom);
729: *exit = ch_ret;
730: attach(new_room->r_exit, newroom);
731: }
732: }
733:
734: /* Mark if the monster is inside a wall */
735: if (isrock(mvinch(ch_ret.y, ch_ret.x))) turn_on(*th, ISINWALL);
736: else turn_off(*th, ISINWALL);
737:
738: /* If the monster can illuminate rooms, check for a change */
739: if (on(*th, HASFIRE)) {
740: register struct linked_list *fire_item;
741:
742: /* Is monster entering a room? */
743: if (orig_rer != new_room && new_room != NULL) {
744: fire_item = creat_item(); /* Get an item-only structure */
745: ldata(fire_item) = (char *) th;
746:
747: attach(new_room->r_fires, fire_item);
748: new_room->r_flags |= HASFIRE;
749:
750: if (cansee(ch_ret.y, ch_ret.x) && next(new_room->r_fires) == NULL)
751: light(&hero);
752: }
753:
754: /* Is monster leaving a room? */
755: if (orig_rer != new_room && orig_rer != NULL) {
756: /* Find the bugger in the list and delete him */
757: for (fire_item = orig_rer->r_fires; fire_item != NULL;
758: fire_item = next(fire_item)) {
759: if (THINGPTR(fire_item) == th) { /* Found him! */
760: detach(orig_rer->r_fires, fire_item);
761: destroy_item(fire_item);
762: if (orig_rer->r_fires == NULL) {
763: orig_rer->r_flags &= ~HASFIRE;
764: if (cansee(th->t_pos.y, th->t_pos.x))
765: light(&th->t_pos);
766: }
767: break;
768: }
769: }
770: }
771: }
772:
773: /* If monster is entering player's room and player can see it,
774: * stop the player's running.
775: */
776: if (new_room != orig_rer && new_room != NULL &&
777: new_room == ree && cansee(unc(ch_ret)) &&
778: (off(*th, ISINVIS) || on(player, CANSEE)) &&
779: (off(*th, ISSHADOW) || on(player, CANSEE)) &&
780: (off(*th, CANSURPRISE) || ISWEARING(R_ALERT)))
781: running = FALSE;
782:
783: /*
784: if (rer != NULL && !lit_room(orig_rer) && sch == FLOOR &&
785: DISTANCE(ch_ret.y, ch_ret.x, th->t_pos.y, th->t_pos.x) < 3 &&
786: off(player, ISBLIND))
787: th->t_oldch = ' ';
788: else
789: */
790: th->t_oldch = sch;
791:
792: /* Let's display those creatures that we can see. */
793: if (cansee(unc(ch_ret)) &&
794: off(*th, ISINWALL) &&
795: !invisible(th))
796: mvwaddch(cw, ch_ret.y, ch_ret.x, th->t_type);
797:
798: /*
799: * Blank out the old position and record the new position --
800: * the blanking must be done first in case the positions are the same.
801: */
802: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
803: mvwaddch(mw, ch_ret.y, ch_ret.x, th->t_type);
804:
805: /* Record monster's last position (if new one is different) */
806: if (!ce(ch_ret, th->t_pos)) th->t_oldpos = th->t_pos;
807: th->t_pos = ch_ret; /* Mark the monster's new position */
808:
809: /* If the monster is on a trap, trap it */
810: sch = CCHAR( mvinch(ch_ret.y, ch_ret.x) );
811: if (isatrap(sch)) {
812: if (cansee(ch_ret.y, ch_ret.x)) th->t_oldch = sch;
813: be_trapped(th, &ch_ret);
814: }
815:
816:
817: /*
818: * And stop running if need be
819: */
820: if (stoprun && ce(th->t_pos, *(th->t_dest)))
821: turn_off(*th, ISRUN);
822: }
823:
824:
825: /*
826: * Get_hurl returns the weapon that the monster will "throw" if he has one
827: */
828:
829: struct linked_list *
830: get_hurl(struct thing *tp)
831: {
832: struct linked_list *arrow, *bolt, *rock;
833: register struct linked_list *pitem;
834: bool bow=FALSE, crossbow=FALSE, sling=FALSE;
835:
836: arrow = bolt = rock = NULL; /* Don't point to anything to begin with */
837: for (pitem=tp->t_pack; pitem; pitem=next(pitem))
838: if ((OBJPTR(pitem))->o_type == WEAPON)
839: switch ((OBJPTR(pitem))->o_which) {
840: case BOW: bow = TRUE;
841: when CROSSBOW: crossbow = TRUE;
842: when SLING: sling = TRUE;
843: when ROCK: rock = pitem;
844: when ARROW: arrow = pitem;
845: when BOLT: bolt = pitem;
846: }
847:
848: /* Use crossbow bolt if possible */
849: if (crossbow && bolt) return(bolt);
850: if (bow && arrow) return(arrow);
851: if (sling && rock) return(rock);
852: return(NULL);
853: }
854:
855: /*
856: * runners:
857: * Make all the running monsters move.
858: */
859:
860: void
861: runners(void)
862: {
863: register struct linked_list *item;
864: register struct thing *tp = NULL;
865:
866: /*
867: * loop thru the list of running (wandering) monsters and see what
868: * each one will do this time.
869: *
870: * Note: the special case that one of this buggers kills another.
871: * if this happens than we have to see if the monster killed
872: * himself or someone else. In case its himself we have to get next
873: * one immediately. If it wasn't we have to get next one at very
874: * end in case he killed the next one.
875: */
876:
877: for (item = mlist; item != NULL; item = next(item)) {
878: tp = THINGPTR(item);
879: turn_on(*tp, ISREADY);
880: }
881:
882: for (;;) {
883: for (item = mlist; item != NULL; item = next(item)) {
884: tp = THINGPTR(item);
885:
886: if (on(*tp, ISREADY))
887: break;
888: }
889:
890: if (item == NULL)
891: break;
892:
893: turn_off(*tp, ISREADY);
894:
895: if (on(*tp, ISHELD) && rnd(tp->t_stats.s_lvl) > 11) {
896: turn_off(*tp, ISHELD);
897: turn_on(*tp, ISRUN);
898: turn_off(*tp, ISDISGUISE);
899: tp->t_dest = &hero;
900: if (tp->t_stats.s_hpt < tp->maxstats.s_hpt)
901: turn_on(*tp, ISFLEE);
902: if (cansee(tp->t_pos.y, tp->t_pos.x))
903: msg("The %s breaks free from the hold spell",
904: monsters[tp->t_index].m_name);
905: }
906: if (off(*tp, ISHELD) && on(*tp, ISRUN)) {
907: register bool flee;
908:
909: /* Should monster run away? */
910: flee = on(*tp, ISFLEE) ||
911: ((tp->t_dest == &hero) && on(player, ISINWALL) &&
912: off(*tp, CANINWALL));
913:
914: if (off(*tp, ISSLOW) || tp->t_turn) {
915: doctor(tp);
916: do_chase(tp, flee);
917: }
918: if (off(*tp, ISDEAD) && off(*tp, ISELSEWHERE) && on(*tp, ISHASTE)) {
919: doctor(tp);
920: do_chase(tp, flee);
921: }
922: if (off(*tp, ISDEAD) && off(*tp, ISELSEWHERE)) {
923: tp->t_turn ^= TRUE;
924: tp->t_wasshot = FALSE; /* Not shot anymore */
925: }
926: }
927: }
928: }
929:
930: /*
931: * runto:
932: * Set a monster running after something
933: */
934:
935: void
936: runto(struct thing *runner, coord *spot)
937: {
938: /*
939: * Start the beastie running
940: */
941: runner->t_dest = spot;
942: turn_on(*runner, ISRUN);
943: turn_off(*runner, ISDISGUISE);
944: }
945:
946:
947:
948: /*
949: * straight_shot:
950: * See if there is a straight line of sight between the two
951: * given coordinates. If shooting is not NULL, it is a pointer
952: * to a structure which should be filled with the direction
953: * to shoot (if there is a line of sight). If shooting, monsters
954: * get in the way. Otherwise, they do not.
955: */
956:
957: bool
958: straight_shot(int ery, int erx, int eey, int eex, coord *shooting)
959: {
960: register int dy, dx; /* Deltas */
961: char ch;
962:
963: /* Does the monster have a straight shot at player */
964: if ((ery != eey) && (erx != eex) &&
965: (abs(ery - eey) != abs(erx - eex))) return(FALSE);
966:
967: /* Get the direction to shoot */
968: if (eey > ery) dy = 1;
969: else if (eey == ery) dy = 0;
970: else dy = -1;
971:
972: if (eex > erx) dx = 1;
973: else if (eex == erx) dx = 0;
974: else dx = -1;
975:
976: /* Make sure we have free area all the way to the player */
977: ery += dy;
978: erx += dx;
979: while ((ery != eey) || (erx != eex)) {
980: switch (ch = CCHAR( winat(ery, erx) )) {
981: case '|':
982: case '-':
983: case WALL:
984: case DOOR:
985: case SECRETDOOR:
986: case FOREST:
987: return(FALSE);
988: default:
989: if (shooting && isalpha(ch)) return(FALSE);
990: }
991: ery += dy;
992: erx += dx;
993: }
994:
995: if (shooting) { /* If we are shooting -- put in the directions */
996: shooting->y = dy;
997: shooting->x = dx;
998: }
999: return(TRUE);
1000: }
1001:
1002: