Annotation of early-roguelike/arogue7/util.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * util.c - all sorts of miscellaneous routines
! 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: #include "curses.h"
! 16: #include "rogue.h"
! 17: #include <ctype.h>
! 18: #include <string.h>
! 19: #ifdef PC7300
! 20: #include <track.h>
! 21: #include <kcodes.h>
! 22: #include <sys/window.h>
! 23: extern struct uwdata wdata;
! 24: #endif
! 25:
! 26: /*
! 27: * all sorts of miscellaneous routines
! 28: *
! 29: */
! 30:
! 31:
! 32:
! 33:
! 34: /*
! 35: * this routine computes the players current AC without dex bonus's
! 36: */
! 37: int
! 38: ac_compute(bool ignoremetal)
! 39: {
! 40: register int ac;
! 41:
! 42: ac = pstats.s_arm; /* base armor of "skin" */
! 43: if (cur_armor) {
! 44: if (!ignoremetal ||
! 45: (cur_armor->o_which != LEATHER &&
! 46: cur_armor->o_which != STUDDED_LEATHER &&
! 47: cur_armor->o_which != PADDED_ARMOR))
! 48: ac -= (10 - cur_armor->o_ac);
! 49: }
! 50: if (player.t_ctype == C_MONK)
! 51: ac -= pstats.s_lvl * 2 / 3;
! 52: ac -= ring_value(R_PROTECT);
! 53: if (cur_misc[WEAR_BRACERS] != NULL)
! 54: ac -= cur_misc[WEAR_BRACERS]->o_ac;
! 55: if (cur_misc[WEAR_CLOAK] != NULL)
! 56: ac -= cur_misc[WEAR_CLOAK]->o_ac;
! 57:
! 58: /* If player has the cloak, must be wearing it */
! 59: if (cur_relic[EMORI_CLOAK]) ac -= 5;
! 60:
! 61: if (ac > 10)
! 62: ac = 10;
! 63: return(ac);
! 64: }
! 65:
! 66: /*
! 67: * aggravate:
! 68: * aggravate all the monsters on this level
! 69: */
! 70:
! 71: void
! 72: aggravate(bool do_uniques, bool do_good)
! 73: {
! 74: register struct linked_list *mi;
! 75: register struct thing *thingptr;
! 76:
! 77: for (mi = mlist; mi != NULL; mi = next(mi)) {
! 78: thingptr = THINGPTR(mi);
! 79: if (do_good == FALSE && off(*thingptr, ISMEAN)) continue;
! 80: if (do_uniques || off(*thingptr, ISUNIQUE)) runto(thingptr, &hero);
! 81: }
! 82: }
! 83:
! 84: /*
! 85: * cansee:
! 86: * returns true if the hero can see a certain coordinate.
! 87: */
! 88:
! 89: bool
! 90: cansee(int y, int x)
! 91: {
! 92: register struct room *rer;
! 93: register int radius;
! 94: coord tp;
! 95:
! 96: if (on(player, ISBLIND))
! 97: return FALSE;
! 98:
! 99: tp.y = y;
! 100: tp.x = x;
! 101: rer = roomin(&tp);
! 102:
! 103: /* How far can we see? */
! 104: if (levtype == OUTSIDE) {
! 105: if (daytime) radius = 36;
! 106: else if (lit_room(rer)) radius = 9;
! 107: else radius = 3;
! 108: }
! 109: else radius = 3;
! 110:
! 111: /*
! 112: * We can only see if the hero in the same room as
! 113: * the coordinate and the room is lit or if it is close.
! 114: */
! 115: return ((rer != NULL &&
! 116: levtype != OUTSIDE &&
! 117: (levtype != MAZELEV || /* Maze level needs direct line */
! 118: maze_view(tp.y, tp.x)) &&
! 119: rer == roomin(&hero) &&
! 120: lit_room(rer)) ||
! 121: DISTANCE(y, x, hero.y, hero.x) < radius);
! 122: }
! 123:
! 124: /*
! 125: * check_level:
! 126: * Check to see if the guy has gone up a level.
! 127: *
! 128: * Return points needed to obtain next level.
! 129: *
! 130: * These are certain beginning experience levels for all players.
! 131: * All further experience levels are computed by muliplying by 2
! 132: * up through MAXDOUBLE. Then the cap is added in to compute
! 133: * further levels
! 134: */
! 135: long
! 136: check_level(void)
! 137: {
! 138: register int i, j, add = 0;
! 139: register unsigned long exp;
! 140: long retval; /* Return value */
! 141: int nsides;
! 142:
! 143: pstats.s_lvl -= pstats.s_lvladj; /* correct for level adjustment */
! 144: /* See if we are past the doubling stage */
! 145: exp = char_class[player.t_ctype].cap;
! 146: if (pstats.s_exp >= exp) {
! 147: i = pstats.s_exp/exp; /* First get amount above doubling area */
! 148: retval = exp + i * exp; /* Compute next higher boundary */
! 149: i += MAXDOUBLE; /* Add in the previous doubled levels */
! 150: }
! 151: else {
! 152: i = 0;
! 153: exp = char_class[player.t_ctype].start_exp;
! 154: while (exp <= pstats.s_exp) {
! 155: i++;
! 156: exp <<= 1;
! 157: }
! 158: retval = exp;
! 159: }
! 160: if (++i > pstats.s_lvl) {
! 161: nsides = char_class[player.t_ctype].hit_pts;
! 162: for (j=0; j<(i-pstats.s_lvl); j++) /* Take care of multi-level jumps */
! 163: add += max(1, roll(1,nsides) + const_bonus());
! 164: max_stats.s_hpt += add;
! 165: if ((pstats.s_hpt += add) > max_stats.s_hpt)
! 166: pstats.s_hpt = max_stats.s_hpt;
! 167: msg("Welcome, %s, to level %d",
! 168: cnames[player.t_ctype][min(i-1, NUM_CNAMES-1)], i);
! 169: }
! 170: pstats.s_lvl = i;
! 171: pstats.s_lvl += pstats.s_lvladj; /* correct for level adjustment */
! 172: return(retval);
! 173: }
! 174:
! 175: /*
! 176: * Used to modify the players strength
! 177: * it keeps track of the highest it has been, just in case
! 178: */
! 179:
! 180: void
! 181: chg_str(int amt)
! 182: {
! 183: register int ring_str; /* ring strengths */
! 184: register struct stats *ptr; /* for speed */
! 185:
! 186: ptr = &pstats;
! 187: ring_str = ring_value(R_ADDSTR);
! 188: ptr->s_str -= ring_str;
! 189: ptr->s_str += amt;
! 190: if (ptr->s_str > 25)
! 191: ptr->s_str = 25;
! 192: if (ptr->s_str > max_stats.s_str)
! 193: max_stats.s_str = ptr->s_str;
! 194: ptr->s_str += ring_str;
! 195: if (ptr->s_str <= 0)
! 196: death(D_STRENGTH);
! 197: updpack(TRUE, &player);
! 198: }
! 199:
! 200: /*
! 201: * let's confuse the player
! 202: */
! 203: void
! 204: confus_player(void)
! 205: {
! 206: if (off(player, ISCLEAR))
! 207: {
! 208: msg("Wait, what's going on here. Huh? What? Who?");
! 209: if (find_slot(unconfuse))
! 210: lengthen(unconfuse, HUHDURATION);
! 211: else
! 212: fuse(unconfuse, NULL, HUHDURATION, AFTER);
! 213: turn_on(player, ISHUH);
! 214: }
! 215: else msg("You feel dizzy for a moment, but it quickly passes.");
! 216: }
! 217:
! 218: /*
! 219: * this routine computes the players current dexterity
! 220: */
! 221: int
! 222: dex_compute(void)
! 223: {
! 224: if (cur_misc[WEAR_GAUNTLET] != NULL &&
! 225: cur_misc[WEAR_GAUNTLET]->o_which == MM_G_DEXTERITY) {
! 226: if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
! 227: return (3);
! 228: else
! 229: return (18);
! 230: }
! 231: else
! 232: return (pstats.s_dext);
! 233: }
! 234:
! 235: /*
! 236: * diag_ok:
! 237: * Check to see if the move is legal if it is diagonal
! 238: */
! 239:
! 240: bool
! 241: diag_ok(coord *sp, coord *ep, struct thing *flgptr)
! 242: {
! 243: register int numpaths = 0;
! 244:
! 245: /* Horizontal and vertical moves are always ok */
! 246: if (ep->x == sp->x || ep->y == sp->y)
! 247: return TRUE;
! 248:
! 249: /* Diagonal moves are not allowed if there is a horizontal or
! 250: * vertical path to the destination
! 251: */
! 252: if (step_ok(ep->y, sp->x, MONSTOK, flgptr)) numpaths++;
! 253: if (step_ok(sp->y, ep->x, MONSTOK, flgptr)) numpaths++;
! 254: return(numpaths != 1);
! 255: }
! 256:
! 257: /*
! 258: * pick a random position around the give (y, x) coordinates
! 259: */
! 260: coord *
! 261: fallpos(coord *pos, bool be_clear, int range)
! 262: {
! 263: register int tried, i, j;
! 264: register char ch;
! 265: static coord ret;
! 266: static short masks[] = {
! 267: 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100 };
! 268:
! 269: /*
! 270: * Pick a spot at random centered on the position given by 'pos' and
! 271: * up to 'range' squares away from 'pos'
! 272: *
! 273: * If 'be_clear' is TRUE, the spot must be either FLOOR or PASSAGE
! 274: * inorder to be considered valid
! 275: *
! 276: *
! 277: * Generate a number from 0 to 8, representing the position to pick.
! 278: * Note that this DOES include the positon 'pos' itself
! 279: *
! 280: * If this position is not valid, mark it as 'tried', and pick another.
! 281: * Whenever a position is picked that has been tried before,
! 282: * sequentially find the next untried position. This eliminates costly
! 283: * random number generation
! 284: */
! 285:
! 286: tried = 0;
! 287: while( tried != 0x1ff ) {
! 288: i = rnd(9);
! 289: while( tried & masks[i] )
! 290: i = (i + 1) % 9;
! 291:
! 292: tried |= masks[i];
! 293:
! 294: for( j = 1; j <= range; j++ ) {
! 295: ret.x = pos->x + j*grid[i].x;
! 296: ret.y = pos->y + j*grid[i].y;
! 297:
! 298: if (ret.x == hero.x && ret.y == hero.y)
! 299: continue; /* skip the hero */
! 300:
! 301: if (ret.x < 0 || ret.x > cols - 1 ||
! 302: ret.y < 1 || ret.y > lines - 3)
! 303: continue; /* off the screen? */
! 304:
! 305: ch = CCHAR( winat(ret.y, ret.x) );
! 306:
! 307: /*
! 308: * Check to make certain the spot is valid
! 309: */
! 310: switch( ch ) {
! 311: case FLOOR:
! 312: case PASSAGE:
! 313: return( &ret );
! 314: case GOLD:
! 315: case SCROLL:
! 316: case POTION:
! 317: case STICK:
! 318: case RING:
! 319: case WEAPON:
! 320: case ARMOR:
! 321: case MM:
! 322: case FOOD:
! 323: if(!be_clear && levtype != POSTLEV)
! 324: return( &ret );
! 325: default:
! 326: break;
! 327: }
! 328: }
! 329: }
! 330: return( NULL );
! 331: }
! 332:
! 333:
! 334: /*
! 335: * findmindex:
! 336: * Find the index into the monster table of a monster given its name.
! 337: */
! 338:
! 339: int
! 340: findmindex(char *name)
! 341: {
! 342: int which;
! 343:
! 344: for (which=1; which<NUMMONST; which++) {
! 345: if (strcmp(name, monsters[which].m_name) == 0)
! 346: break;
! 347: }
! 348: if (which >= NUMMONST) {
! 349: debug("couldn't find monster index");
! 350: which = 1;
! 351: }
! 352: return(which);
! 353: }
! 354:
! 355: /*
! 356: * find_mons:
! 357: * Find the monster from his coordinates
! 358: */
! 359:
! 360: struct linked_list *
! 361: find_mons(int y, int x)
! 362: {
! 363: register struct linked_list *item;
! 364: register struct thing *th;
! 365:
! 366: for (item = mlist; item != NULL; item = next(item))
! 367: {
! 368: th = THINGPTR(item);
! 369: if (th->t_pos.y == y && th->t_pos.x == x)
! 370: return item;
! 371: }
! 372: return NULL;
! 373: }
! 374:
! 375: /*
! 376: * find_obj:
! 377: * find the unclaimed object at y, x
! 378: */
! 379:
! 380: struct linked_list *
! 381: find_obj(int y, int x)
! 382: {
! 383: register struct linked_list *obj;
! 384: register struct object *op;
! 385:
! 386: for (obj = lvl_obj; obj != NULL; obj = next(obj))
! 387: {
! 388: op = OBJPTR(obj);
! 389: if (op->o_pos.y == y && op->o_pos.x == x)
! 390: return obj;
! 391: }
! 392: return NULL;
! 393: }
! 394:
! 395: /*
! 396: * get coordinates from the player using the cursor keys (or mouse)
! 397: */
! 398: coord
! 399: get_coordinates(void)
! 400: {
! 401: register int which;
! 402: coord c;
! 403: #ifdef PC7300
! 404: struct umdata startmouse, listenmouse; /* Mouse parameters */
! 405: int xmouse, /* x-position of mouse */
! 406: ymouse, /* y-position of mouse */
! 407: bmouse, /* button value of mouse */
! 408: rmouse; /* reason for mouse change */
! 409: #endif
! 410:
! 411: c = hero;
! 412: wmove(cw, hero.y, hero.x);
! 413: draw(cw);
! 414: #ifdef PC7300
! 415: keypad(0, 1); /* Turn on escape sequences */
! 416: ioctl(0, WIOCGETMOUSE, &startmouse); /* Get current mouse parameters */
! 417: listenmouse = startmouse; /* Make a copy */
! 418: listenmouse.um_flags |= MSDOWN; /* Enable detection of button down */
! 419: ioctl(0, WIOCSETMOUSE, &listenmouse); /* Make the change */
! 420: #endif
! 421: for (;;) {
! 422: #ifdef PC7300
! 423: which = wgetc(0);
! 424: #else
! 425: which = (getchar() & 0177);
! 426: #endif
! 427: switch(which) {
! 428: #ifdef PC7300
! 429: case Home:
! 430: c.x = 0; c.y = 1;
! 431: when Beg:
! 432: c.x = 0;
! 433: when End:
! 434: c.x = cols - 1;
! 435: when Mouse:
! 436: case ESCAPE:
! 437: case Cancl:
! 438: case s_Cancl:
! 439: if (which == Mouse) {
! 440: if (wreadmouse(0,&xmouse,&ymouse,&bmouse,&rmouse) != 0 ||
! 441: (rmouse & MSDOWN) == 0)
! 442: break;
! 443: c.y = ymouse / wdata.uw_vs;
! 444: c.x = xmouse / wdata.uw_hs;
! 445: c.y = max(c.y, 1);
! 446: c.y = min(c.y, lines - 3);
! 447: c.x = max(c.x, 0);
! 448: c.x = min(c.x, cols - 1);
! 449: }
! 450: else c = hero;
! 451: wmove(cw, c.y, c.x);
! 452: draw(cw);
! 453: case '\n':
! 454: case '\c':
! 455: keypad(0, 0); /* Turn off escape interpretation */
! 456: ioctl(0, WIOCSETMOUSE, &startmouse); /* No mouse tracking */
! 457: return(c);
! 458: when 'h':
! 459: case 'H':
! 460: case Back:
! 461: case s_Back:
! 462: c.x--;
! 463: when 'j':
! 464: case 'J':
! 465: case Down:
! 466: case RollDn:
! 467: c.y++;
! 468: when 'k':
! 469: case 'K':
! 470: case Up:
! 471: case RollUp:
! 472: c.y--;
! 473: when 'l':
! 474: case 'L':
! 475: case Forward:
! 476: case s_Forward:
! 477: c.x++;
! 478: when 'y':
! 479: case 'Y':
! 480: case Prev:
! 481: c.x--; c.y--;
! 482: when 'u':
! 483: case 'U':
! 484: case Next:
! 485: c.x++; c.y--;
! 486: when 'b':
! 487: case 'B':
! 488: case s_Prev:
! 489: c.x--; c.y++;
! 490: when 'n':
! 491: case 'N':
! 492: case s_Next:
! 493: c.x++; c.y++;
! 494: when '*':
! 495: msg("Select location via mouse, or");
! 496: msg("Use cursor keys,h,j,k,l,y,u,b,or n, then hit return.");
! 497: #else
! 498: case ESCAPE:
! 499: c = hero;
! 500: wmove(cw, c.y, c.x);
! 501: draw(cw);
! 502: case '\n':
! 503: case '\r':
! 504: return(c);
! 505: when 'h':
! 506: case 'H':
! 507: c.x--;
! 508: when 'j':
! 509: case 'J':
! 510: c.y++;
! 511: when 'k':
! 512: case 'K':
! 513: c.y--;
! 514: when 'l':
! 515: case 'L':
! 516: c.x++;
! 517: when 'y':
! 518: case 'Y':
! 519: c.x--; c.y--;
! 520: when 'u':
! 521: case 'U':
! 522: c.x++; c.y--;
! 523: when 'b':
! 524: case 'B':
! 525: c.x--; c.y++;
! 526: when 'n':
! 527: case 'N':
! 528: c.x++; c.y++;
! 529: when '*':
! 530: msg("Use h,j,k,l,y,u,b,n to position cursor, then hit return.");
! 531: #endif
! 532: }
! 533: c.y = max(c.y, 1);
! 534: c.y = min(c.y, lines - 3);
! 535: c.x = max(c.x, 0);
! 536: c.x = min(c.x, cols - 1);
! 537: wmove(cw, c.y, c.x);
! 538: draw(cw);
! 539: }
! 540: }
! 541:
! 542: /*
! 543: * set up the direction co_ordinate for use in various "prefix" commands
! 544: */
! 545: bool
! 546: get_dir(coord *direction)
! 547: {
! 548: register char *prompt;
! 549: register bool gotit;
! 550: int x,y;
! 551:
! 552: prompt = terse ? "Direction?" : "Which direction? ";
! 553: msg(prompt);
! 554: do
! 555: {
! 556: gotit = TRUE;
! 557: switch (md_readchar(msgw))
! 558: {
! 559: case 'h': case'H': direction->y = 0; direction->x = -1;
! 560: when 'j': case'J': direction->y = 1; direction->x = 0;
! 561: when 'k': case'K': direction->y = -1; direction->x = 0;
! 562: when 'l': case'L': direction->y = 0; direction->x = 1;
! 563: when 'y': case'Y': direction->y = -1; direction->x = -1;
! 564: when 'u': case'U': direction->y = -1; direction->x = 1;
! 565: when 'b': case'B': direction->y = 1; direction->x = -1;
! 566: when 'n': case'N': direction->y = 1; direction->x = 1;
! 567: case 0:
! 568: when 3: quit(0);
! 569: return(FALSE);
! 570: when ESCAPE: return (FALSE);
! 571: otherwise:
! 572: mpos = 0;
! 573: msg(prompt);
! 574: gotit = FALSE;
! 575: }
! 576: } until (gotit);
! 577: if ((on(player, ISHUH) || on(player, ISDANCE)) && rnd(100) > 20) {
! 578: do
! 579: {
! 580: *direction = grid[rnd(9)];
! 581: } while (direction->y == 0 && direction->x == 0);
! 582: }
! 583: else if (on(player, ISFLEE)) {
! 584: y = hero.y;
! 585: x = hero.x;
! 586: while (shoot_ok(winat(y, x))) {
! 587: y += direction->y;
! 588: x += direction->x;
! 589: }
! 590: if (isalpha(mvwinch(mw, y, x))) {
! 591: if (y == player.t_dest->y && x == player.t_dest->x) {
! 592: mpos = 0;
! 593: msg("You are too frightened to!");
! 594: return(FALSE);
! 595: }
! 596: }
! 597: }
! 598: mpos = 0;
! 599: return TRUE;
! 600: }
! 601:
! 602: /*
! 603: * see if the object is one of the currently used items
! 604: */
! 605: bool
! 606: is_current(struct object *obj)
! 607: {
! 608: if (obj == NULL)
! 609: return FALSE;
! 610: if (obj == cur_armor || obj == cur_weapon ||
! 611: obj == cur_ring[LEFT_1] || obj == cur_ring[LEFT_2] ||
! 612: obj == cur_ring[LEFT_3] || obj == cur_ring[LEFT_4] ||
! 613: obj == cur_ring[RIGHT_1] || obj == cur_ring[RIGHT_2] ||
! 614: obj == cur_ring[RIGHT_3] || obj == cur_ring[RIGHT_4] ||
! 615: obj == cur_misc[WEAR_BOOTS] || obj == cur_misc[WEAR_JEWEL] ||
! 616: obj == cur_misc[WEAR_BRACERS] || obj == cur_misc[WEAR_CLOAK] ||
! 617: obj == cur_misc[WEAR_GAUNTLET] || obj == cur_misc[WEAR_NECKLACE]) {
! 618:
! 619: return TRUE;
! 620: }
! 621:
! 622: /* Is it a "current" relic? */
! 623: if (obj->o_type == RELIC) {
! 624: switch (obj->o_which) {
! 625: case MUSTY_DAGGER:
! 626: case EMORI_CLOAK:
! 627: case HEIL_ANKH:
! 628: case YENDOR_AMULET:
! 629: case STONEBONES_AMULET:
! 630: case HRUGGEK_MSTAR:
! 631: case AXE_AKLAD:
! 632: case YEENOGHU_FLAIL:
! 633: case SURTUR_RING:
! 634: if (cur_relic[obj->o_which]) return TRUE;
! 635: }
! 636: }
! 637:
! 638: return FALSE;
! 639: }
! 640:
! 641:
! 642: /*
! 643: * Look:
! 644: * A quick glance all around the player
! 645: * wakeup: Should we wake up monsters
! 646: * runend: At end of a run -- for mazes
! 647: */
! 648:
! 649: void
! 650: look(bool wakeup, bool runend)
! 651: {
! 652: register int x, y, radius;
! 653: register char ch, och;
! 654: register int oldx, oldy;
! 655: register bool inpass, horiz, vert, do_light = FALSE, do_blank = FALSE;
! 656: register int passcount = 0, curfloorcount = 0, nextfloorcount = 0;
! 657: register struct room *rp;
! 658: register int ey, ex;
! 659:
! 660: inpass = ((rp = roomin(&hero)) == NULL); /* Are we in a passage? */
! 661:
! 662: /* Are we moving vertically or horizontally? */
! 663: if (runch == 'h' || runch == 'l') horiz = TRUE;
! 664: else horiz = FALSE;
! 665: if (runch == 'j' || runch == 'k') vert = TRUE;
! 666: else vert = FALSE;
! 667:
! 668: /* How far around himself can the player see? */
! 669: if (levtype == OUTSIDE) {
! 670: if (daytime) radius = 6;
! 671: else if (lit_room(rp)) radius = 3;
! 672: else radius = 1;
! 673: }
! 674: else radius = 1;
! 675:
! 676: getyx(cw, oldy, oldx); /* Save current position */
! 677:
! 678: /* Blank out the floor around our last position and check for
! 679: * moving out of a corridor in a maze.
! 680: */
! 681: if (levtype == OUTSIDE) do_blank = !daytime;
! 682: else if (oldrp != NULL && !lit_room(oldrp) && off(player, ISBLIND))
! 683: do_blank = TRUE;
! 684:
! 685: /* Now move around the old position and blank things out */
! 686: ey = player.t_oldpos.y + radius;
! 687: ex = player.t_oldpos.x + radius;
! 688: for (x = player.t_oldpos.x - radius; x <= ex; x++)
! 689: if (x >= 0 && x < cols)
! 690: for (y = player.t_oldpos.y - radius; y <= ey; y++) {
! 691: struct linked_list *it;
! 692: coord here; /* Current <x,y> coordinate */
! 693: char savech; /* Saves character in monster window */
! 694: bool in_room; /* Are we in a room? */
! 695:
! 696: if (y < 1 || y > lines - 3) continue;
! 697:
! 698: /* See what's there -- ignore monsters, just see what they're on */
! 699: savech = CCHAR( mvwinch(mw, y, x) );
! 700: waddch(mw, ' ');
! 701: ch = show(y, x);
! 702: mvwaddch(mw, y, x, savech); /* Restore monster */
! 703:
! 704: /*
! 705: * If we have a monster that we can't see anymore, make sure
! 706: * that we can note that fact.
! 707: */
! 708: if (isalpha(savech) &&
! 709: (y < hero.y - radius || y > hero.y + radius ||
! 710: x < hero.x - radius || x > hero.x + radius)) {
! 711: /* Find the monster */
! 712: it = find_mons(y, x);
! 713: }
! 714: else it = NULL;
! 715:
! 716: /* Are we in a room? */
! 717: here.y = y;
! 718: here.x = x;
! 719: in_room = (roomin(&here) != NULL);
! 720:
! 721: if ((do_blank || !in_room) && (y != hero.y || x != hero.x))
! 722: switch (ch) {
! 723: case DOOR:
! 724: case SECRETDOOR:
! 725: case PASSAGE:
! 726: case STAIRS:
! 727: case TRAPDOOR:
! 728: case TELTRAP:
! 729: case BEARTRAP:
! 730: case SLEEPTRAP:
! 731: case ARROWTRAP:
! 732: case DARTTRAP:
! 733: case MAZETRAP:
! 734: case POOL:
! 735: case POST:
! 736: case '|':
! 737: case '-':
! 738: case WALL:
! 739: /* If there was a monster showing, make it disappear */
! 740: if (isalpha(savech)) {
! 741: mvwaddch(cw, y, x, ch);
! 742:
! 743: /*
! 744: * If we found it (we should!), set it to
! 745: * the right character!
! 746: */
! 747: if (it) (THINGPTR(it))->t_oldch = ch;
! 748: }
! 749: break;
! 750: when FLOOR:
! 751: case FOREST:
! 752: default:
! 753: mvwaddch(cw, y, x, in_room ? ' ' : PASSAGE);
! 754:
! 755: /* If we found a monster, set it to darkness! */
! 756: if (it) (THINGPTR(it))->t_oldch = CCHAR( mvwinch(cw, y, x) );
! 757: }
! 758:
! 759: /* Moving out of a corridor? */
! 760: if (levtype == MAZELEV && !ce(hero, player.t_oldpos) &&
! 761: !running && !isrock(ch) && /* Not running and not a wall */
! 762: ((vert && x != player.t_oldpos.x && y==player.t_oldpos.y) ||
! 763: (horiz && y != player.t_oldpos.y && x==player.t_oldpos.x)))
! 764: do_light = off(player, ISBLIND);
! 765: }
! 766:
! 767: /* Take care of unlighting a corridor */
! 768: if (do_light && lit_room(rp)) light(&player.t_oldpos);
! 769:
! 770: /* Are we coming or going between a wall and a corridor in a maze? */
! 771: och = show(player.t_oldpos.y, player.t_oldpos.x);
! 772: ch = show(hero.y, hero.x);
! 773: if (levtype == MAZELEV &&
! 774: ((isrock(och) && !isrock(ch)) || (isrock(ch) && !isrock(och)))) {
! 775: do_light = off(player, ISBLIND); /* Light it up if not blind */
! 776:
! 777: /* Unlight what we just saw */
! 778: if (do_light && lit_room(&rooms[0])) light(&player.t_oldpos);
! 779: }
! 780:
! 781: /* Look around the player */
! 782: ey = hero.y + radius;
! 783: ex = hero.x + radius;
! 784: for (x = hero.x - radius; x <= ex; x++)
! 785: if (x >= 0 && x < cols) for (y = hero.y - radius; y <= ey; y++) {
! 786: if (y < 1 || y >= lines - 2)
! 787: continue;
! 788: if (isalpha(mvwinch(mw, y, x)))
! 789: {
! 790: register struct linked_list *it;
! 791: register struct thing *tp;
! 792:
! 793: if (wakeup)
! 794: it = wake_monster(y, x);
! 795: else
! 796: it = find_mons(y, x);
! 797:
! 798: if (it) {
! 799: tp = THINGPTR(it);
! 800: tp->t_oldch = CCHAR( mvinch(y, x) );
! 801: if (isatrap(tp->t_oldch)) {
! 802: register struct trap *trp = trap_at(y, x);
! 803:
! 804: tp->t_oldch = (trp->tr_flags & ISFOUND) ? tp->t_oldch
! 805: : trp->tr_show;
! 806: }
! 807: if (tp->t_oldch == FLOOR && !lit_room(rp) &&
! 808: off(player, ISBLIND))
! 809: tp->t_oldch = ' ';
! 810: }
! 811: }
! 812:
! 813: /*
! 814: * Secret doors show as walls
! 815: */
! 816: if ((ch = show(y, x)) == SECRETDOOR)
! 817: ch = secretdoor(y, x);
! 818: /*
! 819: * Don't show room walls if he is in a passage and
! 820: * check for maze turns
! 821: */
! 822: if (off(player, ISBLIND))
! 823: {
! 824: if (y == hero.y && x == hero.x
! 825: || (inpass && (ch == '-' || ch == '|')))
! 826: continue;
! 827:
! 828: /* Did we come to a crossroads in a maze? */
! 829: if (levtype == MAZELEV &&
! 830: (runend || !ce(hero, player.t_oldpos)) &&
! 831: !isrock(ch) && /* Not a wall */
! 832: ((vert && x != hero.x && y == hero.y) ||
! 833: (horiz && y != hero.y && x == hero.x)))
! 834: /* Just came to a turn */
! 835: do_light = off(player, ISBLIND);
! 836: }
! 837: else if (y != hero.y || x != hero.x)
! 838: continue;
! 839:
! 840: wmove(cw, y, x);
! 841: waddch(cw, ch);
! 842: if (door_stop && !firstmove && running)
! 843: {
! 844: switch (runch)
! 845: {
! 846: case 'h':
! 847: if (x == hero.x + 1)
! 848: continue;
! 849: when 'j':
! 850: if (y == hero.y - 1)
! 851: continue;
! 852: when 'k':
! 853: if (y == hero.y + 1)
! 854: continue;
! 855: when 'l':
! 856: if (x == hero.x - 1)
! 857: continue;
! 858: when 'y':
! 859: if ((x + y) - (hero.x + hero.y) >= 1)
! 860: continue;
! 861: when 'u':
! 862: if ((y - x) - (hero.y - hero.x) >= 1)
! 863: continue;
! 864: when 'n':
! 865: if ((x + y) - (hero.x + hero.y) <= -1)
! 866: continue;
! 867: when 'b':
! 868: if ((y - x) - (hero.y - hero.x) <= -1)
! 869: continue;
! 870: }
! 871: switch (ch)
! 872: {
! 873: case DOOR:
! 874: if (x == hero.x || y == hero.y)
! 875: running = FALSE;
! 876: break;
! 877: case PASSAGE:
! 878: if (x == hero.x || y == hero.y)
! 879: passcount++;
! 880: break;
! 881: case FLOOR:
! 882: /* Stop by new passages in a maze (floor next to us) */
! 883: if ((levtype == MAZELEV) &&
! 884: !(hero.y == y && hero.x == x)) {
! 885: if (vert) { /* Moving vertically */
! 886: /* We have a passage on our row */
! 887: if (y == hero.y) curfloorcount++;
! 888:
! 889: /* Some passage on the next row */
! 890: else if (y != player.t_oldpos.y)
! 891: nextfloorcount++;
! 892: }
! 893: else { /* Moving horizontally */
! 894: /* We have a passage on our column */
! 895: if (x == hero.x) curfloorcount++;
! 896:
! 897: /* Some passage in the next column */
! 898: else if (x != player.t_oldpos.x)
! 899: nextfloorcount++;
! 900: }
! 901: }
! 902: case '|':
! 903: case '-':
! 904: case ' ':
! 905: break;
! 906: default:
! 907: running = FALSE;
! 908: break;
! 909: }
! 910: }
! 911: }
! 912:
! 913: /* Have we passed a side passage, with multiple choices? */
! 914: if (curfloorcount > 0 && nextfloorcount > 0) running = FALSE;
! 915:
! 916: else if (door_stop && !firstmove && passcount > 1)
! 917: running = FALSE;
! 918:
! 919: /* Do we have to light up the area (just stepped into a new corridor)? */
! 920: if (do_light && !running && lit_room(rp)) light(&hero);
! 921:
! 922: mvwaddch(cw, hero.y, hero.x, PLAYER);
! 923: wmove(cw, oldy, oldx);
! 924: if (!ce(player.t_oldpos, hero)) {
! 925: player.t_oldpos = hero; /* Don't change if we didn't move */
! 926: oldrp = rp;
! 927: }
! 928: }
! 929:
! 930: /*
! 931: * Lower a level of experience
! 932: */
! 933:
! 934: void
! 935: lower_level(short who)
! 936: {
! 937: int fewer, nsides;
! 938: unsigned int exp;
! 939:
! 940: msg("You suddenly feel less skillful.");
! 941: if (--pstats.s_lvl == 0)
! 942: death(who); /* All levels gone */
! 943: if (pstats.s_lvladj > 0) { /* lose artificial levels first */
! 944: pstats.s_lvladj--;
! 945: return;
! 946: }
! 947: exp = char_class[player.t_ctype].cap;
! 948: if (pstats.s_exp >= exp*2)
! 949: pstats.s_exp -= exp;
! 950: else
! 951: pstats.s_exp /= 2;
! 952:
! 953: nsides = char_class[player.t_ctype].hit_pts;
! 954: fewer = max(1, roll(1,nsides) + const_bonus());
! 955: pstats.s_hpt -= fewer;
! 956: max_stats.s_hpt -= fewer;
! 957: if (pstats.s_hpt < 1)
! 958: pstats.s_hpt = 1;
! 959: if (max_stats.s_hpt < 1)
! 960: death(who);
! 961: }
! 962:
! 963: /*
! 964: * print out the name of a monster
! 965: */
! 966: char *
! 967: monster_name(struct thing *tp)
! 968: {
! 969: prbuf[0] = '\0';
! 970: if (on(*tp, ISFLEE) || on(*tp, WASTURNED))
! 971: strcat(prbuf, "terrified ");
! 972: if (on(*tp, ISHUH))
! 973: strcat(prbuf, "confused ");
! 974: if (on(*tp, ISCHARMED))
! 975: strcat(prbuf, "charmed ");
! 976: else if (on(*tp, ISFLY))
! 977: strcat(prbuf, "flying ");
! 978:
! 979: /* If it is sleeping or stoned, write over any of the above attributes */
! 980: if (off(*tp, ISRUN))
! 981: strcpy(prbuf, "sleeping ");
! 982: if (on(*tp, ISSTONE))
! 983: strcpy(prbuf, "petrified ");
! 984:
! 985: if (tp->t_name) strcat(prbuf, tp->t_name);
! 986: else strcat(prbuf, monsters[tp->t_index].m_name);
! 987:
! 988: return(prbuf);
! 989: }
! 990:
! 991: /*
! 992: * move_hero:
! 993: * Try to move the hero somplace besides next to where he is. We ask him
! 994: * where. There can be restrictions based on why he is moving.
! 995: */
! 996:
! 997: bool
! 998: move_hero(int why)
! 999: {
! 1000: char *action = "";
! 1001: char which;
! 1002: coord c;
! 1003:
! 1004: switch (why) {
! 1005: case H_TELEPORT:
! 1006: action = "teleport";
! 1007: }
! 1008:
! 1009: msg("Where do you wish to %s to? (* for help) ", action);
! 1010: c = get_coordinates();
! 1011: mpos = 0;
! 1012: which = CCHAR( winat(c.y, c.x) );
! 1013: switch (which) {
! 1014: default:
! 1015: if (!isrock(which) || off(player, CANINWALL)) break;
! 1016:
! 1017: case FLOOR:
! 1018: case PASSAGE:
! 1019: case DOOR:
! 1020: case STAIRS:
! 1021: case POST:
! 1022: case GOLD:
! 1023: case POTION:
! 1024: case SCROLL:
! 1025: case FOOD:
! 1026: case WEAPON:
! 1027: case ARMOR:
! 1028: case RING:
! 1029: case MM:
! 1030: case RELIC:
! 1031: case STICK:
! 1032: hero = c;
! 1033: return(TRUE);
! 1034: }
! 1035: return(FALSE);
! 1036: }
! 1037:
! 1038: /*
! 1039: * raise_level:
! 1040: * The guy just magically went up a level.
! 1041: */
! 1042:
! 1043: void
! 1044: raise_level(void)
! 1045: {
! 1046: unsigned long test; /* Next level -- be sure it is not an overflow */
! 1047:
! 1048: test = check_level(); /* Get next boundary */
! 1049:
! 1050: /* Be sure it is higher than what we have no -- else overflow */
! 1051: if (test > pstats.s_exp) pstats.s_exp = test;
! 1052: check_level();
! 1053: }
! 1054:
! 1055: /*
! 1056: * saving throw matrix for character saving throws
! 1057: * this table is indexed by char type and saving throw type
! 1058: */
! 1059: static int st_matrix[NUM_CHARTYPES][5] = {
! 1060: /* Poison, Petrify, wand, Breath, Magic */
! 1061: { 14, 15, 16, 16, 17 },
! 1062: { 14, 15, 16, 16, 17 },
! 1063: { 14, 15, 16, 16, 17 },
! 1064: { 14, 13, 11, 15, 12 },
! 1065: { 10, 13, 14, 16, 15 },
! 1066: { 13, 12, 14, 16, 15 },
! 1067: { 13, 12, 14, 16, 15 },
! 1068: { 10, 13, 14, 16, 15 },
! 1069: { 13, 12, 14, 16, 15 },
! 1070: { 14, 15, 16, 16, 17 }
! 1071: };
! 1072:
! 1073: /*
! 1074: * save:
! 1075: * See if a creature saves against something
! 1076: * which: which type of save
! 1077: * who: who is saving
! 1078: * adj: saving throw adjustment
! 1079: */
! 1080: bool
! 1081: save(int which, struct thing *who, int adj)
! 1082: {
! 1083: register int need, level, protect;
! 1084:
! 1085: protect = 0;
! 1086: level = who->t_stats.s_lvl;
! 1087: need = st_matrix[who->t_ctype][which];
! 1088: switch (who->t_ctype) {
! 1089: case C_FIGHTER:
! 1090: case C_RANGER:
! 1091: case C_PALADIN:
! 1092: case C_MONSTER:
! 1093: need -= (level-1) / 2;
! 1094: when C_MAGICIAN:
! 1095: need -= 2 * (level-1) / 5;
! 1096: when C_CLERIC:
! 1097: case C_DRUID:
! 1098: need -= (level-1) / 3;
! 1099: when C_THIEF:
! 1100: case C_ASSASIN:
! 1101: case C_MONK:
! 1102: need -= 2 * (level-1) / 4;
! 1103: }
! 1104: /*
! 1105: * add in pluses against poison for execeptional constitution
! 1106: */
! 1107: if (which == VS_POISON && who->t_stats.s_const > 18)
! 1108: need -= (who->t_stats.s_const - 17) / 2;
! 1109: if (who == &player) {
! 1110: /*
! 1111: * does the player have a ring of protection on?
! 1112: */
! 1113: protect += ring_value(R_PROTECT);
! 1114: /*
! 1115: * does the player have a cloak of protection on?
! 1116: */
! 1117: if (cur_misc[WEAR_CLOAK])
! 1118: protect += cur_misc[WEAR_CLOAK]->o_ac;
! 1119:
! 1120: protect = min(protect, 4);/* no more than a +4 bonus */
! 1121: need -= protect;
! 1122: }
! 1123: need -= adj;
! 1124: /*
! 1125: * always miss or save on a 1 (except for UNIQUEs
! 1126: */
! 1127: if (who == &player || off(*who, ISUNIQUE))
! 1128: need = max(need, 2);
! 1129: need = min(20, need); /* always make our save on a 20 */
! 1130: debug("need a %d to save", need);
! 1131: return (roll(1, 20) >= need);
! 1132: }
! 1133:
! 1134:
! 1135: /*
! 1136: * secret_door:
! 1137: * Figure out what a secret door looks like.
! 1138: */
! 1139:
! 1140: char
! 1141: secretdoor(int y, int x)
! 1142: {
! 1143: register int i;
! 1144: register struct room *rp;
! 1145: register coord *cpp;
! 1146: static coord cp;
! 1147:
! 1148: cp.y = y;
! 1149: cp.x = x;
! 1150: cpp = &cp;
! 1151: for (rp = rooms, i = 0; i < MAXROOMS; rp++, i++)
! 1152: if (inroom(rp, cpp))
! 1153: if (y == rp->r_pos.y || y == rp->r_pos.y + rp->r_max.y - 1)
! 1154: return('-');
! 1155: else
! 1156: return('|');
! 1157:
! 1158: return('p');
! 1159: }
! 1160:
! 1161: /*
! 1162: * this routine computes the players current strength
! 1163: */
! 1164: int
! 1165: str_compute(void)
! 1166: {
! 1167: if (cur_misc[WEAR_GAUNTLET] != NULL &&
! 1168: cur_misc[WEAR_GAUNTLET]->o_which == MM_G_OGRE) {
! 1169: if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
! 1170: return (3);
! 1171: else
! 1172: return (18);
! 1173: }
! 1174: else
! 1175: return (pstats.s_str);
! 1176: }
! 1177:
! 1178: /*
! 1179: * copy string using unctrl for things
! 1180: */
! 1181: void
! 1182: strucpy(char *s1, char *s2, int len)
! 1183: {
! 1184: const char *sp;
! 1185:
! 1186: while (len--)
! 1187: {
! 1188: strcpy(s1, (sp = unctrl(*s2++)));
! 1189: s1 += strlen(sp);
! 1190: }
! 1191: *s1 = '\0';
! 1192: }
! 1193:
! 1194: /*
! 1195: * tr_name:
! 1196: * print the name of a trap
! 1197: */
! 1198:
! 1199: char *
! 1200: tr_name(char ch)
! 1201: {
! 1202: register char *s = "";
! 1203:
! 1204: switch (ch)
! 1205: {
! 1206: case TRAPDOOR:
! 1207: s = terse ? "A trapdoor." : "You found a trapdoor.";
! 1208: when BEARTRAP:
! 1209: s = terse ? "A beartrap." : "You found a beartrap.";
! 1210: when SLEEPTRAP:
! 1211: s = terse ? "A sleeping gas trap.":"You found a sleeping gas trap.";
! 1212: when ARROWTRAP:
! 1213: s = terse ? "An arrow trap." : "You found an arrow trap.";
! 1214: when TELTRAP:
! 1215: s = terse ? "A teleport trap." : "You found a teleport trap.";
! 1216: when DARTTRAP:
! 1217: s = terse ? "A dart trap." : "You found a poison dart trap.";
! 1218: when POOL:
! 1219: s = terse ? "A shimmering pool." : "You found a shimmering pool";
! 1220: when MAZETRAP:
! 1221: s = terse ? "A maze entrance." : "You found a maze entrance";
! 1222: }
! 1223: return s;
! 1224: }
! 1225:
! 1226: /*
! 1227: * for printfs: if string starts with a vowel, return "n" for an "an"
! 1228: */
! 1229: char *
! 1230: vowelstr(char *str)
! 1231: {
! 1232: switch (*str)
! 1233: {
! 1234: case 'a':
! 1235: case 'e':
! 1236: case 'i':
! 1237: case 'o':
! 1238: case 'u':
! 1239: return "n";
! 1240: default:
! 1241: return "";
! 1242: }
! 1243: }
! 1244:
! 1245: /*
! 1246: * wake up a room full (hopefully) of creatures
! 1247: */
! 1248: void
! 1249: wake_room(struct room *rp)
! 1250: {
! 1251: register struct linked_list *item;
! 1252: register struct thing *tp;
! 1253:
! 1254: for (item=mlist; item!=NULL; item=next(item)) {
! 1255: tp = THINGPTR(item);
! 1256: if (off(*tp,ISRUN) && on(*tp,ISMEAN) && roomin(&tp->t_pos) == rp)
! 1257: runto(tp, &hero);
! 1258: }
! 1259: }
! 1260:
! 1261:
! 1262: /*
! 1263: * waste_time:
! 1264: * Do nothing but let other things happen
! 1265: */
! 1266:
! 1267: void
! 1268: waste_time(void)
! 1269: {
! 1270: if (inwhgt) /* if from wghtchk then done */
! 1271: return;
! 1272: do_daemons(BEFORE);
! 1273: do_fuses(BEFORE);
! 1274: do_daemons(AFTER);
! 1275: do_fuses(AFTER);
! 1276: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue7