![[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 / srogue|
Return to chase.c CVS log | Up to [contributed] / early-roguelike / srogue |
1.1 rubenllo 1: /*
2: * Code for one object to chase another
3: *
4: * @(#)chase.c 9.0 (rdk) 7/17/84
5: *
6: * Super-Rogue
7: * Copyright (C) 1984 Robert D. Kindelberger
8: * All rights reserved.
9: *
10: * Based on "Rogue: Exploring the Dungeons of Doom"
11: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
12: * All rights reserved.
13: *
14: * See the file LICENSE.TXT for full copyright and licensing information.
15: */
16:
17: #include <stdlib.h>
18: #include "rogue.h"
19: #include "rogue.ext"
20:
21: #define FARAWAY 32767
22: #define RDIST(a, b) (DISTANCE((a)->y, (a)->x, (b).y, (b).x))
23:
24: int do_chase(struct linked_list *mon);
25: int chase(struct thing *tp, struct coord *ee, bool runaway, bool dofight);
26:
27: struct coord ch_ret; /* Where chasing takes you */
28:
29: /*
30: * runners:
31: * Make all the running monsters move.
32: */
33: void
34: runners(void)
35: {
36: reg struct thing *tp;
37: reg struct linked_list *mon,*nextmon;
38:
39: for (mon = mlist; mon != NULL; mon = nextmon) {
40: tp = THINGPTR(mon);
41: nextmon = next(mon);
42: if (off(*tp, ISHELD) && on(*tp, ISRUN)) {
43: if (tp->t_nomove > 0)
44: if (--tp->t_nomove > 0)
45: continue;
46: if (on(*tp, ISHASTE))
47: if (do_chase(mon) == -1)
48: continue;
49: if (off(*tp, ISSLOW) || tp->t_turn)
50: if (do_chase(mon) == -1)
51: continue;
52: tp->t_turn ^= TRUE;
53: }
54: }
55: }
56:
57:
58: /*
59: * do_chase:
60: * Make one thing chase another.
61: */
62: int
63: do_chase(struct linked_list *mon)
64: {
65: reg struct thing *th;
66: reg struct room *rer, *ree, *rxx;
67: reg int mindist, i, dist;
68: struct stats *st;
69: bool stoprun = FALSE, ondoor = FALSE, link = FALSE;
70: char runaway, dofight, wound, sch, ch;
71: struct coord this;
72: struct trap *trp;
73:
74: th = THINGPTR(mon);
75: wound = th->t_flags & ISWOUND;
76: if (wound)
77: mindist = 0;
78: else
79: mindist = FARAWAY;
80: runaway = wound;
81: dofight = !runaway;
82: rer = th->t_room;
83: if (th->t_type == 'V') {
84: if (rer != NULL && !rf_on(rer, ISDARK)) {
85: /*
86: * Vampires can't stand the light
87: */
88: if (cansee(th->t_pos.y, th->t_pos.x))
89: msg("The vampire vaporizes into thin air !");
90: killed(mon, FALSE);
91: return(-1);
92: }
93: }
94: ree = roomin(th->t_dest); /* room of chasee */
95: this = *th->t_dest;
96: /*
97: * If the object of our desire is in a different
98: * room, then run to the door nearest to our goal.
99: */
100: if (mvinch(th->t_pos.y, th->t_pos.x) == DOOR)
101: ondoor = TRUE;
102: rxx = NULL;
103: if (rer != NULL || ree != NULL) {
104: /*
105: * Monster not in room, hero in room. Run to closest door
106: * in hero's room if not wounded. Run away if wounded.
107: */
108: if (rer == NULL && ree != NULL) {
109: if (!wound)
110: rxx = ree;
111: }
112: /*
113: * Monster in a room, hero not in room. If on a door,
114: * then use closest distance. If not on a door, then
115: * run to closest door in monsters room.
116: */
117: else if (rer != NULL && ree == NULL) {
118: if (!ondoor) {
119: rxx = rer;
120: if (wound)
121: runaway = FALSE;
122: }
123: }
124: /*
125: * Both hero and monster in a DIFFERENT room. Set flag to
126: * check for links between the monster's and hero's rooms.
127: * If no links are found, then the closest door in the
128: * monster's room is used.
129: */
130: else if (rer != ree) {
131: if (!wound) {
132: link = TRUE;
133: if (ondoor)
134: rxx = ree; /* if on door, run to heros room */
135: else
136: rxx = rer; /* else to nearest door this room */
137: }
138: }
139: /*
140: * Both hero and monster in same room. If monster is
141: * wounded, find the best door to run to.
142: */
143: else if (wound) {
144: struct coord *ex;
145: int poss, mdtd, hdtd, ghdtd, nx, gx = 0, best;
146:
147: best = ghdtd = -FARAWAY;
148: for (nx = 0; nx < ree->r_nexits; nx++) {
149: ex = &ree->r_exit[nx];
150: if (mvinch(ex->y, ex->x) == SECRETDOOR)
151: continue;
152: gx += 1;
153: mdtd = abs(th->t_pos.y - ex->y) + abs(th->t_pos.x - ex->x);
154: hdtd = abs(hero.y - ex->y) + abs(hero.x - ex->x);
155: poss = hdtd - mdtd; /* possible move */
156: if (poss > best) {
157: best = poss;
158: this = *ex;
159: }
160: else if (poss == best && hdtd > ghdtd) {
161: ghdtd = hdtd;
162: best = poss;
163: this = *ex;
164: }
165: }
166: runaway = FALSE; /* go for target */
167: if (best < 1)
168: dofight = TRUE; /* fight if we must */
169: mdtd = (gx <= 1 && best < 1);
170: if (ondoor || mdtd) {
171: this = hero;
172: runaway = TRUE;
173: if (!mdtd)
174: dofight = FALSE;
175: }
176: }
177: if (rxx != NULL) {
178: for (i = 0; i < rxx->r_nexits; i += 1) {
179: dist = RDIST(th->t_dest, rxx->r_exit[i]);
180: if (link && rxx->r_ptr[i] == ree)
181: dist = -1;
182: if ((!wound && dist < mindist) ||
183: (wound && dist > mindist)) {
184: this = rxx->r_exit[i];
185: mindist = dist;
186: }
187: }
188: }
189: }
190: else if (DISTANCE(hero.y, hero.x, th->t_pos.y, th->t_pos.x) <= 3)
191: dofight = TRUE;
192: /*
193: * this now contains what we want to run to this time
194: * so we run to it. If we hit it we either want to
195: * fight it or stop running.
196: */
197: if (chase(th, &this, runaway, dofight) == FIGHT) {
198: return( attack(th) );
199: }
200: else if ((th->t_flags & (ISSTUCK | ISPARA)))
201: return(0); /* if paralyzed or stuck */
202: if ((trp = trap_at(ch_ret.y, ch_ret.x)) != NULL) {
203: ch = be_trapped(&ch_ret, th);
204: if (ch == GONER || nlmove) {
205: if (ch == GONER)
206: remove_monster(&th->t_pos, mon);
207: nlmove = FALSE;
208: return((ch == GONER) ? -1 : 0);
209: }
210: }
211: if (pl_off(ISBLIND))
212: mvwaddch(cw,th->t_pos.y,th->t_pos.x,th->t_oldch);
213: sch = mvwinch(cw, ch_ret.y, ch_ret.x);
214: if (rer != NULL && rf_on(rer,ISDARK) && sch == FLOOR &&
215: DISTANCE(ch_ret.y,ch_ret.x,th->t_pos.y,th->t_pos.x) < 3 &&
216: pl_off(ISBLIND))
217: th->t_oldch = ' ';
218: else
219: th->t_oldch = sch;
220: if (cansee(unc(ch_ret)) && off(*th, ISINVIS))
221: mvwaddch(cw, ch_ret.y, ch_ret.x, th->t_type);
222: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
223: mvwaddch(mw, ch_ret.y, ch_ret.x, th->t_type);
224: th->t_oldpos = th->t_pos;
225: th->t_pos = ch_ret;
226: th->t_room = roomin(&ch_ret);
227: i = 5;
228: if (th->t_flags & ISREGEN)
229: i = 40;
230: st = &th->t_stats;
231: if (rnd(100) < i) {
232: if (++st->s_hpt > st->s_maxhp)
233: st->s_hpt = st->s_maxhp;
234: if (!monhurt(th))
235: th->t_flags &= ~ISWOUND;
236: }
237: if (stoprun && ce(th->t_pos, *(th->t_dest)))
238: th->t_flags &= ~ISRUN;
239: return CHASE;
240: }
241:
242:
243: /*
244: * chase:
245: * Find the spot for the chaser to move closer to the
246: * chasee. Returns TRUE if we want to keep on chasing
247: * later FALSE if we reach the goal.
248: */
249: int
250: chase(struct thing *tp, struct coord *ee, bool runaway, bool dofight)
251: {
252: reg int x, y, ch;
253: reg int dist, thisdist, closest;
254: reg struct coord *er = &tp->t_pos;
255: struct coord try, closecoord;
256: int numsteps, onscare;
257:
258: /*
259: * If the thing is confused, let it move randomly.
260: */
261: ch = CHASE;
262: onscare = FALSE;
263: if (on(*tp, ISHUH)) {
264: ch_ret = *rndmove(tp);
265: dist = DISTANCE(hero.y, hero.x, ch_ret.y, ch_ret.x);
266: if (rnd(1000) < 5)
267: tp->t_flags &= ~ISHUH;
268: if (dist == 0)
269: ch = FIGHT;
270: }
271: else {
272: /*
273: * Otherwise, find the the best spot to run to
274: * in order to get to your goal.
275: */
276: numsteps = 0;
277: if (runaway)
278: closest = 0;
279: else
280: closest = FARAWAY;
281: ch_ret = *er;
282: closecoord = tp->t_oldpos;
283: for (y = er->y - 1; y <= er->y + 1; y += 1) {
284: for (x = er->x - 1; x <= er->x + 1; x += 1) {
285: if (!cordok(y, x))
286: continue;
287: try.x = x;
288: try.y = y;
289: if (!diag_ok(er, &try))
290: continue;
291: ch = winat(y, x);
292: if (step_ok(ch)) {
293: struct trap *trp;
294:
295: if (isatrap(ch)) {
296: trp = trap_at(y, x);
297: if (trp != NULL && off(*tp, ISHUH)) {
298: /*
299: * Dont run over found traps unless
300: * the hero is standing on it. If confused,
301: * then he can run into them.
302: */
303: if (trp->tr_flags & ISFOUND) {
304: if (trp->tr_type == POOL && rnd(100) < 80)
305: continue;
306: else if (y != hero.y || x != hero.x)
307: continue;
308: }
309: }
310: }
311: /*
312: * Check for scare monster scrolls.
313: */
314: if (ch == SCROLL) {
315: struct linked_list *item;
316:
317: item = find_obj(y, x);
318: if (item != NULL)
319: if ((OBJPTR(item))->o_which == S_SCARE) {
320: if (ce(hero, try))
321: onscare = TRUE;
322: continue;
323: }
324: }
325: /*
326: * Vampires will not run into a lit room.
327: */
328: if (tp->t_type == 'V') {
329: struct room *lr;
330:
331: lr = roomin(&try);
332: if (lr != NULL && !rf_on(lr, ISDARK))
333: continue;
334: }
335: /*
336: * This is a valid place to step
337: */
338: if (y == hero.y && x == hero.x) {
339: if (dofight) {
340: ch_ret = try; /* if fighting */
341: return FIGHT; /* hit hero */
342: }
343: else
344: continue;
345: }
346: thisdist = DISTANCE(y, x, ee->y, ee->x);
347: if (thisdist <= 0) {
348: ch_ret = try; /* got here but */
349: return CHASE; /* dont fight */
350: }
351: numsteps += 1;
352: if ((!runaway && thisdist < closest) ||
353: (runaway && thisdist > closest)) {
354: /*
355: * dont count the monsters last position as
356: * the closest spot, unless running away and
357: * in the same room.
358: */
359: if (!ce(try, tp->t_oldpos) || (runaway
360: && player.t_room == tp->t_room
361: && tp->t_room != NULL)) {
362: closest = thisdist;
363: closecoord = try;
364: }
365: }
366: }
367: }
368: }
369: /*
370: * If dead end, then go back from whence you came.
371: * Otherwise, pick the closest of the remaining spots.
372: */
373: if (numsteps > 0) /* move to best spot */
374: ch_ret = closecoord;
375: else { /* nowhere to go */
376: if (DISTANCE(tp->t_pos.y, tp->t_pos.x, hero.y, hero.x) < 2)
377: if (!onscare)
378: ch_ret = hero;
379: }
380: if (ce(hero, ch_ret))
381: ch = FIGHT;
382: }
383: return ch;
384: }
385:
386:
387: /*
388: * runto:
389: * Set a monster running after something
390: */
391: void
392: runto(struct coord *runner, struct coord *spot)
393: {
394: reg struct linked_list *item;
395: reg struct thing *tp;
396:
397: if ((item = find_mons(runner->y, runner->x)) == NULL)
398: return;
399: tp = THINGPTR(item);
400: if (tp->t_flags & ISPARA)
401: return;
402: tp->t_dest = spot;
403: tp->t_flags |= ISRUN;
404: tp->t_flags &= ~ISHELD;
405: }
406:
407:
408: /*
409: * roomin:
410: * Find what room some coordinates are in.
411: * NULL means they aren't in any room.
412: */
413: struct room *
414: roomin(struct coord *cp)
415: {
416: reg struct room *rp;
417:
418: if (cordok(cp->y, cp->x)) {
419: for (rp = rooms; rp < &rooms[MAXROOMS]; rp += 1)
420: if (inroom(rp, cp))
421: return rp;
422: }
423: return NULL;
424: }
425:
426:
427: /*
428: * find_mons:
429: * Find the monster from his coordinates
430: */
431: struct linked_list *
432: find_mons(int y, int x)
433: {
434: reg struct linked_list *item;
435: reg struct thing *th;
436:
437: for (item = mlist; item != NULL; item = next(item)) {
438: th = THINGPTR(item);
439: if (th->t_pos.y == y && th->t_pos.x == x)
440: return item;
441: }
442: return NULL;
443: }
444:
445:
446: /*
447: * diag_ok:
448: * Check to see if the move is legal if it is diagonal
449: */
450: bool
451: diag_ok(struct coord *sp, struct coord *ep)
452: {
453: if (ep->x == sp->x || ep->y == sp->y)
454: return TRUE;
455: if (step_ok(mvinch(ep->y,sp->x)) && step_ok(mvinch(sp->y,ep->x)))
456: return TRUE;
457: return FALSE;
458: }
459:
460:
461: /*
462: * cansee:
463: * returns true if the hero can see a certain coordinate.
464: */
465: bool
466: cansee(int y, int x)
467: {
468: reg struct room *rer;
469: struct coord tp;
470:
471: if (pl_on(ISBLIND))
472: return FALSE;
473: /*
474: * We can only see if the hero in the same room as
475: * the coordinate and the room is lit or if it is close.
476: */
477: if (DISTANCE(y, x, hero.y, hero.x) < 3)
478: return TRUE;
479: tp.y = y;
480: tp.x = x;
481: rer = roomin(&tp);
482: if (rer != NULL && levtype != MAZELEV)
483: if (rer == player.t_room && !rf_on(rer,ISDARK))
484: return TRUE;
485: return FALSE;
486: }