![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to move.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue5|
Return to move.c CVS log | Up to [contributed] / early-roguelike / arogue5 |
1.1 ! rubenllo 1: /*
! 2: * Hero movement commands
! 3: *
! 4: * Advanced Rogue
! 5: * Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
! 6: * All rights reserved.
! 7: *
! 8: * Based on "Super-Rogue"
! 9: * Copyright (C) 1984 Robert D. Kindelberger
! 10: * All rights reserved.
! 11: *
! 12: * Based on "Rogue: Exploring the Dungeons of Doom"
! 13: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
! 14: * All rights reserved.
! 15: *
! 16: * See the file LICENSE.TXT for full copyright and licensing information.
! 17: */
! 18:
! 19: #include "curses.h"
! 20: #include <ctype.h>
! 21: #include "rogue.h"
! 22:
! 23: /*
! 24: * Used to hold the new hero position
! 25: */
! 26:
! 27: static coord nh;
! 28:
! 29: static const char Moves[3][3] = {
! 30: { 'y', 'k', 'u' },
! 31: { 'h', '\0', 'l' },
! 32: { 'b', 'j', 'n' }
! 33: };
! 34:
! 35: /*
! 36: * be_trapped:
! 37: * The guy stepped on a trap.... Make him pay.
! 38: */
! 39:
! 40: char
! 41: be_trapped(struct thing *th, coord *tc)
! 42: {
! 43: register struct trap *tp;
! 44: register char ch;
! 45: register const char *mname = NULL;
! 46: register bool is_player = (th == &player),
! 47: can_see;
! 48: register struct linked_list *mitem = NULL;
! 49:
! 50:
! 51: /* Can the player see the creature? */
! 52: can_see = (cansee(tc->y, tc->x) && (is_player || !invisible(th)));
! 53:
! 54: tp = trap_at(tc->y, tc->x);
! 55: /*
! 56: * if he's wearing boots of elvenkind, he won't set off the trap
! 57: * unless its a magic pool (they're not really traps)
! 58: */
! 59: if (is_player &&
! 60: cur_misc[WEAR_BOOTS] != NULL &&
! 61: cur_misc[WEAR_BOOTS]->o_which == MM_ELF_BOOTS &&
! 62: tp->tr_type != POOL)
! 63: return '\0';
! 64:
! 65: /*
! 66: * if the creature is flying then it won't set off the trap
! 67: */
! 68: if (on(*th, ISFLY))
! 69: return '\0';
! 70:
! 71: tp->tr_flags |= ISFOUND;
! 72:
! 73: if (!is_player) {
! 74: mitem = find_mons(th->t_pos.y, th->t_pos.x);
! 75: mname = monsters[th->t_index].m_name;
! 76: }
! 77: else {
! 78: count = running = FALSE;
! 79: mvwaddch(cw, tp->tr_pos.y, tp->tr_pos.x, tp->tr_type);
! 80: }
! 81: switch (ch = tp->tr_type) {
! 82: case TRAPDOOR:
! 83: if (is_player) {
! 84: level++;
! 85: pstats.s_hpt -= roll(1, 10);
! 86: if (pstats.s_hpt <= 0) death(D_FALL);
! 87: new_level(NORMLEV);
! 88: msg("You fell into a trap!");
! 89: }
! 90: else {
! 91: if (can_see) msg("The %s fell into a trap!", mname);
! 92:
! 93: /* See if the fall killed the monster */
! 94: if ((th->t_stats.s_hpt -= roll(1, 10)) <= 0) {
! 95: killed(mitem, FALSE, FALSE);
! 96: }
! 97: else { /* Just move monster to next level */
! 98: check_residue(th);
! 99:
! 100: /* Erase the monster from the old position */
! 101: if (isalpha(mvwinch(cw, th->t_pos.y, th->t_pos.x)))
! 102: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
! 103: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
! 104: turn_on(*th, ISELSEWHERE);
! 105: detach(mlist, mitem);
! 106: attach(tlist, mitem); /* remember him next level */
! 107: }
! 108: }
! 109: when BEARTRAP:
! 110: if (is_stealth(th)) {
! 111: if (is_player) msg("You pass a bear trap.");
! 112: else if (can_see) msg("The %s passes a bear trap.", mname);
! 113: }
! 114: else {
! 115: th->t_no_move += BEARTIME;
! 116: if (is_player) msg("You are caught in a bear trap.");
! 117: else if (can_see) msg("The %s is caught in a bear trap.",
! 118: mname);
! 119: }
! 120: when SLEEPTRAP:
! 121: if (is_player) {
! 122: msg("A strange white mist envelops you.");
! 123: if (!ISWEARING(R_ALERT)) {
! 124: msg("You fall asleep.");
! 125: no_command += SLEEPTIME;
! 126: }
! 127: }
! 128: else {
! 129: if (can_see)
! 130: msg("A strange white mist envelops the %s.",mname);
! 131: if (on(*th, ISUNDEAD)) {
! 132: if (can_see)
! 133: msg("The mist doesn't seem to affect the %s.",mname);
! 134: }
! 135: else {
! 136: th->t_no_move += SLEEPTIME;
! 137: }
! 138: }
! 139: when ARROWTRAP:
! 140: if (swing(th->t_ctype, th->t_stats.s_lvl-1, th->t_stats.s_arm, 1))
! 141: {
! 142: if (is_player) {
! 143: msg("Oh no! An arrow shot you.");
! 144: if ((pstats.s_hpt -= roll(1, 6)) <= 0) {
! 145: msg("The arrow killed you.");
! 146: death(D_ARROW);
! 147: }
! 148: }
! 149: else {
! 150: if (can_see) msg("An arrow shot the %s.", mname);
! 151: if ((th->t_stats.s_hpt -= roll(1, 6)) <= 0) {
! 152: if (can_see) msg("The arrow killed the %s.", mname);
! 153: killed(mitem, FALSE, FALSE);
! 154: }
! 155: }
! 156: }
! 157: else
! 158: {
! 159: register struct linked_list *item;
! 160: register struct object *arrow;
! 161:
! 162: if (is_player) msg("An arrow shoots past you.");
! 163: else if (can_see) msg("An arrow shoots by the %s.", mname);
! 164: item = new_item(sizeof *arrow);
! 165: arrow = OBJPTR(item);
! 166: arrow->o_type = WEAPON;
! 167: arrow->contents = NULL;
! 168: arrow->o_which = ARROW;
! 169: arrow->o_hplus = rnd(3) - 1;
! 170: arrow->o_dplus = rnd(3) - 1;
! 171: init_weapon(arrow, ARROW);
! 172: arrow->o_count = 1;
! 173: arrow->o_pos = *tc;
! 174: arrow->o_mark[0] = '\0';
! 175: fall(item, FALSE);
! 176: }
! 177: when TELTRAP:
! 178: if (is_player) teleport();
! 179: else {
! 180: register int rm;
! 181: struct room *old_room; /* old room of monster */
! 182:
! 183: /*
! 184: * Erase the monster from the old position
! 185: */
! 186: if (isalpha(mvwinch(cw, th->t_pos.y, th->t_pos.x)))
! 187: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
! 188: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
! 189: /*
! 190: * check to see if room should go dark
! 191: */
! 192: if (on(*th, HASFIRE)) {
! 193: old_room=roomin(&th->t_pos);
! 194: if (old_room != NULL) {
! 195: register struct linked_list *fire_item;
! 196:
! 197: for (fire_item = old_room->r_fires; fire_item != NULL;
! 198: fire_item = next(fire_item)) {
! 199: if (THINGPTR(fire_item) == th) {
! 200: detach(old_room->r_fires, fire_item);
! 201: destroy_item(fire_item);
! 202:
! 203: if (old_room->r_fires == NULL) {
! 204: old_room->r_flags &= ~HASFIRE;
! 205: if (can_see) light(&hero);
! 206: }
! 207: }
! 208: }
! 209: }
! 210: }
! 211:
! 212: /* Get a new position */
! 213: do {
! 214: rm = rnd_room();
! 215: rnd_pos(&rooms[rm], &th->t_pos);
! 216: } until(winat(th->t_pos.y, th->t_pos.x) == FLOOR);
! 217:
! 218: /* Put it there */
! 219: mvwaddch(mw, th->t_pos.y, th->t_pos.x, th->t_type);
! 220: th->t_oldch = CCHAR( mvwinch(cw, th->t_pos.y, th->t_pos.x) );
! 221: /*
! 222: * check to see if room that creature appears in should
! 223: * light up
! 224: */
! 225: if (on(*th, HASFIRE)) {
! 226: register struct linked_list *fire_item;
! 227:
! 228: fire_item = creat_item();
! 229: ldata(fire_item) = (char *) th;
! 230: attach(rooms[rm].r_fires, fire_item);
! 231:
! 232: rooms[rm].r_flags |= HASFIRE;
! 233: if(cansee(th->t_pos.y, th->t_pos.x) &&
! 234: next(rooms[rm].r_fires) == NULL)
! 235: light(&hero);
! 236: }
! 237: if (can_see) msg("The %s seems to have disappeared!", mname);
! 238: }
! 239: when DARTTRAP:
! 240: if (swing(th->t_ctype, th->t_stats.s_lvl+1, th->t_stats.s_arm, 1)) {
! 241: if (is_player) {
! 242: msg("A small dart just hit you in the shoulder.");
! 243: if ((pstats.s_hpt -= roll(1, 4)) <= 0) {
! 244: msg("The dart killed you.");
! 245: death(D_DART);
! 246: }
! 247:
! 248: /* Now the poison */
! 249: if (!save(VS_POISON, &player, 0)) {
! 250: /* 75% chance it will do point damage - else strength */
! 251: if (rnd(100) < 75) {
! 252: pstats.s_hpt /= 2;
! 253: if (pstats.s_hpt == 0) death(D_POISON);
! 254: }
! 255: else if (!ISWEARING(R_SUSABILITY))
! 256: chg_str(-1);
! 257: }
! 258: }
! 259: else {
! 260: if (can_see)
! 261: msg("A small dart just hit the %s in the shoulder.",
! 262: mname);
! 263: if ((th->t_stats.s_hpt -= roll(1,4)) <= 0) {
! 264: if (can_see) msg("The dart killed the %s.", mname);
! 265: killed(mitem, FALSE, FALSE);
! 266: }
! 267: if (!save(VS_POISON, th, 0)) {
! 268: th->t_stats.s_hpt /= 2;
! 269: if (th->t_stats.s_hpt <= 0) {
! 270: if (can_see) msg("The dart killed the %s.", mname);
! 271: killed(mitem, FALSE, FALSE);
! 272: }
! 273: }
! 274: }
! 275: }
! 276: else {
! 277: if (is_player)
! 278: msg("A small dart whizzes by your ear and vanishes.");
! 279: else if (can_see)
! 280: msg("A small dart whizzes by the %s's ear and vanishes.",
! 281: mname);
! 282: }
! 283: when POOL: {
! 284: register int i;
! 285:
! 286: i = rnd(100);
! 287: if (is_player) {
! 288: if ((tp->tr_flags & ISGONE)) {
! 289: if (i < 30) {
! 290: teleport(); /* teleport away */
! 291: pool_teleport = TRUE;
! 292: }
! 293: else if((i < 45) && level > 2) {
! 294: level -= rnd(2) + 1;
! 295: cur_max = level;
! 296: new_level(NORMLEV);
! 297: pool_teleport = TRUE;
! 298: msg("You here a faint groan from below.");
! 299: }
! 300: else if(i < 70) {
! 301: level += rnd(4) + 1;
! 302: new_level(NORMLEV);
! 303: pool_teleport = TRUE;
! 304: msg("You find yourself in strange surroundings.");
! 305: }
! 306: else if(i > 95) {
! 307: msg("Oh no!!! You drown in the pool!!! --More--");
! 308: wait_for(cw,' ');
! 309: death(D_DROWN);
! 310: }
! 311: }
! 312: }
! 313: else {
! 314: if (i < 60) {
! 315: if (can_see) {
! 316: /* Drowns */
! 317: if (i < 30) msg("The %s drowned in the pool!", mname);
! 318:
! 319: /* Teleported to another level */
! 320: else msg("The %s disappeared!", mname);
! 321: }
! 322: killed(mitem, FALSE, FALSE);
! 323: }
! 324: }
! 325: }
! 326: when MAZETRAP:
! 327: if (is_player) {
! 328: pstats.s_hpt -= roll(1, 10);
! 329: level++;
! 330: msg("You fell through a trap door!");
! 331: if (pstats.s_hpt <= 0) death(D_FALL);
! 332: new_level(MAZELEV);
! 333: msg("You are surrounded by twisty passages!");
! 334: }
! 335: else {
! 336: if (can_see) msg("The %s fell into a trap!", mname);
! 337: killed(mitem, FALSE, FALSE);
! 338: }
! 339: }
! 340:
! 341: /* Move the cursor back onto the hero */
! 342: wmove(cw, hero.y, hero.x);
! 343:
! 344: md_flushinp(); /* flush typeahead */
! 345:
! 346: return(ch);
! 347: }
! 348:
! 349: /*
! 350: * blue_light:
! 351: * magically light up a room (or level or make it dark)
! 352: */
! 353:
! 354: bool
! 355: blue_light(bool blessed, bool cursed)
! 356: {
! 357: register struct room *rp;
! 358: bool ret_val=FALSE; /* Whether or not affect is known */
! 359:
! 360: rp = roomin(&hero); /* What room is hero in? */
! 361:
! 362: /* Darken the room if the magic is cursed */
! 363: if (cursed) {
! 364: if ((rp == NULL) || !lit_room(rp)) msg(nothing);
! 365: else {
! 366: rp->r_flags |= ISDARK;
! 367: if (!lit_room(rp) && (levtype != OUTSIDE || !daytime))
! 368: msg("The %s suddenly goes dark.",
! 369: levtype == OUTSIDE ? "area" : "room");
! 370: else msg(nothing);
! 371: ret_val = TRUE;
! 372: }
! 373: }
! 374: else {
! 375: ret_val = TRUE;
! 376: if (rp && !lit_room(rp) &&
! 377: (levtype != OUTSIDE || !daytime)) {
! 378: addmsg("The %s is lit", levtype == OUTSIDE ? "area" : "room");
! 379: if (!terse)
! 380: addmsg(" by a %s blue light.",
! 381: blessed ? "bright" : "shimmering");
! 382: endmsg();
! 383: }
! 384: else if (winat(hero.y, hero.x) == PASSAGE)
! 385: msg("The corridor glows %sand then fades",
! 386: blessed ? "brightly " : "");
! 387: else {
! 388: ret_val = FALSE;
! 389: msg(nothing);
! 390: }
! 391: if (blessed) {
! 392: register int i; /* Index through rooms */
! 393:
! 394: for (i=0; i<MAXROOMS; i++)
! 395: rooms[i].r_flags &= ~ISDARK;
! 396: }
! 397: else if (rp) rp->r_flags &= ~ISDARK;
! 398: }
! 399:
! 400: /*
! 401: * Light the room and put the player back up
! 402: */
! 403: light(&hero);
! 404: mvwaddch(cw, hero.y, hero.x, PLAYER);
! 405: return(ret_val);
! 406: }
! 407:
! 408: /*
! 409: * corr_move:
! 410: * Check to see that a move is legal. If so, return correct character.
! 411: * If not, if player came from a legal place, then try to turn him.
! 412: */
! 413:
! 414: void
! 415: corr_move(int dy, int dx)
! 416: {
! 417: int legal=0; /* Number of legal alternatives */
! 418: register int y, x, /* Indexes though possible positions */
! 419: locy = 0, locx = 0; /* Hold delta of chosen location */
! 420:
! 421: /* New position */
! 422: nh.y = hero.y + dy;
! 423: nh.x = hero.x + dx;
! 424:
! 425: /* If it is a legal move, just return */
! 426: if (nh.x >= 0 && nh.x < COLS && nh.y > 0 && nh.y < LINES - 2) {
! 427:
! 428: switch (winat(nh.y, nh.x)) {
! 429: case WALL:
! 430: case '|':
! 431: case '-':
! 432: break;
! 433: default:
! 434: if (diag_ok(&hero, &nh, &player))
! 435: return;
! 436: }
! 437: }
! 438:
! 439: /* Check legal places surrounding the player -- ignore previous position */
! 440: for (y = hero.y - 1; y <= hero.y + 1; y++) {
! 441: if (y < 1 || y > LINES - 3)
! 442: continue;
! 443: for (x = hero.x - 1; x <= hero.x + 1; x++) {
! 444: /* Ignore borders of the screen */
! 445: if (x < 0 || x > COLS - 1)
! 446: continue;
! 447:
! 448: /*
! 449: * Ignore where we came from, where we are, and where we couldn't go
! 450: */
! 451: if ((x == hero.x - dx && y == hero.y - dy) ||
! 452: (x == hero.x + dx && y == hero.y + dy) ||
! 453: (x == hero.x && y == hero.y))
! 454: continue;
! 455:
! 456: switch (winat(y, x)) {
! 457: case WALL:
! 458: case '|':
! 459: case '-':
! 460: break;
! 461: default:
! 462: nh.y = y;
! 463: nh.x = x;
! 464: if (diag_ok(&hero, &nh, &player)) {
! 465: legal++;
! 466: locy = y - (hero.y - 1);
! 467: locx = x - (hero.x - 1);
! 468: }
! 469: }
! 470: }
! 471: }
! 472:
! 473: /* If we have 2 or more legal moves, make no change */
! 474: if (legal != 1) {
! 475: return;
! 476: }
! 477:
! 478: runch = Moves[locy][locx];
! 479:
! 480: /*
! 481: * For mazes, pretend like it is the beginning of a new run at each turn
! 482: * in order to get the lighting correct.
! 483: */
! 484: if (levtype == MAZELEV) firstmove = TRUE;
! 485: return;
! 486: }
! 487:
! 488: /*
! 489: * dip_it:
! 490: * Dip an object into a magic pool
! 491: */
! 492: void
! 493: dip_it(void)
! 494: {
! 495: reg struct linked_list *what;
! 496: reg struct object *ob;
! 497: reg struct trap *tp;
! 498: reg int wh, i;
! 499:
! 500: tp = trap_at(hero.y,hero.x);
! 501: if (tp == NULL || tp->tr_type != POOL) {
! 502: msg("I see no shimmering pool here");
! 503: return;
! 504: }
! 505: if (tp->tr_flags & ISGONE) {
! 506: msg("This shimmering pool appears to have used once already");
! 507: return;
! 508: }
! 509: if ((what = get_item(pack, "dip", ALL)) == NULL) {
! 510: msg("");
! 511: after = FALSE;
! 512: return;
! 513: }
! 514: ob = OBJPTR(what);
! 515: mpos = 0;
! 516: if (ob == cur_armor ||
! 517: ob == cur_misc[WEAR_BOOTS] || ob == cur_misc[WEAR_JEWEL] ||
! 518: ob == cur_misc[WEAR_GAUNTLET]|| ob == cur_misc[WEAR_CLOAK] ||
! 519: ob == cur_misc[WEAR_BRACERS] || ob == cur_misc[WEAR_NECKLACE]||
! 520: ob == cur_ring[LEFT_1] || ob == cur_ring[LEFT_2] ||
! 521: ob == cur_ring[LEFT_3] || ob == cur_ring[LEFT_4] ||
! 522: ob == cur_ring[RIGHT_1] || ob == cur_ring[RIGHT_2] ||
! 523: ob == cur_ring[RIGHT_3] || ob == cur_ring[RIGHT_4]) {
! 524: msg("You'll have to take it off first.");
! 525: return;
! 526: }
! 527: tp->tr_flags |= ISGONE;
! 528: if (ob != NULL) {
! 529: wh = ob->o_which;
! 530: ob->o_flags |= ISKNOW;
! 531: i = rnd(100);
! 532: switch(ob->o_type) {
! 533: case WEAPON:
! 534: if(i < 50) { /* enchant weapon here */
! 535: if ((ob->o_flags & ISCURSED) == 0) {
! 536: ob->o_hplus += 1;
! 537: ob->o_dplus += 1;
! 538: }
! 539: else { /* weapon was prev cursed here */
! 540: ob->o_hplus = rnd(2);
! 541: ob->o_dplus = rnd(2);
! 542: }
! 543: ob->o_flags &= ~ISCURSED;
! 544: msg("The %s glows blue for a moment.",weaps[wh].w_name);
! 545: }
! 546: else if(i < 70) { /* curse weapon here */
! 547: if ((ob->o_flags & ISCURSED) == 0) {
! 548: ob->o_hplus = -(rnd(2)+1);
! 549: ob->o_dplus = -(rnd(2)+1);
! 550: }
! 551: else { /* if already cursed */
! 552: ob->o_hplus--;
! 553: ob->o_dplus--;
! 554: }
! 555: ob->o_flags |= ISCURSED;
! 556: msg("The %s glows red for a moment.",weaps[wh].w_name);
! 557: }
! 558: else
! 559: msg(nothing);
! 560: when ARMOR:
! 561: if (i < 50) { /* enchant armor */
! 562: if((ob->o_flags & ISCURSED) == 0)
! 563: ob->o_ac -= rnd(2) + 1;
! 564: else
! 565: ob->o_ac = -rnd(3)+ armors[wh].a_class;
! 566: ob->o_flags &= ~ISCURSED;
! 567: msg("The %s glows blue for a moment",armors[wh].a_name);
! 568: }
! 569: else if(i < 75){ /* curse armor */
! 570: if ((ob->o_flags & ISCURSED) == 0)
! 571: ob->o_ac = rnd(3)+ armors[wh].a_class;
! 572: else
! 573: ob->o_ac += rnd(2) + 1;
! 574: ob->o_flags |= ISCURSED;
! 575: msg("The %s glows red for a moment.",armors[wh].a_name);
! 576: }
! 577: else
! 578: msg(nothing);
! 579: when STICK: {
! 580: int j;
! 581: j = rnd(8) + 1;
! 582: if(i < 50) { /* add charges */
! 583: ob->o_charges += j;
! 584: ws_know[wh] = TRUE;
! 585: if (ob->o_flags & ISCURSED)
! 586: ob->o_flags &= ~ISCURSED;
! 587: sprintf(outstring,"The %s %s glows blue for a moment.",
! 588: ws_made[wh],ws_type[wh]);
! 589: msg(outstring);
! 590: }
! 591: else if(i < 65) { /* remove charges */
! 592: if ((ob->o_charges -= i) < 0)
! 593: ob->o_charges = 0;
! 594: ws_know[wh] = TRUE;
! 595: if (ob->o_flags & ISBLESSED)
! 596: ob->o_flags &= ~ISBLESSED;
! 597: else
! 598: ob->o_flags |= ISCURSED;
! 599: sprintf(outstring,"The %s %s glows red for a moment.",
! 600: ws_made[wh],ws_type[wh]);
! 601: msg(outstring);
! 602: }
! 603: else
! 604: msg(nothing);
! 605: }
! 606: when SCROLL:
! 607: s_know[wh] = TRUE;
! 608: msg("The '%s' scroll unfurls.",s_names[wh]);
! 609: when POTION:
! 610: p_know[wh] = TRUE;
! 611: msg("The %s potion bubbles for a moment.",p_colors[wh]);
! 612: when RING:
! 613: if(i < 50) { /* enchant ring */
! 614: if ((ob->o_flags & ISCURSED) == 0)
! 615: ob->o_ac += rnd(2) + 1;
! 616: else
! 617: ob->o_ac = rnd(2) + 1;
! 618: ob->o_flags &= ~ISCURSED;
! 619: }
! 620: else if(i < 80) { /* curse ring */
! 621: if ((ob->o_flags & ISCURSED) == 0)
! 622: ob->o_ac = -(rnd(2) + 1);
! 623: else
! 624: ob->o_ac -= (rnd(2) + 1);
! 625: ob->o_flags |= ISCURSED;
! 626: }
! 627: r_know[wh] = TRUE;
! 628: msg("The %s ring vibrates for a moment.",r_stones[wh]);
! 629: when MM:
! 630: m_know[wh] = TRUE;
! 631: switch (ob->o_which) {
! 632: case MM_BRACERS:
! 633: case MM_PROTECT:
! 634: if(i < 50) { /* enchant item */
! 635: if ((ob->o_flags & ISCURSED) == 0)
! 636: ob->o_ac += rnd(2) + 1;
! 637: else
! 638: ob->o_ac = rnd(2) + 1;
! 639: ob->o_flags &= ~ISCURSED;
! 640: }
! 641: else if(i < 80) { /* curse item */
! 642: if ((ob->o_flags & ISCURSED) == 0)
! 643: ob->o_ac = -(rnd(2) + 1);
! 644: else
! 645: ob->o_ac -= (rnd(2) + 1);
! 646: ob->o_flags |= ISCURSED;
! 647: }
! 648: msg("The item vibrates for a moment.");
! 649: when MM_CHOKE:
! 650: case MM_DISAPPEAR:
! 651: ob->o_ac = 0;
! 652: msg ("The dust dissolves in the pool!");
! 653: }
! 654: otherwise:
! 655: msg("The pool bubbles for a moment.");
! 656: }
! 657: updpack(FALSE);
! 658: }
! 659: else
! 660: msg(nothing);
! 661: }
! 662:
! 663: /*
! 664: * do_move:
! 665: * Check to see that a move is legal. If it is handle the
! 666: * consequences (fighting, picking up, etc.)
! 667: */
! 668:
! 669: void
! 670: do_move(int dy, int dx)
! 671: {
! 672: register struct room *rp, *orp;
! 673: register char ch;
! 674: coord old_hero;
! 675: int i, wasfirstmove;
! 676:
! 677: wasfirstmove = firstmove;
! 678: firstmove = FALSE;
! 679: curprice = -1; /* if in trading post, we've moved off obj */
! 680: if (player.t_no_move) {
! 681: player.t_no_move--;
! 682: msg("You are still stuck in the bear trap");
! 683: return;
! 684: }
! 685: /*
! 686: * Do a confused move (maybe)
! 687: */
! 688: if ((on(player, ISHUH) && rnd(100) < 80) ||
! 689: (on(player, ISDANCE) && rnd(100) < 80) ||
! 690: (ISWEARING(R_DELUSION) && rnd(100) < 25))
! 691: nh = *rndmove(&player);
! 692: else {
! 693: nh.y = hero.y + dy;
! 694: nh.x = hero.x + dx;
! 695: }
! 696:
! 697: /*
! 698: * Check if he tried to move off the screen or make an illegal
! 699: * diagonal move, and stop him if he did.
! 700: */
! 701: if (nh.x < 0 || nh.x > COLS-1 || nh.y < 1 || nh.y >= LINES - 2
! 702: || !diag_ok(&hero, &nh, &player))
! 703: {
! 704: after = running = FALSE;
! 705: return;
! 706: }
! 707: if (running && ce(hero, nh))
! 708: after = running = FALSE;
! 709: ch = CCHAR( winat(nh.y, nh.x) );
! 710:
! 711: /* Take care of hero trying to move close to something frightening */
! 712: if (on(player, ISFLEE)) {
! 713: if (rnd(100) < 10) {
! 714: turn_off(player, ISFLEE);
! 715: msg("You regain your composure.");
! 716: }
! 717: else if (DISTANCE(nh.y, nh.x, player.t_dest->y, player.t_dest->x) <
! 718: DISTANCE(hero.y, hero.x, player.t_dest->y, player.t_dest->x))
! 719: return;
! 720: }
! 721:
! 722: /* Take care of hero being held */
! 723: if (on(player, ISHELD) && !isalpha(ch))
! 724: {
! 725: msg("You are being held");
! 726: return;
! 727: }
! 728:
! 729: /* assume he's not in a wall */
! 730: if (!isalpha(ch)) turn_off(player, ISINWALL);
! 731:
! 732: switch(ch) {
! 733: case '|':
! 734: case '-':
! 735: if (levtype == OUTSIDE) {
! 736: hero = nh;
! 737: new_level(OUTSIDE);
! 738: return;
! 739: }
! 740: case WALL:
! 741: case SECRETDOOR:
! 742: if (off(player, CANINWALL) || running) {
! 743: after = running = FALSE;
! 744:
! 745: /* Light if finishing run */
! 746: if (levtype == MAZELEV && lit_room(&rooms[0]))
! 747: look(FALSE, TRUE);
! 748:
! 749: after = running = FALSE;
! 750:
! 751: return;
! 752: }
! 753: turn_on(player, ISINWALL);
! 754: break;
! 755: case POOL:
! 756: if (levtype == OUTSIDE) {
! 757: lake_check(&nh);
! 758: running = FALSE;
! 759: break;
! 760: }
! 761: case MAZETRAP:
! 762: if (levtype == OUTSIDE) {
! 763: running = FALSE;
! 764: break;
! 765: }
! 766: case TRAPDOOR:
! 767: case TELTRAP:
! 768: case BEARTRAP:
! 769: case SLEEPTRAP:
! 770: case ARROWTRAP:
! 771: case DARTTRAP:
! 772: ch = be_trapped(&player, &nh);
! 773: if (ch == TRAPDOOR || ch == TELTRAP ||
! 774: pool_teleport || ch == MAZETRAP) {
! 775: pool_teleport = FALSE;
! 776: return;
! 777: }
! 778: break;
! 779: case GOLD:
! 780: case POTION:
! 781: case SCROLL:
! 782: case FOOD:
! 783: case WEAPON:
! 784: case ARMOR:
! 785: case RING:
! 786: case MM:
! 787: case RELIC:
! 788: case STICK:
! 789: running = FALSE;
! 790: take = ch;
! 791: break;
! 792: case DOOR:
! 793: case STAIRS:
! 794: running = FALSE;
! 795: break;
! 796: case POST:
! 797: running = FALSE;
! 798: new_level(POSTLEV);
! 799: return;
! 800: default:
! 801: break;
! 802: }
! 803:
! 804: if (isalpha(ch)) { /* if its a monster then fight it */
! 805: running = FALSE;
! 806: i = 1;
! 807: if (player.t_ctype == C_FIGHTER)
! 808: i += pstats.s_lvl/10;
! 809: while (i--)
! 810: fight(&nh, cur_weapon, FALSE);
! 811: return;
! 812: }
! 813:
! 814: /*
! 815: * if not fighting then move the hero
! 816: */
! 817: old_hero = hero; /* Save hero's old position */
! 818: hero = nh; /* Move the hero */
! 819: rp = roomin(&hero);
! 820: orp = roomin(&old_hero);
! 821:
! 822: /* Unlight any possible cross-corridor */
! 823: if (levtype == MAZELEV) {
! 824: register bool call_light = FALSE;
! 825: register char wall_check;
! 826:
! 827: if (wasfirstmove && lit_room(&rooms[0])) {
! 828: /* Are we moving out of a corridor? */
! 829: switch (runch) {
! 830: case 'h':
! 831: case 'l':
! 832: if (old_hero.y + 1 < LINES - 2) {
! 833: wall_check = CCHAR( winat(old_hero.y + 1, old_hero.x) );
! 834: if (!isrock(wall_check)) call_light = TRUE;
! 835: }
! 836: if (old_hero.y - 1 > 0) {
! 837: wall_check = CCHAR( winat(old_hero.y - 1, old_hero.x) );
! 838: if (!isrock(wall_check)) call_light = TRUE;
! 839: }
! 840: break;
! 841: case 'j':
! 842: case 'k':
! 843: if (old_hero.x + 1 < COLS) {
! 844: wall_check = CCHAR( winat(old_hero.y, old_hero.x + 1) );
! 845: if (!isrock(wall_check)) call_light = TRUE;
! 846: }
! 847: if (old_hero.x - 1 >= 0) {
! 848: wall_check = CCHAR( winat(old_hero.y, old_hero.x - 1) );
! 849: if (!isrock(wall_check)) call_light = TRUE;
! 850: }
! 851: break;
! 852: default:
! 853: call_light = TRUE;
! 854: }
! 855: player.t_oldpos = old_hero;
! 856: if (call_light) light(&old_hero);
! 857: }
! 858: }
! 859:
! 860: else if (orp != NULL && rp == NULL) { /* Leaving a room -- darken it */
! 861: orp->r_flags |= FORCEDARK; /* Fake darkness */
! 862: light(&old_hero);
! 863: orp->r_flags &= ~FORCEDARK; /* Restore light state */
! 864: }
! 865: else if (rp != NULL && orp == NULL){/* Entering a room */
! 866: light(&hero);
! 867: }
! 868: ch = CCHAR( winat(old_hero.y, old_hero.x) );
! 869: wmove(cw, unc(old_hero));
! 870: waddch(cw, ch);
! 871: wmove(cw, unc(hero));
! 872: waddch(cw, PLAYER);
! 873: }
! 874:
! 875: /*
! 876: * do_run:
! 877: * Start the hero running
! 878: */
! 879:
! 880: void
! 881: do_run(char ch)
! 882: {
! 883: firstmove = TRUE;
! 884: running = TRUE;
! 885: after = FALSE;
! 886: runch = ch;
! 887: }
! 888:
! 889: /*
! 890: * getdelta:
! 891: * Takes a movement character (eg. h, j, k, l) and returns the
! 892: * y and x delta corresponding to it in the remaining arguments.
! 893: * Returns TRUE if it could find it, FALSE otherwise.
! 894: */
! 895: bool
! 896: getdelta(char match, int *dy, int *dx)
! 897: {
! 898: int y, x;
! 899:
! 900: for (y = 0; y < 3; y++)
! 901: for (x = 0; x < 3; x++)
! 902: if (Moves[y][x] == match) {
! 903: *dy = y - 1;
! 904: *dx = x - 1;
! 905: return(TRUE);
! 906: }
! 907:
! 908: return(FALSE);
! 909: }
! 910:
! 911: /*
! 912: * isatrap:
! 913: * Returns TRUE if this character is some kind of trap
! 914: */
! 915: bool
! 916: isatrap(char ch)
! 917: {
! 918: switch(ch) {
! 919: case DARTTRAP:
! 920: case TELTRAP:
! 921: case TRAPDOOR:
! 922: case ARROWTRAP:
! 923: case SLEEPTRAP:
! 924: case BEARTRAP: return(TRUE);
! 925: case MAZETRAP:
! 926: case POOL: return(levtype != OUTSIDE);
! 927: default: return(FALSE);
! 928: }
! 929: }
! 930:
! 931: /*
! 932: * Called to illuminate a room.
! 933: * If it is dark, remove anything that might move.
! 934: */
! 935:
! 936: void
! 937: light(coord *cp)
! 938: {
! 939: register struct room *rp;
! 940: register int j, k, x, y;
! 941: register char ch, rch, sch;
! 942: register struct linked_list *item;
! 943: int jlow, jhigh, klow, khigh; /* Boundaries of lit area */
! 944:
! 945: if ((rp = roomin(cp)) != NULL) {
! 946: /*
! 947: * is he wearing ring of illumination?
! 948: */
! 949: if (&hero == cp && ISWEARING(R_LIGHT)) /* Must be hero's room */
! 950: rp->r_flags &= ~ISDARK;
! 951:
! 952: /* If we are in a maze, don't look at the whole room (level) */
! 953: if (levtype == MAZELEV) {
! 954: int see_radius;
! 955:
! 956: see_radius = 1;
! 957:
! 958: /* If we are looking at the hero in a rock, broaden our sights */
! 959: if (&hero == cp || &player.t_oldpos == cp) {
! 960: ch = CCHAR( winat(hero.y, hero.x) );
! 961: if (isrock(ch)) see_radius = 2;
! 962: ch = CCHAR( winat(player.t_oldpos.y, player.t_oldpos.x) );
! 963: if (isrock(ch)) see_radius = 2;
! 964: }
! 965:
! 966: jlow = max(0, cp->y - see_radius - rp->r_pos.y);
! 967: jhigh = min(rp->r_max.y, cp->y + see_radius + 1 - rp->r_pos.y);
! 968: klow = max(0, cp->x - see_radius - rp->r_pos.x);
! 969: khigh = min(rp->r_max.x, cp->x + see_radius + 1 - rp->r_pos.x);
! 970: }
! 971: else {
! 972: jlow = klow = 0;
! 973: jhigh = rp->r_max.y;
! 974: khigh = rp->r_max.x;
! 975: }
! 976: for (j = 0; j < rp->r_max.y; j++)
! 977: {
! 978: for (k = 0; k < rp->r_max.x; k++)
! 979: {
! 980: bool see_here = 0, see_before = 0;
! 981:
! 982: /* Is this in the give area -- needed for maze */
! 983: if ((j < jlow || j >= jhigh) && (k < klow || k >= khigh))
! 984: continue;
! 985:
! 986: y = rp->r_pos.y + j;
! 987: x = rp->r_pos.x + k;
! 988:
! 989: /*
! 990: * If we are in a maze do not look at this area unless
! 991: * we can see it from where we are or where we last were
! 992: * (for erasing purposes).
! 993: */
! 994: if (levtype == MAZELEV) {
! 995: /* If we can't see it from here, could we see it before? */
! 996: if ((see_here = maze_view(y, x)) == FALSE) {
! 997: coord savhero;
! 998:
! 999: /* Could we see it from where we were? */
! 1000: savhero = hero;
! 1001: hero = player.t_oldpos;
! 1002: see_before = maze_view(y, x);
! 1003: hero = savhero;
! 1004:
! 1005: if (!see_before) continue;
! 1006: }
! 1007: }
! 1008:
! 1009: ch = show(y, x);
! 1010: wmove(cw, y, x);
! 1011: /*
! 1012: * Figure out how to display a secret door
! 1013: */
! 1014: if (ch == SECRETDOOR) {
! 1015: if (j == 0 || j == rp->r_max.y - 1)
! 1016: ch = '-';
! 1017: else
! 1018: ch = '|';
! 1019: }
! 1020: /* For monsters, if they were previously not seen and
! 1021: * now can be seen, or vice-versa, make sure that will
! 1022: * happen. This is for dark rooms as opposed to invisibility.
! 1023: *
! 1024: * Call winat() in the test because ch will not reveal
! 1025: * invisible monsters.
! 1026: */
! 1027: if (isalpha(winat(y, x))) {
! 1028: struct thing *tp; /* The monster */
! 1029:
! 1030: item = wake_monster(y, x);
! 1031: tp = THINGPTR(item);
! 1032:
! 1033: /* Previously not seen -- now can see it */
! 1034: if (tp->t_oldch == ' ' && cansee(tp->t_pos.y, tp->t_pos.x))
! 1035: tp->t_oldch = CCHAR( mvinch(y, x) );
! 1036:
! 1037: /* Previously seen -- now can't see it */
! 1038: else if (!cansee(tp->t_pos.y, tp->t_pos.x) &&
! 1039: roomin(&tp->t_pos) != NULL)
! 1040: switch (tp->t_oldch) {
! 1041: /*
! 1042: * Only blank it out if it is in a room and not
! 1043: * the border (or other wall) of the room.
! 1044: */
! 1045: case DOOR:
! 1046: case SECRETDOOR:
! 1047: case '-':
! 1048: case '|':
! 1049: break;
! 1050:
! 1051: otherwise:
! 1052: tp->t_oldch = ' ';
! 1053: }
! 1054: }
! 1055:
! 1056: /*
! 1057: * If the room is a dark room, we might want to remove
! 1058: * monsters and the like from it (since they might
! 1059: * move).
! 1060: * A dark room.
! 1061: */
! 1062: if ((!lit_room(rp) && (levtype != OUTSIDE)) ||
! 1063: (levtype == OUTSIDE && !daytime) ||
! 1064: on(player, ISBLIND) ||
! 1065: (rp->r_flags & FORCEDARK) ||
! 1066: (levtype == MAZELEV && !see_here && see_before)) {
! 1067: sch = CCHAR( mvwinch(cw, y, x) ); /* What's seen */
! 1068: rch = CCHAR( mvinch(y, x) ); /* What's really there */
! 1069: switch (rch) {
! 1070: case DOOR:
! 1071: case SECRETDOOR:
! 1072: case STAIRS:
! 1073: case TRAPDOOR:
! 1074: case TELTRAP:
! 1075: case BEARTRAP:
! 1076: case SLEEPTRAP:
! 1077: case ARROWTRAP:
! 1078: case DARTTRAP:
! 1079: case MAZETRAP:
! 1080: case POOL:
! 1081: case POST:
! 1082: case '|':
! 1083: case '-':
! 1084: case WALL:
! 1085: if (isalpha(sch)) ch = rch;
! 1086: else if (sch != FLOOR) ch = sch;
! 1087: else ch = ' '; /* Hide undiscoverd things */
! 1088: when FLOOR:
! 1089: ch = ' ';
! 1090: otherwise:
! 1091: ch = ' ';
! 1092: }
! 1093: /* Take care of our magic bookkeeping. */
! 1094: switch (sch) {
! 1095: case MAGIC:
! 1096: case BMAGIC:
! 1097: case CMAGIC:
! 1098: ch = sch;
! 1099: }
! 1100: }
! 1101: mvwaddch(cw, y, x, ch);
! 1102: }
! 1103: }
! 1104: }
! 1105: }
! 1106:
! 1107: /*
! 1108: * lit_room:
! 1109: * Called to see if the specified room is lit up or not.
! 1110: */
! 1111:
! 1112: bool
! 1113: lit_room(struct room *rp)
! 1114: {
! 1115: register struct linked_list *fire_item;
! 1116: register struct thing *fire_creature;
! 1117:
! 1118: if (!(rp->r_flags & ISDARK)) return(TRUE); /* A definitely lit room */
! 1119:
! 1120: /* Is it lit by fire light? */
! 1121: if (rp->r_flags & HASFIRE) {
! 1122: switch (levtype) {
! 1123: case MAZELEV:
! 1124: /* See if a fire creature is in line of sight */
! 1125: for (fire_item = rp->r_fires; fire_item != NULL;
! 1126: fire_item = next(fire_item)) {
! 1127: fire_creature = THINGPTR(fire_item);
! 1128: if (maze_view(fire_creature->t_pos.y,
! 1129: fire_creature->t_pos.x)) return(TRUE);
! 1130: }
! 1131:
! 1132: /* Couldn't find any in line-of-sight */
! 1133: return(FALSE);
! 1134:
! 1135: /* We should probably do something special for the outside */
! 1136: otherwise:
! 1137: return TRUE;
! 1138: }
! 1139: }
! 1140: return(FALSE);
! 1141: }
! 1142:
! 1143: /*
! 1144: * rndmove:
! 1145: * move in a random direction if the monster/person is confused
! 1146: */
! 1147:
! 1148: coord *
! 1149: rndmove(struct thing *who)
! 1150: {
! 1151: register int x, y;
! 1152: register int ex, ey, nopen = 0;
! 1153: static coord ret; /* what we will be returning */
! 1154: static coord dest;
! 1155:
! 1156: ret = who->t_pos;
! 1157: /*
! 1158: * Now go through the spaces surrounding the player and
! 1159: * set that place in the array to true if the space can be
! 1160: * moved into
! 1161: */
! 1162: ey = ret.y + 1;
! 1163: ex = ret.x + 1;
! 1164: for (y = who->t_pos.y - 1; y <= ey; y++)
! 1165: if (y > 0 && y < LINES - 2)
! 1166: for (x = who->t_pos.x - 1; x <= ex; x++)
! 1167: {
! 1168: if (x < 0 || x >= COLS)
! 1169: continue;
! 1170: if (step_ok(y, x, NOMONST, who) == TRUE)
! 1171: {
! 1172: dest.y = y;
! 1173: dest.x = x;
! 1174: if (!diag_ok(&who->t_pos, &dest, who))
! 1175: continue;
! 1176: if (rnd(++nopen) == 0)
! 1177: ret = dest;
! 1178: }
! 1179: }
! 1180: return &ret;
! 1181: }
! 1182:
! 1183:
! 1184:
! 1185: /*
! 1186: * set_trap:
! 1187: * set a trap at (y, x) on screen.
! 1188: */
! 1189:
! 1190: void
! 1191: set_trap(struct thing *tp, int y, int x)
! 1192: {
! 1193: register bool is_player = (tp == &player);
! 1194: register char selection = rnd(7) + '1';
! 1195: register char ch = 0, och;
! 1196: int thief_bonus = 0;
! 1197: int s_dext;
! 1198:
! 1199: switch (och = CCHAR( mvinch(y, x) )) {
! 1200: case WALL:
! 1201: case FLOOR:
! 1202: case PASSAGE:
! 1203: break;
! 1204: default:
! 1205: msg("The trap failed!");
! 1206: return;
! 1207: }
! 1208:
! 1209: if (is_player && player.t_ctype == C_THIEF) thief_bonus = 30;
! 1210:
! 1211: s_dext = (tp == &player) ? dex_compute() : tp->t_stats.s_dext;
! 1212:
! 1213: if (ntraps >= MAXTRAPS || ++trap_tries >= MAXTRPTRY || levtype == POSTLEV ||
! 1214: rnd(80) >= (s_dext + tp->t_stats.s_lvl/2 + thief_bonus)) {
! 1215: if (is_player) msg("The trap failed!");
! 1216: return;
! 1217: }
! 1218:
! 1219:
! 1220: if (is_player) {
! 1221: int state = 0; /* 0 -> current screen, 1 -> prompt screen, 2 -> done */
! 1222:
! 1223: msg("Which kind of trap do you wish to set? (* for a list): ");
! 1224: do {
! 1225: selection = tolower(readchar());
! 1226: switch (selection) {
! 1227: case '*':
! 1228: if (state != 1) {
! 1229: wclear(hw);
! 1230: touchwin(hw);
! 1231: mvwaddstr(hw, 2, 0, "[1] Trap Door\n[2] Bear Trap\n");
! 1232: waddstr(hw, "[3] Sleep Trap\n[4] Arrow Trap\n");
! 1233: waddstr(hw, "[5] Teleport Trap\n[6] Dart Trap\n");
! 1234: if (wizard) {
! 1235: waddstr(hw, "[7] Magic pool\n[8] Maze Trap\n");
! 1236: waddstr(hw, "[9] Trading Post\n");
! 1237: }
! 1238: mvwaddstr(hw, 0, 0, "Which kind of trap do you wish to set? ");
! 1239: draw(hw);
! 1240: state = 1; /* Now in prompt window */
! 1241: }
! 1242: break;
! 1243:
! 1244: case ESCAPE:
! 1245: if (state == 1) {
! 1246: clearok(cw, TRUE); /* Set up for redraw */
! 1247: touchwin(cw);
! 1248: }
! 1249: msg("");
! 1250:
! 1251: trap_tries--; /* Don't count this one */
! 1252: after = FALSE;
! 1253: return;
! 1254:
! 1255: case '1':
! 1256: case '2':
! 1257: case '3':
! 1258: case '4':
! 1259: case '5':
! 1260: case '6':
! 1261: case '7':
! 1262: case '8':
! 1263: case '9':
! 1264: if (selection < '7' || wizard) {
! 1265: if (state == 1) { /* In prompt window */
! 1266: clearok(cw, TRUE); /* Set up for redraw */
! 1267: touchwin(cw);
! 1268: }
! 1269:
! 1270: msg("");
! 1271:
! 1272: /* Make sure there is a floor below us for trap doors */
! 1273: if (selection == '1' && level >= nfloors) {
! 1274: if (state == 1) draw(cw);
! 1275: msg("There is no level below this one.");
! 1276: return;
! 1277: }
! 1278: state = 2; /* Finished */
! 1279: break;
! 1280: }
! 1281:
! 1282: /* Fall through for non-wizard, unusual trap case */
! 1283: default:
! 1284: if (state == 1) { /* In the prompt window */
! 1285: mvwaddstr(hw, 0, 0, "Please enter a selection between 1 and 6: ");
! 1286: draw(hw);
! 1287: }
! 1288: else { /* Normal window */
! 1289: mpos = 0;
! 1290: msg("Please enter a selection between 1 and 6: ");
! 1291: }
! 1292: }
! 1293: } while (state != 2);
! 1294: }
! 1295:
! 1296: switch (selection) {
! 1297: case '1': ch = TRAPDOOR;
! 1298: when '2': ch = BEARTRAP;
! 1299: when '3': ch = SLEEPTRAP;
! 1300: when '4': ch = ARROWTRAP;
! 1301: when '5': ch = TELTRAP;
! 1302: when '6': ch = DARTTRAP;
! 1303: when '7': ch = POOL;
! 1304: when '8': ch = MAZETRAP;
! 1305: when '9': ch = POST;
! 1306: }
! 1307:
! 1308: mvaddch(y, x, ch);
! 1309: traps[ntraps].tr_show = och;
! 1310: traps[ntraps].tr_type = ch;
! 1311: traps[ntraps].tr_pos.y = y;
! 1312: traps[ntraps].tr_pos.x = x;
! 1313: if (is_player)
! 1314: traps[ntraps].tr_flags = ISTHIEFSET;
! 1315: if (ch == POOL || ch == POST) {
! 1316: traps[ntraps].tr_flags |= ISFOUND;
! 1317: }
! 1318:
! 1319: ntraps++;
! 1320: }
! 1321:
! 1322: /*
! 1323: * show:
! 1324: * returns what a certain thing will display as to the un-initiated
! 1325: */
! 1326:
! 1327: char
! 1328: show(int y, int x)
! 1329: {
! 1330: register char ch = CCHAR( winat(y, x) );
! 1331: register struct linked_list *it;
! 1332: register struct thing *tp;
! 1333:
! 1334: if (isatrap(ch)) {
! 1335: register struct trap *trp = trap_at(y, x);
! 1336:
! 1337: return (trp->tr_flags & ISFOUND) ? ch : trp->tr_show;
! 1338: }
! 1339: else if (isalpha(ch)) {
! 1340: if ((it = find_mons(y, x)) == NULL) {
! 1341: msg("Can't find monster in show");
! 1342: return(mvwinch(stdscr, y, x));
! 1343: }
! 1344: tp = THINGPTR(it);
! 1345:
! 1346: if (on(*tp, ISDISGUISE)) ch = tp->t_disguise; /* As a mimic */
! 1347:
! 1348: /* Hide invisible creatures */
! 1349: else if (invisible(tp)) {
! 1350: /* We can't see surprise-type creatures through "see invisible" */
! 1351: if (off(player,CANSEE) || on(*tp,CANSURPRISE))
! 1352: ch = CCHAR( mvwinch(stdscr, y, x) ); /* Invisible */
! 1353: }
! 1354: else if (on(*tp, CANINWALL)) {
! 1355: if (isrock(mvwinch(stdscr, y, x))) ch = CCHAR( winch(stdscr) ); /* As Xorn */
! 1356: }
! 1357: }
! 1358: return ch;
! 1359: }
! 1360:
! 1361:
! 1362: /*
! 1363: * trap_at:
! 1364: * find the trap at (y,x) on screen.
! 1365: */
! 1366:
! 1367: struct trap *
! 1368: trap_at(int y, int x)
! 1369: {
! 1370: register struct trap *tp, *ep;
! 1371:
! 1372: ep = &traps[ntraps];
! 1373: for (tp = traps; tp < ep; tp++)
! 1374: if (tp->tr_pos.y == y && tp->tr_pos.x == x)
! 1375: break;
! 1376: if (tp == ep)
! 1377: debug((sprintf(prbuf, "Trap at %d,%d not in array", y, x), prbuf));
! 1378: return tp;
! 1379: }