Annotation of early-roguelike/xrogue/chase.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: chase.c - Code for one object to chase another
3:
4: XRogue: Expeditions into the Dungeons of Doom
5: Copyright (C) 1991 Robert Pietkivitch
6: All rights reserved.
7:
8: Based on "Advanced Rogue"
9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
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 <ctype.h>
20: #include <curses.h>
21: #include <limits.h>
22: #include <stdlib.h>
23: #include "rogue.h"
24:
25: bool straight_shot(int ery, int erx, int eey, int eex, coord *shooting);
26:
27: /*
28: * Canblink checks if the monster can teleport (blink). If so, it will
29: * try to blink the monster next to the player.
30: */
31:
32: bool
33: can_blink(struct thing *tp)
34: {
35: register int y, x, index=9;
36: coord tryp; /* To hold the coordinates for use in diag_ok */
37: bool spots[9], found_one=FALSE;
38:
39: /*
40: * First, can the monster even blink? And if so, there is only a 50%
41: * chance that it will do so. And it won't blink if it is running or
42: * held.
43: */
44: if (off(*tp, CANBLINK) || (on(*tp, ISHELD)) ||
45: on(*tp, ISFLEE) ||
46: tp->t_action == A_FREEZE ||
47: (rnd(12) < 6)) return(FALSE);
48:
49:
50: /* Initialize the spots as illegal */
51: do {
52: spots[--index] = FALSE;
53: } while (index > 0);
54:
55: /* Find a suitable spot next to the player */
56: for (y=hero.y-1; y<hero.y+2; y++)
57: for (x=hero.x-1; x<hero.x+2; x++, index++) {
58: /* Make sure x coordinate is in range and that we are
59: * not at the player's position
60: */
61: if (x<0 || x >= cols || index == 4) continue;
62:
63: /* Is it OK to move there? */
64: if (step_ok(y, x, NOMONST, tp) &&
65: (!isatrap(mvwinch(cw, y, x)) ||
66: rnd(10) >= tp->t_stats.s_intel ||
67: on(*tp, ISFLY))) {
68: /* OK, we can go here. But don't go there if
69: * monster can't get at player from there
70: */
71: tryp.y = y;
72: tryp.x = x;
73: if (diag_ok(&tryp, &hero, tp)) {
74: spots[index] = TRUE;
75: found_one = TRUE;
76: }
77: }
78: }
79:
80: /* If we found one, go to it */
81: if (found_one) {
82: unsigned char rch; /* What's really where the creatures moves to */
83:
84: /* Find a legal spot */
85: while (spots[index=rnd(9)] == FALSE) continue;
86:
87: /* Get the coordinates */
88: y = hero.y + (index/3) - 1;
89: x = hero.x + (index % 3) - 1;
90:
91: /* Move the monster from the old space */
92: mvwaddch(cw, tp->t_pos.y, tp->t_pos.x, tp->t_oldch);
93:
94: /* Move it to the new space */
95: tp->t_oldch = mvwinch(cw, y, x);
96:
97: /* Display the creature if our hero can see it */
98: if (cansee(y, x) &&
99: off(*tp, ISINWALL) &&
100: !invisible(tp))
101: mvwaddch(cw, y, x, tp->t_type);
102:
103: /* Fix the monster window */
104: mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, ' '); /* Clear old position */
105: mvwaddch(mw, y, x, tp->t_type);
106:
107: /* Record the new position */
108: tp->t_pos.y = y;
109: tp->t_pos.x = x;
110:
111: /* If the monster is on a trap, trap it */
112: rch = mvinch(y, x);
113: if (isatrap(rch)) {
114: if (cansee(y, x)) tp->t_oldch = rch;
115: be_trapped(tp, &(tp->t_pos));
116: }
117: }
118:
119: return(found_one);
120: }
121:
122: /*
123: * Can_shoot determines if the monster (er) has a direct line of shot
124: * at the prey (ee). If so, it returns the direction in which to shoot.
125: */
126:
127: int
128: can_shoot(coord *er, coord *ee, coord *shoot_dir)
129: {
130: /*
131: * They must be in the same room or very close (at door)
132: */
133: if (roomin(er) != roomin(ee) && DISTANCE(er->y,er->x,ee->y,ee->x) > 1)
134: {
135: shoot_dir->x = shoot_dir->y = 0;
136: return(-1);
137: }
138:
139: /* Do we have a straight shot? */
140: if (!straight_shot(er->y, er->x, ee->y, ee->x, shoot_dir))
141: {
142: shoot_dir->x = shoot_dir->y = 0;
143: return(-2);
144: }
145: else
146: return(0);
147: }
148:
149: /*
150: * chase:
151: * Find the spot for the chaser(er) to move closer to the
152: * chasee(ee). Rer is the room of the chaser, and ree is the
153: * room of the creature being chased (chasee).
154: * flee: True if destination (ee) is player and monster is running away
155: * or the player is in a wall and the monster can't get to it
156: */
157:
158: void
159: chase(struct thing *tp, coord *ee, struct room *rer, struct room *ree,
160: bool flee)
161: {
162: int dist, thisdist, monst_dist = INT_MAX;
163: register coord *er = &tp->t_pos;
164: struct thing *prey; /* What we are chasing */
165: coord ch_ret; /* Where chasing takes you */
166: unsigned char ch, mch;
167: bool next_player = FALSE;
168:
169: /*
170: * set the distance from the chas(er) to the chas(ee) here and then
171: * we won't have to reset it unless the chas(er) moves (instead of shoots)
172: */
173: dist = DISTANCE(er->y, er->x, ee->y, ee->x);
174:
175: /*
176: * See if our destination is a monster or player. If so, make "prey" point
177: * to it.
178: */
179: if (ce(hero, *ee)) prey = &player; /* Is it the player? */
180: else if (tp->t_dest && ce(*(tp->t_dest), *ee)) { /* Is it a monster? */
181: struct linked_list *item;
182:
183: /* What is the monster we're chasing? */
184: item = find_mons(ee->y, ee->x);
185: if (item != NULL) prey = THINGPTR(item);
186: else prey = NULL;
187: }
188: else prey = NULL;
189:
190: /* We will use at least one movement period */
191: tp->t_no_move = movement(tp);
192: if (on(*tp, ISFLY)) /* If the creature is flying, speed it up */
193: tp->t_no_move /= 2;
194:
195: /*
196: * If the thing is confused or it can't see the player,
197: * let it move randomly.
198: */
199: if ((on(*tp, ISHUH) && rnd(10) < 8) ||
200: (prey && on(*prey, ISINVIS) && off(*tp, CANSEE))) { /* invisible prey */
201: /*
202: * get a valid random move
203: */
204: tp->t_newpos = rndmove(tp);
205: dist = DISTANCE(tp->t_newpos.y, tp->t_newpos.x, ee->y, ee->x);
206: }
207:
208: /*
209: * Otherwise, find the empty spot next to the chaser that is
210: * closest to the chasee.
211: */
212: else {
213: register int ey, ex, x, y;
214: int dist_to_old = INT_MIN; /* Dist from goal to old position */
215:
216: /*
217: * This will eventually hold where we move to get closer
218: * If we can't find an empty spot, we stay where we are.
219: */
220: dist = flee ? 0 : INT_MAX;
221: ch_ret = *er;
222:
223: /* Are we at our goal already? */
224: if (!flee && ce(ch_ret, *ee)) {
225: turn_off(*tp, ISRUN); /* So stop running! */
226: return;
227: }
228:
229: ey = er->y + 1;
230: ex = er->x + 1;
231:
232: /* Check all possible moves */
233: for (x = er->x - 1; x <= ex; x++) {
234: if (x < 0 || x >= cols) /* Don't try off the board */
235: continue;
236: for (y = er->y - 1; y <= ey; y++) {
237: coord tryp;
238:
239: if ((y < 1) || (y >= lines - 2)) /* Don't try off the board */
240: continue;
241:
242: /* Don't try the player if not going after the player */
243: if ((flee || !ce(hero, *ee) || on(*tp, ISFRIENDLY)) &&
244: x == hero.x && y == hero.y) {
245: next_player = TRUE;
246: continue;
247: }
248:
249: tryp.x = x;
250: tryp.y = y;
251:
252: /* Is there a monster on this spot closer to our goal?
253: * Don't look in our spot or where we were.
254: */
255: if (!ce(tryp, *er) && !ce(tryp, tp->t_oldpos) &&
256: isalpha(mch = mvwinch(mw, y, x))) {
257: int test_dist;
258:
259: test_dist = DISTANCE(y, x, ee->y, ee->x);
260: if (test_dist <= 25 && /* Let's be fairly close */
261: test_dist < monst_dist) {
262: /* Could we really move there? */
263: mvwaddch(mw, y, x, ' '); /* Temporarily blank monst */
264: if (diag_ok(er, &tryp, tp)) monst_dist = test_dist;
265: mvwaddch(mw, y, x, mch); /* Restore monster */
266: }
267: }
268:
269: /* Can we move onto the spot? */
270: if (!diag_ok(er, &tryp, tp)) continue;
271:
272: ch = mvwinch(cw, y, x); /* Screen character */
273:
274: /*
275: * Stepping on player is NOT okay if we are fleeing.
276: * If we are friendly to the player and there is a monster
277: * in the way that is not of our race, it is okay to move
278: * there.
279: */
280: if (step_ok(y, x, FIGHTOK, tp) &&
281: (off(*tp, ISFLEE) || ch != PLAYER))
282: {
283: /*
284: * If it is a trap, an intelligent monster may not
285: * step on it (unless our hero is on top!)
286: */
287: if ((isatrap(ch)) &&
288: (rnd(10) < tp->t_stats.s_intel) &&
289: (!on(*tp, ISFLY)) &&
290: (y != hero.y || x != hero.x))
291: continue;
292:
293: /*
294: * OK -- this place counts
295: */
296: thisdist = DISTANCE(y, x, ee->y, ee->x);
297:
298: /* Adjust distance if we are being shot at */
299: if (tp->t_wasshot && tp->t_stats.s_intel > 5 &&
300: prey != NULL) {
301: /* Move out of line of sight */
302: if (straight_shot(tryp.y, tryp.x, ee->y, ee->x, (coord *)NULL)) {
303: if (flee) thisdist -= SHOTPENALTY;
304: else thisdist += SHOTPENALTY;
305: }
306:
307: /* But do we want to leave the room? */
308: else if (rer && rer == ree && ch == DOOR)
309: thisdist += DOORPENALTY;
310: }
311:
312: /* Don't move to the last position if we can help it
313: * (unless out prey just moved there)
314: */
315: if (ce(tryp, tp->t_oldpos) && (flee || !ce(tryp, hero)))
316: dist_to_old = thisdist;
317:
318: else if ((flee && (thisdist > dist)) ||
319: (!flee && (thisdist < dist)))
320: {
321: ch_ret = tryp;
322: dist = thisdist;
323: }
324: }
325: }
326: }
327:
328: /* If we aren't trying to get the player, but he is in our way,
329: * hit him (unless we have been turned or are friendly). next_player
330: * being TRUE -> we are next to the player but don't want to hit him.
331: *
332: * If we are friendly to the player, following him, and standing next
333: * to him, we will try to help him out in battle.
334: */
335: if (next_player && off(*tp, WASTURNED)) {
336: if (off(*tp, ISFRIENDLY) &&
337: ((flee && ce(ch_ret, *er)) ||
338: (!flee && DISTANCE(er->y, er->x, ee->y, ee->x) < dist)) &&
339: step_ok(tp->t_dest->y, tp->t_dest->x, NOMONST, tp)) {
340: /* Okay to hit player */
341: debug("Switching to hero.");
342: tp->t_newpos = hero;
343: tp->t_action = A_MOVE;
344: return;
345: }
346: else if (on(*tp, ISFRIENDLY) && !flee && ce(*ee, hero)) {
347: /*
348: * Look all around the player. If there is a fightable
349: * creature next to both of us, hit it. Otherwise, if
350: * there is a fightable creature next to the player, try
351: * to move next to it.
352: */
353: dist = INT_MAX;
354: for (x = hero.x - 1; x <= hero.x + 1; x++) {
355: if (x < 0 || x >= cols) /* Don't try off the board */
356: continue;
357: for (y = hero.y - 1; y <= hero.y + 1; y++) {
358: if ((y < 1) || (y >= lines - 2)) /* Stay on the board */
359: continue;
360:
361: /* Is there a fightable monster here? */
362: if (isalpha(mvwinch(mw, y, x)) &&
363: step_ok(y, x, FIGHTOK, tp) &&
364: off(*tp, ISSTONE)) {
365: thisdist = DISTANCE(er->y, er->x, y, x);
366: if (thisdist < dist) {
367: dist = thisdist;
368: ch_ret.y = y;
369: ch_ret.x = x;
370: }
371: }
372: }
373: }
374:
375: /* Are we next to a bad guy? */
376: if (dist <= 2) { /* Get him! */
377: tp->t_newpos = ch_ret;
378: tp->t_action = A_MOVE;
379: }
380:
381: /* Try to move to the bad guy */
382: else if (dist < INT_MAX)
383: chase(tp, &ch_ret,
384: roomin(&tp->t_pos), roomin(&ch_ret), FALSE);
385:
386: else tp->t_action = A_NIL;
387:
388: return;
389: }
390: }
391:
392: /*
393: * If we have decided that we can move onto a monster (we are
394: * friendly to the player, go to it.
395: */
396: if (!ce(ch_ret, *er) && isalpha(mvwinch(mw, ch_ret.y, ch_ret.x))) {
397: debug("Attack monster");
398: tp->t_newpos = ch_ret;
399: tp->t_action = A_MOVE;
400: return;
401: }
402:
403: /* If we can't get closer to the player (if that's our goal)
404: * because other monsters are in the way, just stay put
405: */
406: if (!flee && ce(hero, *ee) && monst_dist < INT_MAX &&
407: DISTANCE(er->y, er->x, hero.y, hero.x) < dist) {
408: tp->t_action = A_NIL; /* do nothing for awhile */
409: return;
410: }
411:
412: /* Do we want to go back to the last position? */
413: else if (dist_to_old != INT_MIN && /* It is possible to move back */
414: ((flee && dist == 0) || /* No other possible moves */
415: (!flee && dist == INT_MAX))) {
416: /* Do we move back or just stay put (default)? */
417: dist = DISTANCE(er->y, er->x, ee->y, ee->x); /* Current distance */
418: if (!flee || (flee && (dist_to_old > dist))) ch_ret = tp->t_oldpos;
419: }
420:
421: /* Record the new destination */
422: tp->t_newpos = ch_ret;
423: }
424:
425: /*
426: * Do we want to fight or move? If our selected destination (ch_ret)
427: * is our hero, then we want to fight. Otherwise, we want to move.
428: */
429: if (ce(tp->t_newpos, hero)) {
430: /* Fight! (or sell) */
431: if (on(*tp, CANSELL)) {
432: tp->t_action = A_SELL;
433: tp->t_no_move += movement(tp); /* takes a little time to sell */
434: }
435: else {
436: tp->t_action = A_ATTACK;
437:
438: /*
439: * Try to find a weapon to wield. Wield_weap will return a
440: * projector if weapon is a projectile (eg. bow for arrow).
441: * If weapon is NULL (the case here), it will try to find
442: * a suitable weapon.
443: *
444: * Add in rest of time. Fight is
445: * movement() + weap_move() + FIGHTBASE
446: */
447: tp->t_using = wield_weap((struct object *)NULL, tp);
448: if (tp->t_using == NULL)
449: tp->t_no_move += weap_move(tp, (struct object *)NULL);
450: else
451: tp->t_no_move += weap_move(tp, OBJPTR(tp->t_using));
452:
453: if (on(*tp, ISHASTE))
454: tp->t_no_move += FIGHTBASE/2;
455: else if (on(*tp, ISSLOW))
456: tp->t_no_move += FIGHTBASE*2;
457: else
458: tp->t_no_move += FIGHTBASE;
459: }
460: }
461: else {
462: /* Move */
463: tp->t_action = A_MOVE;
464:
465: /*
466: * Check if the creature is not next to the player. If it
467: * is not and has held or suffocated the player, then stop it!
468: * Note that this code should more appropriately appear in
469: * the area that actually moves the monster, but for now it
470: * is okay here because the player can't move while held or
471: * suffocating.
472: */
473: if (dist > 2) {
474: if (on(*tp, DIDHOLD)) {
475: turn_off(*tp, DIDHOLD);
476: turn_on(*tp, CANHOLD);
477: if (--hold_count == 0)
478: turn_off(player, ISHELD);
479: }
480:
481: /* If monster was suffocating, stop it */
482: if (on(*tp, DIDSUFFOCATE)) {
483: turn_off(*tp, DIDSUFFOCATE);
484: turn_on(*tp, CANSUFFOCATE);
485: extinguish(suffocate);
486: msg("You can breathe again.....Whew!");
487: }
488: }
489: }
490: }
491:
492: /*
493: * do_chase:
494: * Make one thing chase another.
495: */
496:
497: void
498: do_chase(struct thing *th)
499: {
500: register struct room *orig_rer, /* Original room of chaser */
501: *new_room; /* new room of monster */
502: unsigned char floor, rch, sch;
503: coord old_pos, /* Old position of monster */
504: ch_ret; /* Where we want to go */
505:
506: if (on(*th, NOMOVE)) return;
507:
508: ch_ret = th->t_newpos; /* Record our desired new position */
509:
510: /*
511: * Make sure we have an open spot (no other monster's gotten in our way,
512: * someone didn't just drop a scare monster there, our prey didn't just
513: * get there, etc.)
514: */
515: if (!step_ok(th->t_newpos.y, th->t_newpos.x, FIGHTOK, th)) {
516: /*
517: * Most monsters get upset now. Guardians are all friends,
518: * and we don't want to see 50 messages in a row!
519: */
520: if (th->t_stats.s_intel > 4 &&
521: off(*th, ISUNDEAD) &&
522: off(*th, ISGUARDIAN) &&
523: off(*th, AREMANY) &&
524: off(*th, ISHUH) &&
525: off(*th, ISCHARMED) &&
526: off(player, ISBLIND) &&
527: cansee(unc(th->t_pos)) &&
528: !invisible(th) && (rnd(15) < 5)) {
529: switch (rnd(10)) {
530: case 0: case 1:
531: msg("%s lashes out at you! ",prname(monster_name(th),TRUE));
532: when 2: case 3:
533: msg("%s scrambles around. ",prname(monster_name(th), TRUE));
534: otherwise:
535: msg("%s motions angrily. ", prname(monster_name(th), TRUE));
536: }
537: }
538: return;
539: }
540: else if (ce(th->t_newpos, hero) || /* Player just got in our way */
541: isalpha(mvwinch(mw, th->t_newpos.y, th->t_newpos.x))) {
542: bool fightplayer = ce(th->t_newpos, hero);
543:
544: /* If we were turned or are friendly, we just have to sit here! */
545: if (fightplayer && (on(*th, WASTURNED) || on(*th, ISFRIENDLY))) return;
546:
547: /* Do we want to sell something? */
548: if (fightplayer && on(*th, CANSELL)) {
549: th->t_action = A_SELL;
550: th->t_no_move += movement(th); /* takes a little time to sell */
551: return;
552: }
553:
554: /* Let's hit him */
555: th->t_action = A_ATTACK;
556:
557: /*
558: * Try to find a weapon to wield. Wield_weap will return a
559: * projector if weapon is a projectile (eg. bow for arrow).
560: * If weapon is NULL (the case here), it will try to find
561: * a suitable weapon.
562: */
563: th->t_using = wield_weap((struct object *)NULL, th);
564: /*
565: * add in rest of time
566: */
567: if (th->t_using == NULL)
568: th->t_no_move += weap_move(th, (struct object *)NULL);
569: else
570: th->t_no_move += weap_move(th, OBJPTR(th->t_using));
571: if (on(*th, ISHASTE))
572: th->t_no_move += FIGHTBASE/2;
573: else if (on(*th, ISSLOW))
574: th->t_no_move += FIGHTBASE*2;
575: else
576: th->t_no_move += FIGHTBASE;
577: return;
578: }
579:
580: /*
581: * Blank out the old position and record the new position --
582: * the blanking must be done first in case the positions are the same.
583: */
584: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
585: mvwaddch(mw, ch_ret.y, ch_ret.x, th->t_type);
586:
587: /* Get new and old rooms of monster */
588: new_room = roomin(&ch_ret);
589: orig_rer = roomin(&th->t_pos);
590:
591: /* Store the critter's old position and update the current one */
592: old_pos = th->t_pos;
593: th->t_pos = ch_ret;
594: floor = (roomin(&ch_ret) == NULL) ? PASSAGE : FLOOR;
595:
596: /* If we have a scavenger, it can pick something up */
597: if (off(*th, ISGUARDIAN)) {
598: register struct linked_list *n_item, *o_item;
599: register int item_count = 0;
600: bool want_something = FALSE;
601:
602: while ((n_item = find_obj(ch_ret.y, ch_ret.x)) != NULL) {
603: register struct object *n_obj, *o_obj;
604: bool wants_it;
605:
606: /* Does this monster want anything? */
607: if (want_something == FALSE) {
608: if (on(*th, ISSCAVENGE) || on(*th, CARRYFOOD) ||
609: on(*th, CARRYGOLD) || on(*th, CARRYSCROLL) ||
610: on(*th, CARRYPOTION) || on(*th, CARRYRING) ||
611: on(*th, CARRYSTICK) || on(*th, CARRYMISC) ||
612: on(*th, CARRYWEAPON) || on(*th, CARRYARMOR) ||
613: on(*th, CARRYDAGGER)) {
614: want_something = TRUE;
615:
616: /*
617: * Blank the area. We have to do it only before the
618: * first item in case an item gets dropped in same
619: * place. We don't want to blank it out after it get
620: * dropped.
621: */
622: mvaddch(ch_ret.y, ch_ret.x, floor);
623:
624: /* Were we specifically after something here? */
625: if (ce(*th->t_dest, ch_ret)) {
626: /* If we're mean, we go after the hero */
627: if (on(*th, ISMEAN)) runto(th, &hero);
628:
629: /* Otherwise just go back to sleep */
630: else {
631: turn_off(*th, ISRUN);
632: th->t_dest = NULL;
633: }
634: }
635: }
636: else break;
637: }
638:
639: item_count++; /* Count the number of items */
640:
641: /*
642: * see if he's got one of this group already
643: */
644: o_item = NULL;
645: n_obj = OBJPTR(n_item);
646: detach(lvl_obj, n_item);
647:
648: /* See if he wants it */
649: if (n_obj->o_type == SCROLL && n_obj->o_which == S_SCARE &&
650: th->t_stats.s_intel < 16)
651: wants_it = FALSE; /* Most monsters don't want a scare monster */
652: else if (on(*th, ISSCAVENGE)) wants_it = TRUE;
653: else {
654: wants_it = FALSE; /* Default case */
655: switch (n_obj->o_type) {
656: case FOOD: if(on(*th, CARRYFOOD)) wants_it = TRUE;
657: when GOLD: if(on(*th, CARRYGOLD)) wants_it = TRUE;
658: when SCROLL:if(on(*th, CARRYSCROLL)) wants_it = TRUE;
659: when POTION:if(on(*th, CARRYPOTION)) wants_it = TRUE;
660: when RING: if(on(*th, CARRYRING)) wants_it = TRUE;
661: when STICK: if(on(*th, CARRYSTICK)) wants_it = TRUE;
662: when MM: if(on(*th, CARRYMISC)) wants_it = TRUE;
663: when ARMOR: if(on(*th, CARRYARMOR)) wants_it = TRUE;
664: when WEAPON:if(on(*th, CARRYWEAPON) ||
665: (on(*th,CARRYDAGGER)&&n_obj->o_which==DAGGER))
666: wants_it = TRUE;
667: }
668: }
669: /*
670: * The quartermaster doesn't sell cursed stuff so he won't
671: * pick it up
672: */
673: if (on(*th, CANSELL) && (n_obj->o_flags & ISCURSED))
674: wants_it = FALSE;
675:
676: /* If he doesn't want it, throw it away */
677: if (wants_it == FALSE) {
678: fall(n_item, FALSE);
679: continue;
680: }
681:
682: /* Otherwise, let's pick it up */
683: if (n_obj->o_group) {
684: for(o_item = th->t_pack; o_item != NULL; o_item = next(o_item)){
685: o_obj = OBJPTR(o_item);
686: if (o_obj->o_group == n_obj->o_group) {
687: o_obj->o_count += n_obj->o_count;
688: o_discard(n_item);
689: break;
690: }
691: }
692: }
693: if (o_item == NULL) { /* didn't find it */
694: attach(th->t_pack, n_item);
695: }
696: }
697:
698: /* If there was anything here, we may have to update the screen */
699: if (item_count) {
700: if (cansee(ch_ret.y, ch_ret.x))
701: mvwaddch(cw, ch_ret.y, ch_ret.x, mvinch(ch_ret.y, ch_ret.x));
702: updpack(TRUE, th); /* Update the monster's encumberance, too */
703: }
704: }
705:
706: rch = mvwinch(stdscr, old_pos.y, old_pos.x);
707: if (th->t_oldch == floor && rch != floor && !isatrap(rch))
708: mvwaddch(cw, old_pos.y, old_pos.x, rch);
709: else
710: mvwaddch(cw, old_pos.y, old_pos.x, th->t_oldch);
711: sch = mvwinch(cw, ch_ret.y, ch_ret.x); /* What player sees */
712: rch = mvwinch(stdscr, ch_ret.y, ch_ret.x); /* What's really there */
713:
714: /* If we have a tunneling monster, it may be making a tunnel */
715: if (on(*th, CANTUNNEL) &&
716: (rch==SECRETDOOR || rch==WALL || rch==VERTWALL || rch==HORZWALL)) {
717: unsigned char nch; /* The new look to the tunnel */
718:
719: if (rch == WALL && levtype == OUTSIDE) nch = FLOOR;
720: else if (rch == WALL) nch = PASSAGE;
721: else if (levtype == MAZELEV || levtype == OUTSIDE) nch = FLOOR;
722: else nch = DOOR;
723: addch(nch);
724:
725: if (cansee(ch_ret.y, ch_ret.x)) sch = nch; /* Can player see this? */
726:
727: /* Does this make a new exit? */
728: if (rch == VERTWALL || rch == HORZWALL) {
729: struct linked_list *newroom;
730: coord *exit;
731:
732: newroom = new_item(sizeof(coord));
733: exit = DOORPTR(newroom);
734: *exit = ch_ret;
735: attach(new_room->r_exit, newroom);
736: }
737: }
738:
739: /* Mark if the monster is inside a wall */
740: if (isrock(mvinch(ch_ret.y, ch_ret.x))) turn_on(*th, ISINWALL);
741: else turn_off(*th, ISINWALL);
742:
743: /* If the monster can illuminate rooms, check for a change */
744: if (on(*th, HASFIRE)) {
745: register struct linked_list *fire_item;
746:
747: /* Is monster entering a room? */
748: if (orig_rer != new_room && new_room != NULL) {
749: fire_item = creat_item(); /* Get an item-only structure */
750: ldata(fire_item) = (char *) th;
751:
752: attach(new_room->r_fires, fire_item);
753: new_room->r_flags |= HASFIRE;
754:
755: if (cansee(ch_ret.y, ch_ret.x) && next(new_room->r_fires) == NULL)
756: light(&hero);
757: }
758:
759: /* Is monster leaving a room? */
760: if (orig_rer != new_room && orig_rer != NULL) {
761: /* Find the bugger in the list and delete him */
762: for (fire_item = orig_rer->r_fires; fire_item != NULL;
763: fire_item = next(fire_item)) {
764: if (THINGPTR(fire_item) == th) { /* Found him! */
765: detach(orig_rer->r_fires, fire_item);
766: destroy_item(fire_item);
767: if (orig_rer->r_fires == NULL) {
768: orig_rer->r_flags &= ~HASFIRE;
769: if (cansee(old_pos.y, old_pos.x))
770: light(&old_pos);
771: }
772: break;
773: }
774: }
775: }
776: }
777:
778: /* If monster is entering player's room and player can see it,
779: * stop the player's running.
780: */
781: if (new_room != orig_rer && new_room != NULL &&
782: new_room == roomin(th->t_dest) && cansee(unc(ch_ret)) &&
783: (off(*th, ISINVIS) || on(player, CANSEE)) &&
784: (off(*th, ISSHADOW) || on(player, CANSEE)) &&
785: (off(*th, CANSURPRISE) || ISWEARING(R_ALERT))) {
786: running = FALSE;
787: if (fight_flush) flushinp();
788: }
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: /* Record monster's last position (if new one is different) */
799: if (!ce(ch_ret, old_pos)) th->t_oldpos = old_pos;
800:
801: /* If the monster is on a trap, trap it */
802: sch = mvinch(ch_ret.y, ch_ret.x);
803: if (isatrap(sch)) {
804: if (cansee(ch_ret.y, ch_ret.x)) th->t_oldch = sch;
805: be_trapped(th, &ch_ret);
806: }
807: }
808:
809: /*
810: * Get_hurl returns the weapon that the monster will "throw" if he has one
811: */
812:
813: struct linked_list *
814: get_hurl(struct thing *tp)
815: {
816: struct linked_list *arrow=NULL, *bolt=NULL, *rock=NULL,
817: *spear = NULL, *dagger=NULL, *dart=NULL, *aklad=NULL;
818: register struct linked_list *pitem;
819: register struct object *obj;
820: bool bow=FALSE, crossbow=FALSE, sling=FALSE;
821:
822: for (pitem=tp->t_pack; pitem; pitem=next(pitem)) {
823: obj = OBJPTR(pitem);
824: if (obj->o_type == WEAPON)
825: switch (obj->o_which) {
826: case BOW: bow = TRUE;
827: when CROSSBOW: crossbow = TRUE;
828: when SLING: sling = TRUE;
829: when ROCK: rock = pitem;
830: when ARROW: arrow = pitem;
831: when BOLT: bolt = pitem;
832: when SPEAR: spear = pitem;
833: when DAGGER:
834: /* Don't throw the dagger if it's our last one */
835: if (obj->o_count > 1) dagger = pitem;
836: when DART: dart = pitem;
837: }
838: else if (obj->o_type == RELIC &&
839: obj->o_which == AXE_AKLAD)
840: aklad = pitem;
841: }
842:
843: /* Do we have that all-powerful Aklad Axe? */
844: if (aklad) return(aklad);
845:
846: /* Use crossbow bolt if possible */
847: if (crossbow && bolt) return(bolt);
848: if (bow && arrow) return(arrow);
849: if (spear) return(spear);
850: if (dagger) return(dagger);
851: if (sling && rock) return(rock);
852: if (dart) return(dart);
853: return(NULL);
854: }
855:
856: /*
857: * runto:
858: * Set a monster running after something
859: */
860:
861: void
862: runto(struct thing *runner, coord *spot)
863: {
864: if (on(*runner, ISSTONE))
865: return;
866:
867: /* If we are chasing a new creature, forget about thrown weapons */
868: if (runner->t_dest && !ce(*runner->t_dest, *spot)) runner->t_wasshot=FALSE;
869:
870: /*
871: * Start the beastie running
872: */
873: runner->t_dest = spot;
874: turn_on(*runner, ISRUN);
875: turn_off(*runner, ISDISGUISE);
876: }
877:
878: /*
879: * straight_shot:
880: * See if there is a straight line of sight between the two
881: * given coordinates. If shooting is not NULL, it is a pointer
882: * to a structure which should be filled with the direction
883: * to shoot (if there is a line of sight). If shooting, monsters
884: * get in the way. Otherwise, they do not.
885: */
886:
887: bool
888: straight_shot(int ery, int erx, int eey, int eex, coord *shooting)
889: {
890: register int dy, dx; /* Deltas */
891: unsigned char ch;
892:
893: /* Does the monster have a straight shot at prey */
894: if ((ery != eey) && (erx != eex) &&
895: (abs(ery - eey) != abs(erx - eex))) return(FALSE);
896:
897: /* Get the direction to shoot */
898: if (eey > ery) dy = 1;
899: else if (eey == ery) dy = 0;
900: else dy = -1;
901:
902: if (eex > erx) dx = 1;
903: else if (eex == erx) dx = 0;
904: else dx = -1;
905:
906: /* Make sure we have free area all the way to the player */
907: ery += dy;
908: erx += dx;
909: while ((ery != eey) || (erx != eex)) {
910: switch (ch = winat(ery, erx)) {
911: case VERTWALL:
912: case HORZWALL:
913: case WALL:
914: case DOOR:
915: case SECRETDOOR:
916: case FOREST:
917: return(FALSE);
918: default:
919: if (shooting && isalpha(ch)) return(FALSE);
920: }
921: ery += dy;
922: erx += dx;
923: }
924:
925: if (shooting) { /* If we are shooting -- put in the directions */
926: shooting->y = dy;
927: shooting->x = dx;
928: }
929: return(TRUE);
930: }
931:
CVSweb
![[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 / xrogue