Annotation of early-roguelike/xrogue/monsters.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: monsters.c - File with various monster functions in it
! 3:
! 4: XRogue: Expeditions into the Dungeons of Doom
! 5: Copyright (C) 1991 Robert Pietkivitch
! 6: All rights reserved.
! 7:
! 8: Based on "Advanced Rogue"
! 9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
! 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 <string.h>
! 22: #include <stdlib.h>
! 23: #include "rogue.h"
! 24:
! 25: /*
! 26: * Check_residue takes care of any effect of the monster
! 27: */
! 28:
! 29: void
! 30: check_residue(struct thing *tp)
! 31: {
! 32: /*
! 33: * Take care of special abilities
! 34: */
! 35: if (on(*tp, DIDHOLD) && (--hold_count == 0)) {
! 36: turn_off(player, ISHELD);
! 37: turn_off(*tp, DIDHOLD);
! 38: }
! 39:
! 40: /* If frightened of this monster, stop */
! 41: if (on(player, ISFLEE) &&
! 42: player.t_dest == &tp->t_pos) turn_off(player, ISFLEE);
! 43:
! 44: /* If monster was suffocating player, stop it */
! 45: if (on(*tp, DIDSUFFOCATE)) {
! 46: extinguish(suffocate);
! 47: turn_off(*tp, DIDSUFFOCATE);
! 48: }
! 49:
! 50: /* If something with fire, may darken */
! 51: if (on(*tp, HASFIRE)) {
! 52: register struct room *rp=roomin(&tp->t_pos);
! 53: register struct linked_list *fire_item;
! 54:
! 55: if (rp) {
! 56: for (fire_item = rp->r_fires; fire_item != NULL;
! 57: fire_item = next(fire_item)) {
! 58: if (THINGPTR(fire_item) == tp) {
! 59: detach(rp->r_fires, fire_item);
! 60: destroy_item(fire_item);
! 61: if (rp->r_fires == NULL) {
! 62: rp->r_flags &= ~HASFIRE;
! 63: if (cansee(tp->t_pos.y, tp->t_pos.x)) light(&hero);
! 64: }
! 65: break;
! 66: }
! 67: }
! 68: }
! 69: }
! 70: }
! 71:
! 72: /*
! 73: * Creat_mons creates the specified monster -- any if 0
! 74: * person: where to create next to
! 75: */
! 76:
! 77: bool
! 78: creat_mons(struct thing *person, short monster, bool report)
! 79: {
! 80: struct linked_list *nitem;
! 81: register struct thing *tp;
! 82: struct room *rp;
! 83: coord *mp;
! 84:
! 85: if (levtype == POSTLEV)
! 86: return(FALSE);
! 87: if ((mp = fallpos(&(person->t_pos), FALSE, 2)) != NULL) {
! 88: nitem = new_item(sizeof (struct thing));
! 89: new_monster(nitem,
! 90: monster == 0 ? randmonster(FALSE, FALSE)
! 91: : monster,
! 92: mp,
! 93: TRUE);
! 94: tp = THINGPTR(nitem);
! 95: runto(tp, &hero);
! 96: carry_obj(tp, monsters[tp->t_index].m_carry/2); /* only half chance */
! 97:
! 98: /* since it just got here, it is disoriented */
! 99: tp->t_no_move = 2 * movement(tp);
! 100:
! 101: if (on(*tp, HASFIRE)) {
! 102: rp = roomin(&tp->t_pos);
! 103: if (rp) {
! 104: register struct linked_list *fire_item;
! 105:
! 106: /* Put the new fellow in the room list */
! 107: fire_item = creat_item();
! 108: ldata(fire_item) = (char *) tp;
! 109: attach(rp->r_fires, fire_item);
! 110:
! 111: rp->r_flags |= HASFIRE;
! 112: }
! 113: }
! 114:
! 115: /*
! 116: * If we can see this monster, set oldch to ' ' to make light()
! 117: * think the creature used to be invisible (ie. not seen here)
! 118: */
! 119: if (cansee(tp->t_pos.y, tp->t_pos.x)) tp->t_oldch = ' ';
! 120: return(TRUE);
! 121: }
! 122: if (report) msg("You hear a faint cry of anguish in the distance.. ");
! 123: return(FALSE);
! 124: }
! 125:
! 126: /*
! 127: * Genmonsters:
! 128: * Generate at least 'least' monsters for this single room level.
! 129: * 'Treas' indicates whether this is a "treasure" level.
! 130: */
! 131:
! 132: void
! 133: genmonsters(int least, bool treas)
! 134: {
! 135: reg int i;
! 136: reg struct room *rp = &rooms[0];
! 137: reg struct linked_list *item;
! 138: reg struct thing *mp;
! 139: coord tp;
! 140:
! 141: for (i = 0; i < (max(50, level) + least); i++) {
! 142: if (!treas && rnd(100) < 65) /* put in some little buggers */
! 143: continue;
! 144:
! 145: /*
! 146: * Put the monster in
! 147: */
! 148: item = new_item(sizeof *mp);
! 149: mp = THINGPTR(item);
! 150: do {
! 151: rnd_pos(rp, &tp);
! 152: } until(mvwinch(stdscr, tp.y, tp.x) == FLOOR);
! 153:
! 154: new_monster(item, randmonster(FALSE, FALSE), &tp, FALSE);
! 155: /*
! 156: * See if we want to give it a treasure to carry around.
! 157: */
! 158: carry_obj(mp, monsters[mp->t_index].m_carry);
! 159:
! 160: /* Calculate a movement rate */
! 161: mp->t_no_move = movement(mp);
! 162:
! 163: /* Is it going to give us some light? */
! 164: if (on(*mp, HASFIRE)) {
! 165: register struct linked_list *fire_item;
! 166:
! 167: fire_item = creat_item();
! 168: ldata(fire_item) = (char *) mp;
! 169: attach(rp->r_fires, fire_item);
! 170: rp->r_flags |= HASFIRE;
! 171: }
! 172: }
! 173: }
! 174:
! 175: /*
! 176: * id_monst returns the index of the monster given its letter
! 177: */
! 178:
! 179: short
! 180: id_monst(char monster)
! 181: {
! 182: register short result;
! 183:
! 184: if (levtype == OUTSIDE) {
! 185: result = NLEVMONS*vlevel + (NUMMONST-NUMDINOS-1);
! 186: if (result > NUMMONST) result = NUMMONST;
! 187: }
! 188: else {
! 189: result = NLEVMONS*vlevel;
! 190: if (result > NUMMONST-NUMDINOS) result = NUMMONST-NUMDINOS;
! 191: }
! 192:
! 193: if (levtype == OUTSIDE) {
! 194: for(; result>(NUMMONST-NUMDINOS-1); result--)
! 195: if (monsters[result].m_appear == monster) return(result);
! 196: for (result=(NLEVMONS*vlevel)+1; result <= NUMMONST-NUMDINOS; result++)
! 197: if (monsters[result].m_appear == monster) return(result);
! 198: }
! 199: else {
! 200: for(; result>0; result--)
! 201: if (monsters[result].m_appear == monster) return(result);
! 202: for (result=(NLEVMONS*vlevel)+1; result <= NUMMONST; result++)
! 203: if (monsters[result].m_appear == monster) return(result);
! 204: }
! 205: return(0);
! 206: }
! 207:
! 208:
! 209: /*
! 210: * new_monster:
! 211: * Pick a new monster and add it to the list
! 212: */
! 213:
! 214: void
! 215: new_monster(struct linked_list *item, short type, coord *cp, bool max_monster)
! 216: {
! 217: register struct thing *tp;
! 218: register struct monster *mp;
! 219: register char *ip, *hitp;
! 220: register int i, min_intel, max_intel;
! 221: register int num_dice, num_sides=8, num_extra=0;
! 222:
! 223: attach(mlist, item);
! 224: tp = THINGPTR(item);
! 225: tp->t_pack = NULL;
! 226: tp->t_index = type;
! 227: tp->t_wasshot = FALSE;
! 228: tp->t_type = monsters[type].m_appear;
! 229: tp->t_ctype = C_MONSTER;
! 230: tp->t_action = A_NIL;
! 231: tp->t_doorgoal.x = tp->t_doorgoal.y = -1;
! 232: tp->t_quiet = 0;
! 233: tp->t_dest = NULL;
! 234: tp->t_name = NULL;
! 235: tp->t_pos = tp->t_oldpos = *cp;
! 236: tp->t_oldch = mvwinch(cw, cp->y, cp->x);
! 237: mvwaddch(mw, cp->y, cp->x, tp->t_type);
! 238: mp = &monsters[tp->t_index];
! 239:
! 240: /* Figure out monster's hit points */
! 241: hitp = mp->m_stats.ms_hpt;
! 242: num_dice = atoi(hitp);
! 243: if ((hitp = strchr(hitp, 'd')) != NULL) {
! 244: num_sides = atoi(++hitp);
! 245: if ((hitp = strchr(hitp, '+')) != NULL)
! 246: num_extra = atoi(++hitp);
! 247: }
! 248:
! 249: tp->t_stats.s_lvladj = 0;
! 250: tp->t_stats.s_lvl = mp->m_stats.ms_lvl;
! 251: tp->t_stats.s_arm = mp->m_stats.ms_arm;
! 252: strcpy(tp->t_stats.s_dmg,mp->m_stats.ms_dmg);
! 253: tp->t_stats.s_str = mp->m_stats.ms_str;
! 254: tp->t_stats.s_dext = mp->m_stats.ms_dex;
! 255: tp->t_movement = mp->m_stats.ms_move;
! 256: if (vlevel > HARDER) { /* the deeper, the meaner we get */
! 257: tp->t_stats.s_lvl += (vlevel - HARDER);
! 258: num_dice += (vlevel - HARDER)/2;
! 259: tp->t_stats.s_arm -= (vlevel - HARDER) / 4;
! 260: }
! 261: if (max_monster)
! 262: tp->t_stats.s_hpt = num_dice * num_sides + num_extra;
! 263: else
! 264: tp->t_stats.s_hpt = roll(num_dice, num_sides) + num_extra;
! 265: tp->t_stats.s_exp = mp->m_stats.ms_exp + mp->m_add_exp*tp->t_stats.s_hpt;
! 266:
! 267: /*
! 268: * just initailize others values to something reasonable for now
! 269: * maybe someday will *really* put these in monster table
! 270: */
! 271: tp->t_stats.s_wisdom = 8 + rnd(7);
! 272: tp->t_stats.s_const = 8 + rnd(7);
! 273: tp->t_stats.s_charisma = 8 + rnd(7);
! 274:
! 275: /* Set the initial flags */
! 276: for (i=0; i<16; i++) tp->t_flags[i] = 0;
! 277: for (i=0; i<MAXFLAGS; i++)
! 278: turn_on(*tp, mp->m_flags[i]);
! 279:
! 280: /*
! 281: * these are the base chances that a creatures will do something
! 282: * assuming it can. These are(or can be) modified at runtime
! 283: * based on what the creature experiences
! 284: */
! 285: tp->t_breathe = 70; /* base chance of breathing */
! 286: tp->t_artifact = 90; /* base chance of using artifact */
! 287: tp->t_summon = 50; /* base chance of summoning */
! 288: tp->t_cast = 70; /* base chance of casting a spell */
! 289: tp->t_wand = on(*tp, ISUNIQUE) ? 35 : 50; /* base chance of using wands */
! 290:
! 291: /* suprising monsters don't always surprise you */
! 292: if (!max_monster && on(*tp, CANSURPRISE) &&
! 293: off(*tp, ISUNIQUE) && rnd(100) < 25)
! 294: turn_off(*tp, CANSURPRISE);
! 295:
! 296: /* If this monster is unique, gen it */
! 297: if (on(*tp, ISUNIQUE)) mp->m_normal = FALSE;
! 298:
! 299: /*
! 300: * If it is the quartermaster, then compute his level and exp pts
! 301: * based on the level. This will make it fair when thieves try to
! 302: * steal and give them reasonable experience if they succeed.
! 303: * Then fill his pack with his wares.
! 304: */
! 305: if (on(*tp, CANSELL)) {
! 306: tp->t_stats.s_exp = vlevel * 100;
! 307: tp->t_stats.s_lvl = vlevel/2 + 1;
! 308: make_sell_pack(tp);
! 309: }
! 310:
! 311: /* Normally scared monsters have a chance to not be scared */
! 312: if (on(*tp, ISFLEE) && (rnd(4) == 0)) turn_off(*tp, ISFLEE);
! 313:
! 314: /* Figure intelligence */
! 315: min_intel = atoi(mp->m_intel);
! 316: if ((ip = (char *) strchr(mp->m_intel, '-')) == NULL)
! 317: tp->t_stats.s_intel = min_intel;
! 318: else {
! 319: max_intel = atoi(++ip);
! 320: if (max_monster)
! 321: tp->t_stats.s_intel = max_intel;
! 322: else
! 323: tp->t_stats.s_intel = min_intel + rnd(max_intel - min_intel);
! 324: }
! 325: if (vlevel > HARDER)
! 326: tp->t_stats.s_intel += ((vlevel - HARDER)/2);
! 327: tp->maxstats = tp->t_stats;
! 328:
! 329: /* If the monster can shoot, it may have a weapon */
! 330: if (on(*tp, CANSHOOT) && ((rnd(100) < (20 + vlevel)) || max_monster)) {
! 331: struct linked_list *item1;
! 332: register struct object *cur, *cur1;
! 333:
! 334: item = new_item(sizeof *cur);
! 335: item1 = new_item(sizeof *cur1);
! 336: cur = OBJPTR(item);
! 337: cur1 = OBJPTR(item1);
! 338: cur->o_hplus = (rnd(4) < 3) ? 0
! 339: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 340: cur->o_dplus = (rnd(4) < 3) ? 0
! 341: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 342: cur1->o_hplus = (rnd(4) < 3) ? 0
! 343: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 344: cur1->o_dplus = (rnd(4) < 3) ? 0
! 345: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 346: strcpy(cur->o_damage,"0d0");
! 347: strcpy(cur->o_hurldmg,"0d0");
! 348: strcpy(cur1->o_damage,"0d0");
! 349: strcpy(cur1->o_hurldmg,"0d0");
! 350: cur->o_ac = cur1->o_ac = 11;
! 351: cur->o_count = cur1->o_count = 1;
! 352: cur->o_group = cur1->o_group = 0;
! 353: cur->contents = cur1->contents = NULL;
! 354: if ((cur->o_hplus <= 0) && (cur->o_dplus <= 0)) cur->o_flags = ISCURSED;
! 355: if ((cur1->o_hplus <= 0) && (cur1->o_dplus <= 0))
! 356: cur1->o_flags = ISCURSED;
! 357: cur->o_flags = cur1->o_flags = 0;
! 358: cur->o_type = cur1->o_type = WEAPON;
! 359: cur->o_mark[0] = cur1->o_mark[0] = '\0';
! 360:
! 361: /* The monster may use a crossbow, sling, or an arrow */
! 362: i = rnd(100);
! 363: if (i < 35) {
! 364: cur->o_which = CROSSBOW;
! 365: cur1->o_which = BOLT;
! 366: init_weapon(cur, CROSSBOW);
! 367: init_weapon(cur1, BOLT);
! 368: }
! 369: else if (i < 70) {
! 370: cur->o_which = BOW;
! 371: cur1->o_which = ARROW;
! 372: init_weapon(cur, BOW);
! 373: init_weapon(cur1, ARROW);
! 374: }
! 375: else {
! 376: cur->o_which = SLING;
! 377: cur1->o_which = ROCK;
! 378: init_weapon(cur, SLING);
! 379: init_weapon(cur1, ROCK);
! 380: }
! 381:
! 382: attach(tp->t_pack, item);
! 383: attach(tp->t_pack, item1);
! 384: }
! 385:
! 386:
! 387: /* Calculate the initial movement rate */
! 388: updpack(TRUE, tp);
! 389: tp->t_no_move = movement(tp);
! 390:
! 391: if (ISWEARING(R_AGGR))
! 392: runto(tp, &hero);
! 393:
! 394: if (on(*tp, ISDISGUISE))
! 395: {
! 396: char mch = 0;
! 397:
! 398: if (tp->t_pack != NULL)
! 399: mch = (OBJPTR(tp->t_pack))->o_type;
! 400: else
! 401: switch (rnd(10)) {
! 402: case 0: mch = GOLD;
! 403: when 1: mch = POTION;
! 404: when 2: mch = SCROLL;
! 405: when 3: mch = FOOD;
! 406: when 4: mch = WEAPON;
! 407: when 5: mch = ARMOR;
! 408: when 6: mch = RING;
! 409: when 7: mch = STICK;
! 410: when 8: mch = monsters[randmonster(FALSE, FALSE)].m_appear;
! 411: when 9: mch = MM;
! 412: }
! 413: tp->t_disguise = mch;
! 414: }
! 415: }
! 416:
! 417: /*
! 418: * randmonster:
! 419: * Pick a monster to show up. The lower the level,
! 420: * the meaner the monster.
! 421: */
! 422:
! 423: short
! 424: randmonster(bool wander, bool no_unique)
! 425: {
! 426: register int d, cur_level, range, i;
! 427:
! 428: /*
! 429: * Do we want a merchant? Merchant is always in place 'NUMMONST'
! 430: */
! 431: if (wander && monsters[NUMMONST].m_wander && rnd(100) < pstats.s_charisma/3)
! 432: return NUMMONST;
! 433:
! 434: cur_level = vlevel;
! 435: range = (4*NLEVMONS)+1; /* range is 0 thru 12 */
! 436: i = 0;
! 437: do
! 438: {
! 439: if (i++ > NUMMONST-1) { /* in case all have be genocided */
! 440: i = 0;
! 441: if (--cur_level <= 0)
! 442: fatal("rogue: Could not find a monster to make! ");
! 443: }
! 444: if (levtype == OUTSIDE) { /* create DINOSUARS */
! 445: d = (cur_level - rnd(range/2)) + (NUMMONST-NUMDINOS-1);
! 446: if (d < NUMMONST-NUMDINOS)
! 447: d = (NUMMONST-NUMDINOS) + rnd(range/2);
! 448: if (d > NUMMONST-1)
! 449: d = (NUMMONST-NUMDINOS) + rnd(NUMDINOS);
! 450: }
! 451: else { /* Create NORMALs and UNIQs here */
! 452: d = (NLEVMONS*(cur_level-1) + rnd(range) - (range-NLEVMONS-1));
! 453: if (d < 1) d = rnd(6)+1;
! 454:
! 455: if (d > NUMMONST-NUMDINOS-1) { /* Entire range NORMs + UNIQs */
! 456: if (no_unique) /* Choose from last 12 NORMAL monsters */
! 457: d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) - rnd(NUMUNIQUE/5);
! 458: else /* Choose from entire UNIQ monsters + range */
! 459: d = (NUMMONST-NUMDINOS-1) - rnd(NUMUNIQUE+range);
! 460: }
! 461: /* Half-way into the UNIQs now */
! 462: else if (d > (NUMMONST-NUMDINOS-(NUMUNIQUE/2)-1)) {
! 463: if (no_unique) /* Choose from last 15 NORMAL monsters */
! 464: d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) - rnd(NUMUNIQUE/4);
! 465: else /* Choose from entire UNIQ monsters + range */
! 466: d = (NUMMONST-NUMDINOS-1) - rnd(NUMUNIQUE+range);
! 467: }
! 468: /* End NORMALs and begin relic bearing UNIQs */
! 469: else if (d > (NUMMONST-NUMDINOS-NUMUNIQUE-1)) {
! 470: if (no_unique) /* Choose from last 20 NORMAL monsters */
! 471: d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) - rnd(NUMUNIQUE/3);
! 472: else /* Choose from first 20 UNIQ monsters */
! 473: d = (NUMMONST-NUMDINOS-NUMUNIQUE-1) + rnd(NUMUNIQUE/3);
! 474: }
! 475: }
! 476: }
! 477: while (wander ? !monsters[d].m_wander || !monsters[d].m_normal
! 478: : !monsters[d].m_normal);
! 479: return d;
! 480: }
! 481:
! 482: /* Sell displays a menu of goods from which the player may choose
! 483: * to purchase something.
! 484: */
! 485:
! 486: void
! 487: sell(struct thing *tp)
! 488: {
! 489: register struct linked_list *item, *seller;
! 490: register struct linked_list *sellpack;
! 491: register struct object *obj;
! 492: register long worth, min_worth;
! 493: char buffer[LINELEN];
! 494:
! 495: /*
! 496: * Get a linked_list pointer to the seller. We need this in case
! 497: * he disappears so we can set him ISDEAD.
! 498: */
! 499: seller = find_mons(tp->t_pos.y, tp->t_pos.x);
! 500:
! 501: sellpack = tp->t_pack;
! 502: if (sellpack == NULL) {
! 503: msg("%s looks puzzled and departs.", prname(monster_name(tp), TRUE));
! 504:
! 505: /* Get rid of the monster */
! 506: killed(seller, FALSE, FALSE, FALSE);
! 507: return;
! 508: }
! 509:
! 510: /* See how much the minimum pack item is worth */
! 511: min_worth = 100000;
! 512: for (item = sellpack; item != NULL; item = next(item)) {
! 513: obj = OBJPTR(item);
! 514: obj->o_flags |= ISPOST; /* Force a long description of the item */
! 515: worth = get_worth(obj);
! 516: if (worth < min_worth) min_worth = worth;
! 517: }
! 518:
! 519: /* See if player can afford an item */
! 520: if (min_worth > purse) {
! 521: msg("%s eyes your small purse and departs.",
! 522: prname(monster_name(tp), TRUE));
! 523:
! 524: /* Get rid of the monster */
! 525: killed(seller, FALSE, FALSE, FALSE);
! 526: return;
! 527: }
! 528:
! 529: /* Announce our intentions */
! 530: msg("%s opens his pack. --More--", prname(monster_name(tp), TRUE));
! 531: wait_for(' ');
! 532:
! 533: /* Try to sell something */
! 534: sprintf(buffer, "You got %ld gold pieces. Buy", purse);
! 535: item = get_item(sellpack, buffer, ALL, TRUE, TRUE);
! 536:
! 537: /* Get rid of the monster */
! 538: if (item != NULL) detach(tp->t_pack, item); /* Take it out of the pack */
! 539: killed(seller, FALSE, FALSE, FALSE);
! 540:
! 541: if (item == NULL) return;
! 542:
! 543: /* Can he afford the selected item? */
! 544: obj = OBJPTR(item);
! 545:
! 546: worth = get_worth(obj);
! 547: if (worth > purse) {
! 548: msg("You cannot afford it.");
! 549: o_discard(item);
! 550: return;
! 551: }
! 552:
! 553: /* Charge him through the nose */
! 554: purse -= worth;
! 555:
! 556: /* If a stick or ring, let player know the type */
! 557: switch (obj->o_type) {
! 558: case RING: r_know[obj->o_which] = TRUE;
! 559: when POTION: p_know[obj->o_which] = TRUE;
! 560: when SCROLL: s_know[obj->o_which] = TRUE;
! 561: when STICK: ws_know[obj->o_which] = TRUE;
! 562: when MM: m_know[obj->o_which] = TRUE;
! 563:
! 564: }
! 565:
! 566: /* identify it */
! 567: whatis (item);
! 568:
! 569: /* Remove the POST flag that we used for get_item() */
! 570: obj->o_flags &= ~ISPOST;
! 571:
! 572: if (add_pack(item, FALSE) == FALSE) {
! 573: obj->o_pos = hero;
! 574: fall(item, TRUE);
! 575: }
! 576: }
! 577:
! 578: /*
! 579: * what to do when the hero steps next to a monster
! 580: */
! 581:
! 582: struct linked_list *
! 583: wake_monster(int y, int x)
! 584: {
! 585: register struct thing *tp;
! 586: register struct linked_list *it;
! 587: register struct room *trp;
! 588: register char *mname;
! 589: bool nasty; /* Will the monster "attack"? */
! 590:
! 591: if ((it = find_mons(y, x)) == NULL) {
! 592: msg("Wake: can't find monster in show (%d, %d)", y, x);
! 593: return (NULL);
! 594: }
! 595: tp = THINGPTR(it);
! 596: if (on(*tp, ISSTONE)) /* if stoned, don't do anything */
! 597: return it;
! 598:
! 599: /*
! 600: * For now, if we are a friendly monster, we won't do any of
! 601: * our special effects.
! 602: */
! 603: if (on(*tp, ISFRIENDLY)) return it;
! 604:
! 605: trp = roomin(&tp->t_pos); /* Current room for monster */
! 606:
! 607: /*
! 608: * Let greedy ones in a room guard gold
! 609: * (except in a maze where lots of creatures would all go for the
! 610: * same piece of gold)
! 611: */
! 612: if (on(*tp, ISGREED) && off(*tp, ISRUN) && levtype != MAZELEV &&
! 613: trp != NULL && lvl_obj != NULL) {
! 614: register struct linked_list *item;
! 615: register struct object *cur;
! 616:
! 617: for (item = lvl_obj; item != NULL; item = next(item)) {
! 618: cur = OBJPTR(item);
! 619: if ((cur->o_type == GOLD) && (roomin(&cur->o_pos) == trp)) {
! 620: /* Run to the gold */
! 621: runto(tp, &cur->o_pos);
! 622:
! 623: /* Make it worth protecting */
! 624: cur->o_count += GOLDCALC + GOLDCALC;
! 625: break;
! 626: }
! 627: }
! 628: }
! 629:
! 630: /*
! 631: * Every time he sees mean monster, it might start chasing him
! 632: */
! 633: if (on(*tp, ISMEAN) &&
! 634: off(*tp, ISHELD) &&
! 635: off(*tp, ISRUN) &&
! 636: rnd(100) > 35 &&
! 637: (!is_stealth(&player) || (on(*tp, ISUNIQUE) && rnd(100) > 35)) &&
! 638: (off(player, ISINVIS) || on(*tp, CANSEE)) ||
! 639: (trp != NULL && (trp->r_flags & ISTREAS))) {
! 640: runto(tp, &hero);
! 641: }
! 642:
! 643: /*
! 644: * Get the name; we don't want to do it until here because we need to
! 645: * know whether the monster is still sleeping or not.
! 646: */
! 647: mname = monster_name(tp);
! 648:
! 649: /* See if the monster will bother the player */
! 650: nasty = (on(*tp, ISRUN) && cansee(tp->t_pos.y, tp->t_pos.x));
! 651:
! 652: /*
! 653: * if the creature is awake and can see the player and the
! 654: * player has the dreaded "eye of vecna" then see if the
! 655: * creature is turned to stone
! 656: */
! 657: if (cur_relic[EYE_VECNA] && nasty && off(*tp, NOSTONE) &&
! 658: (off(player, ISINVIS) || on(*tp, CANSEE))) {
! 659: turn_on(*tp, NOSTONE); /* only have to save once */
! 660: if (!save(VS_PETRIFICATION, tp, -2)) {
! 661: turn_on(*tp, ISSTONE);
! 662: turn_off(*tp, ISRUN);
! 663: turn_off(*tp, ISINVIS);
! 664: turn_off(*tp, CANSURPRISE);
! 665: turn_off(*tp, ISDISGUISE);
! 666: msg("%s is turned to stone!", prname(mname, TRUE));
! 667: return it;
! 668: }
! 669: }
! 670:
! 671: /*
! 672: * Handle monsters that can gaze and do things while running
! 673: * Player must be able to see the monster and the monster must
! 674: * not be asleep
! 675: */
! 676: if (nasty && !invisible(tp)) {
! 677: /*
! 678: * Confusion
! 679: */
! 680: if (on(*tp, CANHUH) &&
! 681: (off(*tp, ISINVIS) || on(player, CANSEE)) &&
! 682: (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT))) {
! 683: if (!save(VS_MAGIC, &player, 0)) {
! 684: if (off(player, ISCLEAR)) {
! 685: if (find_slot(unconfuse))
! 686: lengthen(unconfuse, HUHDURATION);
! 687: else {
! 688: fuse(unconfuse, NULL, HUHDURATION, AFTER);
! 689: msg("%s's gaze has confused you.",prname(mname, TRUE));
! 690: turn_on(player, ISHUH);
! 691: }
! 692: }
! 693: else msg("You feel dizzy for a moment, but it quickly passes.");
! 694: }
! 695: else if (rnd(100) < 67)
! 696: turn_off(*tp, CANHUH); /* Once you save, maybe that's it */
! 697: }
! 698:
! 699: /* Sleep */
! 700: if(on(*tp, CANSNORE) &&
! 701: player.t_action != A_FREEZE &&
! 702: !save(VS_PARALYZATION, &player, 0)) {
! 703: if (ISWEARING(R_ALERT))
! 704: msg("You feel drowsy for a moment.. ");
! 705: else {
! 706: msg("%s's gaze puts you to sleep! ", prname(mname, TRUE));
! 707: player.t_no_move += movement(&player) * SLEEPTIME;
! 708: player.t_action = A_FREEZE;
! 709: if (rnd(100) < 50) turn_off(*tp, CANSNORE);
! 710: }
! 711: }
! 712:
! 713: /* Fear */
! 714: if (on(*tp, CANFRIGHTEN) && !on(player, ISFLEE)) {
! 715: turn_off(*tp, CANFRIGHTEN);
! 716: if (!ISWEARING(R_HEROISM) &&
! 717: !save(VS_WAND, &player, -(tp->t_stats.s_lvl/10))) {
! 718: turn_on(player, ISFLEE);
! 719: player.t_dest = &tp->t_pos;
! 720: msg("The sight of %s terrifies you!", prname(mname, FALSE));
! 721: }
! 722: }
! 723:
! 724: /* blinding creatures */
! 725: if(on(*tp, CANBLIND) && !find_slot(sight)) {
! 726: turn_off(*tp, CANBLIND);
! 727: if (!save(VS_WAND, &player, 0)) {
! 728: msg("The gaze of %s blinds you! ", prname(mname, FALSE));
! 729: turn_on(player, ISBLIND);
! 730: fuse(sight, NULL, rnd(30)+20, AFTER);
! 731: light(&hero);
! 732: }
! 733: }
! 734:
! 735: /* the sight of the ghost can age you! */
! 736: if (on(*tp, CANAGE)) {
! 737: turn_off (*tp, CANAGE);
! 738: if (!save(VS_MAGIC, &player, 0)) {
! 739: msg ("The sight of %s ages you!", prname(mname, FALSE));
! 740: pstats.s_const--;
! 741: /* max_stats.s_const--; */
! 742: if (pstats.s_const < 1) {
! 743: pstats.s_hpt = -1;
! 744: death (D_CONSTITUTION);
! 745: }
! 746: }
! 747: }
! 748:
! 749: /* Turning to stone */
! 750: if (on(*tp, LOOKSTONE)) {
! 751: turn_off(*tp, LOOKSTONE);
! 752:
! 753: if (on(player, CANINWALL))
! 754: msg("The gaze of %s has no effect.", prname(mname, FALSE));
! 755: else {
! 756: if (!save(VS_PETRIFICATION, &player, 0) && rnd(100) < 5) {
! 757: pstats.s_hpt = -1;
! 758: msg("The gaze of %s petrifies you!", prname(mname, FALSE));
! 759: msg("You are turned to stone!!! --More--");
! 760: wait_for(' ');
! 761: death(D_PETRIFY);
! 762: }
! 763: else {
! 764: msg("The gaze of %s stiffens your limbs.",
! 765: prname(mname, FALSE));
! 766: player.t_no_move += movement(&player) * STONETIME;
! 767: player.t_action = A_FREEZE;
! 768: }
! 769: }
! 770: }
! 771: }
! 772:
! 773: return it;
! 774: }
! 775: /*
! 776: * wanderer:
! 777: * A wandering monster has awakened and is headed for the player
! 778: */
! 779:
! 780: void
! 781: wanderer(void)
! 782: {
! 783: register int i;
! 784: register struct room *hr = roomin(&hero);
! 785: register struct linked_list *item;
! 786: register struct thing *tp;
! 787: register long *attr; /* Points to monsters' attributes */
! 788: int carry; /* Chance of wanderer carrying anything */
! 789: short rmonst; /* Our random wanderer */
! 790: bool canteleport = FALSE, /* Can the monster teleport? */
! 791: seehim; /* Is monster within sight? */
! 792: coord cp;
! 793:
! 794: rmonst = randmonster(TRUE, FALSE); /* Choose a random wanderer */
! 795: attr = &monsters[rmonst].m_flags[0]; /* Start of attributes */
! 796: for (i=0; i<MAXFLAGS; i++)
! 797: if (*attr++ == CANTELEPORT) {
! 798: canteleport = TRUE;
! 799: break;
! 800: }
! 801:
! 802: /* Find a place for it -- avoid the player's room if can't teleport */
! 803: do {
! 804: do {
! 805: i = rnd_room();
! 806: } until (canteleport || hr != &rooms[i] || levtype == MAZELEV ||
! 807: levtype == OUTSIDE);
! 808:
! 809: /* Make sure the monster does not teleport on top of the player */
! 810: do {
! 811: rnd_pos(&rooms[i], &cp);
! 812: } while (hr == &rooms[i] && ce(cp, hero));
! 813: } until (step_ok(cp.y, cp.x, NOMONST, (struct thing *)NULL));
! 814:
! 815: /* Create a new wandering monster */
! 816: item = new_item(sizeof *tp);
! 817: new_monster(item, rmonst, &cp, FALSE);
! 818: tp = THINGPTR(item);
! 819: runto(tp, &hero);
! 820: tp->t_pos = cp; /* Assign the position to the monster */
! 821: seehim = cansee(tp->t_pos.y, tp->t_pos.x);
! 822: if (on(*tp, HASFIRE)) {
! 823: register struct room *rp;
! 824:
! 825: rp = roomin(&tp->t_pos);
! 826: if (rp) {
! 827: register struct linked_list *fire_item;
! 828:
! 829: fire_item = creat_item();
! 830: ldata(fire_item) = (char *) tp;
! 831: attach(rp->r_fires, fire_item);
! 832:
! 833: rp->r_flags |= HASFIRE;
! 834: if (seehim && next(rp->r_fires) == NULL)
! 835: light(&hero);
! 836: }
! 837: }
! 838:
! 839: /* See if we give the monster anything */
! 840: carry = monsters[tp->t_index].m_carry;
! 841: if (off(*tp, ISUNIQUE)) carry /= 2; /* Non-unique has only a half chance */
! 842: carry_obj(tp, carry);
! 843:
! 844: /* Calculate its movement rate */
! 845: tp->t_no_move = movement(tp);
! 846:
! 847: /* Alert the player if a monster just teleported in */
! 848: if (hr == &rooms[i] && canteleport && seehim && !invisible(tp)) {
! 849: msg("A %s just teleported in", monster_name(tp));
! 850: light(&hero);
! 851: running = FALSE;
! 852: }
! 853:
! 854: if (wizard)
! 855: msg("Started a wandering %s", monster_name(tp));
! 856: }
! 857:
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to monsters.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / xrogue