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