Annotation of early-roguelike/rogue3/chase.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Code for one object to chase another
! 3: *
! 4: * @(#)chase.c 3.17 (Berkeley) 6/15/81
! 5: *
! 6: * Rogue: Exploring the Dungeons of Doom
! 7: * Copyright (C) 1980, 1981 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 "curses.h"
! 14: #include "rogue.h"
! 15:
! 16: coord ch_ret; /* Where chasing takes you */
! 17:
! 18: /*
! 19: * runners:
! 20: * Make all the running monsters move.
! 21: */
! 22:
! 23: void
! 24: runners()
! 25: {
! 26: struct linked_list *item;
! 27: struct thing *tp;
! 28:
! 29: for (item = mlist; item != NULL;)
! 30: {
! 31: tp = (struct thing *) ldata(item);
! 32: item = next(item);
! 33: if (off(*tp, ISHELD) && on(*tp, ISRUN))
! 34: {
! 35: if (off(*tp, ISSLOW) || tp->t_turn)
! 36: if (do_chase(tp) == -1)
! 37: continue;
! 38: if (on(*tp, ISHASTE))
! 39: if (do_chase(tp) == -1)
! 40: continue;
! 41: tp->t_turn ^= TRUE;
! 42: }
! 43: }
! 44: }
! 45:
! 46: /*
! 47: * do_chase:
! 48: * Make one thing chase another.
! 49: */
! 50:
! 51: int
! 52: do_chase(struct thing *th)
! 53: {
! 54: struct room *rer, *ree; /* room of chaser, room of chasee */
! 55: int mindist = 32767, i, dist;
! 56: int stoprun = FALSE; /* TRUE means we are there */
! 57: int sch;
! 58: coord this; /* Temporary destination for chaser */
! 59:
! 60: rer = roomin(&th->t_pos); /* Find room of chaser */
! 61: ree = roomin(th->t_dest); /* Find room of chasee */
! 62: /*
! 63: * We don't count doors as inside rooms for this routine
! 64: */
! 65: if (mvwinch(stdscr, th->t_pos.y, th->t_pos.x) == DOOR)
! 66: rer = NULL;
! 67: this = *th->t_dest;
! 68: /*
! 69: * If the object of our desire is in a different room,
! 70: * than we are and we ar not in a corridor, run to the
! 71: * door nearest to our goal.
! 72: */
! 73: if (rer != NULL && rer != ree)
! 74: for (i = 0; i < rer->r_nexits; i++) /* loop through doors */
! 75: {
! 76: dist = DISTANCE(th->t_dest->y, th->t_dest->x,
! 77: rer->r_exit[i].y, rer->r_exit[i].x);
! 78: if (dist < mindist) /* minimize distance */
! 79: {
! 80: this = rer->r_exit[i];
! 81: mindist = dist;
! 82: }
! 83: }
! 84: /*
! 85: * this now contains what we want to run to this time
! 86: * so we run to it. If we hit it we either want to fight it
! 87: * or stop running
! 88: */
! 89: if (!chase(th, &this))
! 90: {
! 91: if (ce(this, hero))
! 92: {
! 93: return( attack(th) );
! 94: }
! 95: else if (th->t_type != 'F')
! 96: stoprun = TRUE;
! 97: }
! 98: else if (th->t_type == 'F')
! 99: return(0);
! 100: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
! 101: sch = mvwinch(cw, ch_ret.y, ch_ret.x);
! 102: if (rer != NULL && (rer->r_flags & ISDARK) && sch == FLOOR
! 103: && DISTANCE(ch_ret.y, ch_ret.x, th->t_pos.y, th->t_pos.x) < 3
! 104: && off(player, ISBLIND))
! 105: th->t_oldch = ' ';
! 106: else
! 107: th->t_oldch = sch;
! 108:
! 109: if (cansee(unc(ch_ret)) && !on(*th, ISINVIS))
! 110: mvwaddch(cw, ch_ret.y, ch_ret.x, th->t_type);
! 111: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
! 112: mvwaddch(mw, ch_ret.y, ch_ret.x, th->t_type);
! 113: th->t_pos = ch_ret;
! 114: /*
! 115: * And stop running if need be
! 116: */
! 117: if (stoprun && ce(th->t_pos, *(th->t_dest)))
! 118: th->t_flags &= ~ISRUN;
! 119:
! 120: return(0);
! 121: }
! 122:
! 123: /*
! 124: * runto:
! 125: * Set a mosnter running after something
! 126: * or stop it from running (for when it dies)
! 127: */
! 128:
! 129: void
! 130: runto(coord *runner, coord *spot)
! 131: {
! 132: struct linked_list *item;
! 133: struct thing *tp;
! 134:
! 135: /*
! 136: * If we couldn't find him, something is funny
! 137: */
! 138: if ((item = find_mons(runner->y, runner->x)) == NULL)
! 139: {
! 140: msg("CHASER '%s'", unctrl(winat(runner->y, runner->x)));
! 141: return;
! 142: }
! 143: tp = (struct thing *) ldata(item);
! 144: /*
! 145: * Start the beastie running
! 146: */
! 147: tp->t_dest = spot;
! 148: tp->t_flags |= ISRUN;
! 149: tp->t_flags &= ~ISHELD;
! 150: }
! 151:
! 152: /*
! 153: * chase:
! 154: * Find the spot for the chaser(er) to move closer to the
! 155: * chasee(ee). Returns TRUE if we want to keep on chasing later
! 156: * FALSE if we reach the goal.
! 157: */
! 158:
! 159: int
! 160: chase(struct thing *tp, coord *ee)
! 161: {
! 162: int x, y;
! 163: int dist, thisdist;
! 164: struct linked_list *item;
! 165: struct object *obj = NULL;
! 166: coord *er = &tp->t_pos;
! 167: int ch;
! 168:
! 169: /*
! 170: * If the thing is confused, let it move randomly. Invisible
! 171: * Stalkers are slightly confused all of the time, and bats are
! 172: * quite confused all the time
! 173: */
! 174: if ((on(*tp, ISHUH) && rnd(10) < 8) || (tp->t_type == 'I' && rnd(100) < 20)
! 175: || (tp->t_type == 'B' && rnd(100) < 50))
! 176: {
! 177: /*
! 178: * get a valid random move
! 179: */
! 180: ch_ret = *rndmove(tp);
! 181: dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);
! 182: /*
! 183: * Small chance that it will become un-confused
! 184: */
! 185: if (rnd(1000) < 50)
! 186: tp->t_flags &= ~ISHUH;
! 187: }
! 188: /*
! 189: * Otherwise, find the empty spot next to the chaser that is
! 190: * closest to the chasee.
! 191: */
! 192: else
! 193: {
! 194: int ey, ex;
! 195: /*
! 196: * This will eventually hold where we move to get closer
! 197: * If we can't find an empty spot, we stay where we are.
! 198: */
! 199: dist = DISTANCE(er->y, er->x, ee->y, ee->x);
! 200: ch_ret = *er;
! 201:
! 202: ey = er->y + 1;
! 203: ex = er->x + 1;
! 204: for (x = er->x - 1; x <= ex; x++)
! 205: for (y = er->y - 1; y <= ey; y++)
! 206: {
! 207: coord tryp;
! 208:
! 209: tryp.x = x;
! 210: tryp.y = y;
! 211: if (!diag_ok(er, &tryp))
! 212: continue;
! 213: ch = winat(y, x);
! 214: if (step_ok(ch))
! 215: {
! 216: /*
! 217: * If it is a scroll, it might be a scare monster scroll
! 218: * so we need to look it up to see what type it is.
! 219: */
! 220: if (ch == SCROLL)
! 221: {
! 222: for (item = lvl_obj; item != NULL; item = next(item))
! 223: {
! 224: obj = (struct object *) ldata(item);
! 225: if (y == obj->o_pos.y && x == obj->o_pos.x)
! 226: break;
! 227: }
! 228: if (item != NULL && obj->o_which == S_SCARE)
! 229: continue;
! 230: }
! 231: /*
! 232: * If we didn't find any scrolls at this place or it
! 233: * wasn't a scare scroll, then this place counts
! 234: */
! 235: thisdist = DISTANCE(y, x, ee->y, ee->x);
! 236: if (thisdist < dist)
! 237: {
! 238: ch_ret = tryp;
! 239: dist = thisdist;
! 240: }
! 241: }
! 242: }
! 243: }
! 244: return (dist != 0);
! 245: }
! 246:
! 247: /*
! 248: * roomin:
! 249: * Find what room some coordinates are in. NULL means they aren't
! 250: * in any room.
! 251: */
! 252:
! 253: struct room *
! 254: roomin(coord *cp)
! 255: {
! 256: struct room *rp;
! 257:
! 258: for (rp = rooms; rp <= &rooms[MAXROOMS-1]; rp++)
! 259: if (inroom(rp, cp))
! 260: return rp;
! 261: return NULL;
! 262: }
! 263:
! 264: /*
! 265: * find_mons:
! 266: * Find the monster from his corrdinates
! 267: */
! 268:
! 269: struct linked_list *
! 270: find_mons(int y, int x)
! 271: {
! 272: struct linked_list *item;
! 273: struct thing *th;
! 274:
! 275: for (item = mlist; item != NULL; item = next(item))
! 276: {
! 277: th = (struct thing *) ldata(item);
! 278: if (th->t_pos.y == y && th->t_pos.x == x)
! 279: return item;
! 280: }
! 281: return NULL;
! 282: }
! 283:
! 284: /*
! 285: * diag_ok:
! 286: * Check to see if the move is legal if it is diagonal
! 287: */
! 288:
! 289: int
! 290: diag_ok(coord *sp, coord *ep)
! 291: {
! 292: if (ep->x == sp->x || ep->y == sp->y)
! 293: return TRUE;
! 294: return (step_ok(mvinch(ep->y, sp->x)) && step_ok(mvinch(sp->y, ep->x)));
! 295: }
! 296:
! 297: /*
! 298: * cansee:
! 299: * returns true if the hero can see a certain coordinate.
! 300: */
! 301:
! 302: int
! 303: cansee(int y, int x)
! 304: {
! 305: struct room *rer;
! 306: coord tp;
! 307:
! 308: if (on(player, ISBLIND))
! 309: return FALSE;
! 310: tp.y = y;
! 311: tp.x = x;
! 312: rer = roomin(&tp);
! 313: /*
! 314: * We can only see if the hero in the same room as
! 315: * the coordinate and the room is lit or if it is close.
! 316: */
! 317: return (rer != NULL && rer == roomin(&hero) && !(rer->r_flags&ISDARK)) ||
! 318: DISTANCE(y, x, hero.y, hero.x) < 3;
! 319: }
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 / rogue3