![[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 / rogue4|
Return to chase.c CVS log | Up to [contributed] / early-roguelike / rogue4 |
1.1 rubenllo 1: /*
2: * Code for one creature to chase another
3: *
4: * @(#)chase.c 4.25 (Berkeley) 5/5/82
5: *
6: * Rogue: Exploring the Dungeons of Doom
7: * Copyright (C) 1980, 1981, 1982 Michael Toy, Ken Arnold and Glenn Wichman
8: * All rights reserved.
9: *
10: * See the file LICENSE.TXT for full copyright and licensing information.
11: */
12:
13: #include <stdlib.h>
14: #include <curses.h>
15: #include "rogue.h"
16:
17: #define DRAGONSHOT 5 /* one chance in DRAGONSHOT that a dragon will flame */
18:
19: coord ch_ret; /* Where chasing takes you */
20:
21: bool chase(THING *tp, coord *ee);
22: int do_chase(THING *th);
23: coord *find_dest(THING *tp);
24:
25: /*
26: * runners:
27: * Make all the running monsters move.
28: */
29: void
30: runners(void)
31: {
32: register THING *tp;
33: register THING *ntp;
34:
35: for (tp = mlist; tp != NULL; tp = ntp)
36: {
37: ntp = next(tp);
38: if (!on(*tp, ISHELD) && on(*tp, ISRUN))
39: {
40: if (!on(*tp, ISSLOW) || tp->t_turn)
41: if (do_chase(tp) == -1)
42: continue;
43: if (on(*tp, ISHASTE))
44: if (do_chase(tp) == -1)
45: continue;
46: tp->t_turn ^= TRUE;
47: }
48: }
49: }
50:
51: /*
52: * do_chase:
53: * Make one thing chase another.
54: */
55: int
56: do_chase(THING *th)
57: {
58: register struct room *rer, *ree; /* room of chaser, room of chasee */
59: register int mindist = 32767, i, dist;
60: register bool stoprun = FALSE; /* TRUE means we are there */
61: register char sch;
62: register bool door;
63: register THING *obj;
64: register struct room *oroom;
65: coord this; /* Temporary destination for chaser */
66:
67: rer = th->t_room; /* Find room of chaser */
68: if (on(*th, ISGREED) && rer->r_goldval == 0)
69: th->t_dest = &hero; /* If gold has been taken, run after hero */
70: if (th->t_dest == &hero) /* Find room of chasee */
71: ree = proom;
72: else
73: ree = roomin(th->t_dest);
74: /*
75: * We don't count doors as inside rooms for this routine
76: */
77: door = (chat(th->t_pos.y, th->t_pos.x) == DOOR);
78: /*
79: * If the object of our desire is in a different room,
80: * and we are not in a corridor, run to the door nearest to
81: * our goal.
82: */
83: over:
84: if (rer != ree)
85: {
86: for (i = 0; i < rer->r_nexits; i++) /* loop through doors */
87: {
88: dist = DISTANCE(th->t_dest->y, th->t_dest->x,
89: rer->r_exit[i].y, rer->r_exit[i].x);
90: if (dist < mindist)
91: {
92: this = rer->r_exit[i];
93: mindist = dist;
94: }
95: }
96: if (door)
97: {
98: rer = &passages[flat(th->t_pos.y, th->t_pos.x) & F_PNUM];
99: door = FALSE;
100: goto over;
101: }
102: }
103: else
104: {
105: this = *th->t_dest;
106: /*
107: * For dragons check and see if (a) the hero is on a straight
108: * line from it, and (b) that it is within shooting distance,
109: * but outside of striking range.
110: */
111: if (th->t_type == 'D' && (th->t_pos.y == hero.y || th->t_pos.x == hero.x
112: || abs(th->t_pos.y - hero.y) == abs(th->t_pos.x - hero.x))
113: && DISTANCE(th->t_pos.y, th->t_pos.x, hero.y, hero.x) <= BOLT_LENGTH * BOLT_LENGTH
114: && !on(*th, ISCANC) && rnd(DRAGONSHOT) == 0)
115: {
116: delta.y = sign(hero.y - th->t_pos.y);
117: delta.x = sign(hero.x - th->t_pos.x);
118: fire_bolt(&th->t_pos, &delta, "flame");
119: running = FALSE;
120: count = quiet = 0;
121: return 0;
122: }
123: }
124: /*
125: * This now contains what we want to run to this time
126: * so we run to it. If we hit it we either want to fight it
127: * or stop running
128: */
129: if (!chase(th, &this))
130: {
131: if (ce(this, hero))
132: {
133: return ( attack(th) );
134: }
135: else if (ce(this, *th->t_dest))
136: {
137: for (obj = lvl_obj; obj != NULL; obj = next(obj))
138: if (th->t_dest == &obj->o_pos)
139: {
140: detach(lvl_obj, obj);
141: attach(th->t_pack, obj);
142: chat(obj->o_pos.y, obj->o_pos.x) =
143: (th->t_room->r_flags & ISGONE) ? PASSAGE : FLOOR;
144: th->t_dest = find_dest(th);
145: break;
146: }
147: if (th->t_type != 'F')
148: stoprun = TRUE;
149: }
150: }
151: else if (th->t_type == 'F')
152: return(0);
153: mvaddch(th->t_pos.y, th->t_pos.x, th->t_oldch);
154: if (!ce(ch_ret, th->t_pos))
155: {
156: sch = mvinch(ch_ret.y, ch_ret.x);
157: if (sch == FLOOR && (th->t_room->r_flags & ISDARK)
158: && DISTANCE(th->t_pos.y, th->t_pos.x, hero.y, hero.x)
159: && !on(player, ISBLIND))
160: th->t_oldch = ' ';
161: else
162: th->t_oldch = sch;
163: oroom = th->t_room;
164: th->t_room = roomin(&ch_ret);
165: if (oroom != th->t_room)
166: th->t_dest = find_dest(th);
167:
168: moat(th->t_pos.y, th->t_pos.x) = NULL;
169: moat(ch_ret.y, ch_ret.x) = th;
170: th->t_pos = ch_ret;
171: }
172: if (see_monst(th))
173: mvaddch(ch_ret.y, ch_ret.x, th->t_disguise);
174: else if (on(player, SEEMONST))
175: {
176: standout();
177: mvaddch(ch_ret.y, ch_ret.x, th->t_type);
178: standend();
179: }
180: /*
181: * And stop running if need be
182: */
183: if (stoprun && ce(th->t_pos, *(th->t_dest)))
184: th->t_flags &= ~ISRUN;
185:
186: return(0);
187: }
188:
189: /*
190: * see_monst:
191: * Return TRUE if the hero can see the monster
192: */
193: bool
194: see_monst(THING *mp)
195: {
196: if (on(player, ISBLIND))
197: return FALSE;
198: if (on(*mp, ISINVIS) && !on(player, CANSEE))
199: return FALSE;
200: if (DISTANCE(mp->t_pos.y, mp->t_pos.x, hero.y, hero.x) < LAMPDIST)
201: return TRUE;
202: if (mp->t_room != proom)
203: return FALSE;
204: return (!(mp->t_room->r_flags & ISDARK));
205: }
206:
207: /*
208: * runto:
209: * Set a mosnter running after something or stop it from running
210: * (for when it dies)
211: */
212: void
213: runto(coord *runner, coord *spot)
214: {
215: register THING *tp;
216:
217: /*
218: * If we couldn't find him, something is funny
219: */
220: #ifdef WIZARD
221: if ((tp = moat(runner->y, runner->x)) == NULL)
222: msg("couldn't find monster in runto at (%d,%d)", runner->y, runner->x);
223: #else
224: tp = moat(runner->y, runner->x);
225: #endif
226: /*
227: * Start the beastie running
228: */
229: if (tp == NULL)
230: return;
231: tp->t_flags |= ISRUN;
232: tp->t_flags &= ~ISHELD;
233: tp->t_dest = find_dest(tp);
234: }
235:
236: /*
237: * chase:
238: * Find the spot for the chaser(er) to move closer to the
239: * chasee(ee). Returns TRUE if we want to keep on chasing later
240: * FALSE if we reach the goal.
241: */
242: bool
243: chase(THING *tp, coord *ee)
244: {
245: register int x, y;
246: register int dist, thisdist;
247: register THING *obj;
248: register coord *er = &tp->t_pos;
249: register char ch;
250: register int plcnt = 1;
251:
252: /*
253: * If the thing is confused, let it move randomly. Invisible
254: * Stalkers are slightly confused all of the time, and bats are
255: * quite confused all the time
256: */
257: if ((on(*tp, ISHUH) && rnd(5) != 0) || (tp->t_type == 'I' && rnd(5) == 0)
258: || (tp->t_type == 'B' && rnd(2) == 0))
259: {
260: /*
261: * get a valid random move
262: */
263: ch_ret = *rndmove(tp);
264: dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);
265: /*
266: * Small chance that it will become un-confused
267: */
268: if (rnd(20) == 0)
269: tp->t_flags &= ~ISHUH;
270: }
271: /*
272: * Otherwise, find the empty spot next to the chaser that is
273: * closest to the chasee.
274: */
275: else
276: {
277: register int ey, ex;
278: /*
279: * This will eventually hold where we move to get closer
280: * If we can't find an empty spot, we stay where we are.
281: */
282: dist = DISTANCE(er->y, er->x, ee->y, ee->x);
283: ch_ret = *er;
284:
285: ey = er->y + 1;
286: ex = er->x + 1;
287: for (x = er->x - 1; x <= ex; x++)
288: for (y = er->y - 1; y <= ey; y++)
289: {
290: coord tryp;
291:
292: tryp.x = x;
293: tryp.y = y;
294: if (!diag_ok(er, &tryp))
295: continue;
296: ch = winat(y, x);
297: if (step_ok(ch))
298: {
299: /*
300: * If it is a scroll, it might be a scare monster scroll
301: * so we need to look it up to see what type it is.
302: */
303: if (ch == SCROLL)
304: {
305: for (obj = lvl_obj; obj != NULL; obj = next(obj))
306: {
307: if (y == obj->o_pos.y && x == obj->o_pos.x)
308: break;
309: }
310: if (obj != NULL && obj->o_which == S_SCARE)
311: continue;
312: }
313: /*
314: * It can also be a Mimic, which we shouldn't step on
315: */
316: if ((obj = moat(y, x)) != NULL && obj->t_type == 'M')
317: continue;
318: /*
319: * If we didn't find any scrolls at this place or it
320: * wasn't a scare scroll, then this place counts
321: */
322: thisdist = DISTANCE(y, x, ee->y, ee->x);
323: if (thisdist < dist)
324: {
325: plcnt = 1;
326: ch_ret = tryp;
327: dist = thisdist;
328: }
329: else if (thisdist == dist && rnd(++plcnt) == 0)
330: {
331: ch_ret = tryp;
332: dist = thisdist;
333: }
334: }
335: }
336: }
337: return (dist != 0 && !ce(ch_ret, hero));
338: }
339:
340: /*
341: * roomin:
342: * Find what room some coordinates are in. NULL means they aren't
343: * in any room.
344: */
345: struct room *
346: roomin(coord *cp)
347: {
348: register struct room *rp;
349: register char *fp;
350:
351: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++)
352: if (cp->x < rp->r_pos.x + rp->r_max.x && rp->r_pos.x <= cp->x
353: && cp->y < rp->r_pos.y + rp->r_max.y && rp->r_pos.y <= cp->y)
354: return rp;
355: fp = &flat(cp->y, cp->x);
356: if (*fp & F_PASS)
357: return &passages[*fp & F_PNUM];
358: msg("in some bizarre place (%d, %d)", unc(*cp));
359: return NULL;
360: }
361:
362: /*
363: * diag_ok:
364: * Check to see if the move is legal if it is diagonal
365: */
366: bool
367: diag_ok(coord *sp, coord *ep)
368: {
369: if (ep->x == sp->x || ep->y == sp->y)
370: return TRUE;
371: return (step_ok(chat(ep->y, sp->x)) && step_ok(chat(sp->y, ep->x)));
372: }
373:
374: /*
375: * cansee:
376: * Returns true if the hero can see a certain coordinate.
377: */
378: bool
379: cansee(int y, int x)
380: {
381: register struct room *rer;
382: coord tp;
383:
384: if (on(player, ISBLIND))
385: return FALSE;
386: if (DISTANCE(y, x, hero.y, hero.x) < LAMPDIST)
387: return TRUE;
388: /*
389: * We can only see if the hero in the same room as
390: * the coordinate and the room is lit or if it is close.
391: */
392: tp.y = y;
393: tp.x = x;
394: return ((rer = roomin(&tp)) == proom && !(rer->r_flags & ISDARK));
395: }
396:
397: /*
398: * find_dest:
399: * find the proper destination for the monster
400: */
401: coord *
402: find_dest(THING *tp)
403: {
404: register THING *obj;
405: register int prob;
406: register struct room *rp;
407:
408: if ((prob = monsters[tp->t_type - 'A'].m_carry) <= 0 || tp->t_room == proom
409: || see_monst(tp))
410: return &hero;
411: rp = tp->t_room;
412: for (obj = lvl_obj; obj != NULL; obj = next(obj))
413: {
414: if (obj->o_type == SCROLL && obj->o_which == S_SCARE)
415: continue;
416: if (roomin(&obj->o_pos) == rp && rnd(100) < prob)
417: {
418: for (tp = mlist; tp != NULL; tp = next(tp))
419: if (tp->t_dest == &obj->o_pos)
420: break;
421: if (tp == NULL)
422: return &obj->o_pos;
423: }
424: }
425: return &hero;
426: }