Annotation of early-roguelike/arogue5/monsters.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * File with various monster functions in it
! 3: *
! 4: * Advanced Rogue
! 5: * Copyright (C) 1984, 1985 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 <stdlib.h>
! 18: #include <ctype.h>
! 19: #include <string.h>
! 20:
! 21:
! 22: /*
! 23: * Check_residue takes care of any effect of the monster
! 24: */
! 25: void
! 26: check_residue(struct thing *tp)
! 27: {
! 28: /*
! 29: * Take care of special abilities
! 30: */
! 31: if (on(*tp, DIDHOLD) && (--hold_count == 0)) turn_off(player, ISHELD);
! 32:
! 33: /* If it has lowered player, give him back a level */
! 34: if (on(*tp, DIDDRAIN)) raise_level(FALSE);
! 35:
! 36: /* If frightened of this monster, stop */
! 37: if (on(player, ISFLEE) &&
! 38: player.t_dest == &tp->t_pos) turn_off(player, ISFLEE);
! 39:
! 40: /* If monster was suffocating player, stop it */
! 41: if (on(*tp, DIDSUFFOCATE)) extinguish(suffocate);
! 42:
! 43: /* If something with fire, may darken */
! 44: if (on(*tp, HASFIRE)) {
! 45: register struct room *rp=roomin(&tp->t_pos);
! 46: register struct linked_list *fire_item;
! 47:
! 48: if (rp) {
! 49: for (fire_item = rp->r_fires; fire_item != NULL;
! 50: fire_item = next(fire_item)) {
! 51: if (THINGPTR(fire_item) == tp) {
! 52: detach(rp->r_fires, fire_item);
! 53: destroy_item(fire_item);
! 54: if (rp->r_fires == NULL) {
! 55: rp->r_flags &= ~HASFIRE;
! 56: if (cansee(tp->t_pos.y, tp->t_pos.x)) light(&hero);
! 57: }
! 58: break;
! 59: }
! 60: }
! 61: }
! 62: }
! 63: }
! 64:
! 65: /*
! 66: * Creat_mons creates the specified monster -- any if 0
! 67: * person: Where to create next to
! 68: */
! 69:
! 70: bool
! 71: creat_mons(struct thing *person, short monster, bool report)
! 72: {
! 73: struct linked_list *nitem;
! 74: register struct thing *tp;
! 75: struct room *rp;
! 76: coord *mp;
! 77:
! 78: if (levtype == POSTLEV)
! 79: return(FALSE);
! 80: if ((mp = fallpos(&(person->t_pos), FALSE, 2)) != NULL) {
! 81: nitem = new_item(sizeof (struct thing));
! 82: new_monster(nitem,
! 83: monster == 0 ? randmonster(FALSE, FALSE)
! 84: : monster,
! 85: mp,
! 86: TRUE);
! 87: tp = THINGPTR(nitem);
! 88: runto(tp, &hero);
! 89: tp->t_no_move = 1; /* since it just got here, it is disoriented */
! 90: carry_obj(tp, monsters[tp->t_index].m_carry/2); /* only half chance */
! 91: if (on(*tp, HASFIRE)) {
! 92: rp = roomin(&tp->t_pos);
! 93: if (rp) {
! 94: register struct linked_list *fire_item;
! 95:
! 96: /* Put the new fellow in the room list */
! 97: fire_item = creat_item();
! 98: ldata(fire_item) = (char *) tp;
! 99: attach(rp->r_fires, fire_item);
! 100:
! 101: rp->r_flags |= HASFIRE;
! 102: }
! 103: }
! 104:
! 105: /*
! 106: * If we can see this monster, set oldch to ' ' to make light()
! 107: * think the creature used to be invisible (ie. not seen here)
! 108: */
! 109: if (cansee(tp->t_pos.y, tp->t_pos.x)) tp->t_oldch = ' ';
! 110: return(TRUE);
! 111: }
! 112: if (report) msg("You hear a faint cry of anguish in the distance.");
! 113: return(FALSE);
! 114: }
! 115:
! 116: /*
! 117: * Genmonsters:
! 118: * Generate at least 'least' monsters for this single room level.
! 119: * 'Treas' indicates whether this is a "treasure" level.
! 120: */
! 121:
! 122: void
! 123: genmonsters(int least, bool treas)
! 124: {
! 125: reg int i;
! 126: reg struct room *rp = &rooms[0];
! 127: reg struct linked_list *item;
! 128: reg struct thing *mp;
! 129: coord tp;
! 130:
! 131: for (i = 0; i < level + least; i++) {
! 132: if (!treas && rnd(100) < 50) /* put in some little buggers */
! 133: continue;
! 134: /*
! 135: * Put the monster in
! 136: */
! 137: item = new_item(sizeof *mp);
! 138: mp = THINGPTR(item);
! 139: do {
! 140: rnd_pos(rp, &tp);
! 141: } until(mvwinch(stdscr, tp.y, tp.x) == FLOOR);
! 142:
! 143: new_monster(item, randmonster(FALSE, FALSE), &tp, FALSE);
! 144: /*
! 145: * See if we want to give it a treasure to carry around.
! 146: */
! 147: carry_obj(mp, monsters[mp->t_index].m_carry);
! 148:
! 149: /* Is it going to give us some light? */
! 150: if (on(*mp, HASFIRE)) {
! 151: register struct linked_list *fire_item;
! 152:
! 153: fire_item = creat_item();
! 154: ldata(fire_item) = (char *) mp;
! 155: attach(rp->r_fires, fire_item);
! 156: rp->r_flags |= HASFIRE;
! 157: }
! 158: }
! 159: }
! 160:
! 161: /*
! 162: * id_monst returns the index of the monster given its letter
! 163: */
! 164:
! 165: short
! 166: id_monst(char monster)
! 167: {
! 168: register short result;
! 169:
! 170: result = NLEVMONS*vlevel;
! 171: if (result > NUMMONST) result = NUMMONST;
! 172:
! 173: for(; result>0; result--)
! 174: if (monsters[result].m_appear == monster) return(result);
! 175: for (result=(NLEVMONS*vlevel)+1; result <= NUMMONST; result++)
! 176: if (monsters[result].m_appear == monster) return(result);
! 177: return(0);
! 178: }
! 179:
! 180:
! 181: /*
! 182: * new_monster:
! 183: * Pick a new monster and add it to the list
! 184: */
! 185:
! 186: void
! 187: new_monster(struct linked_list *item, short type, coord *cp, bool max_monster)
! 188: {
! 189: register struct thing *tp;
! 190: register struct monster *mp;
! 191: register char *ip, *hitp;
! 192: register int i, min_intel, max_intel;
! 193: register int num_dice, num_sides=8, num_extra=0;
! 194:
! 195: attach(mlist, item);
! 196: tp = THINGPTR(item);
! 197: tp->t_turn = TRUE;
! 198: tp->t_pack = NULL;
! 199: tp->t_index = type;
! 200: tp->t_wasshot = FALSE;
! 201: tp->t_type = monsters[type].m_appear;
! 202: tp->t_ctype = C_MONSTER;
! 203: tp->t_no_move = 0;
! 204: tp->t_doorgoal = 0;
! 205: tp->t_quiet = 0;
! 206: tp->t_pos = tp->t_oldpos = *cp;
! 207: tp->t_oldch = CCHAR( mvwinch(cw, cp->y, cp->x) );
! 208: mvwaddch(mw, cp->y, cp->x, tp->t_type);
! 209: mp = &monsters[tp->t_index];
! 210:
! 211: /* Figure out monster's hit points */
! 212: hitp = mp->m_stats.s_hpt;
! 213: num_dice = atoi(hitp);
! 214: if ((hitp = strchr(hitp, 'd')) != NULL) {
! 215: num_sides = atoi(++hitp);
! 216: if ((hitp = strchr(hitp, '+')) != NULL)
! 217: num_extra = atoi(++hitp);
! 218: }
! 219:
! 220: tp->t_stats.s_lvl = mp->m_stats.s_lvl;
! 221: tp->t_stats.s_arm = mp->m_stats.s_arm;
! 222: strncpy(tp->t_stats.s_dmg,mp->m_stats.s_dmg,sizeof(tp->t_stats.s_dmg));
! 223: tp->t_stats.s_str = mp->m_stats.s_str;
! 224: if (vlevel > HARDER) { /* the deeper, the meaner we get */
! 225: tp->t_stats.s_lvl += (vlevel - HARDER);
! 226: num_dice += (vlevel - HARDER)/2;
! 227: }
! 228: if (max_monster)
! 229: tp->t_stats.s_hpt = num_dice * num_sides + num_extra;
! 230: else
! 231: tp->t_stats.s_hpt = roll(num_dice, num_sides) + num_extra;
! 232: tp->t_stats.s_exp = mp->m_stats.s_exp + mp->m_add_exp*tp->t_stats.s_hpt;
! 233:
! 234: /*
! 235: * just initailize others values to something reasonable for now
! 236: * maybe someday will *really* put these in monster table
! 237: */
! 238: tp->t_stats.s_wisdom = 8 + rnd(4);
! 239: tp->t_stats.s_dext = 8 + rnd(4);
! 240: tp->t_stats.s_const = 8 + rnd(4);
! 241: tp->t_stats.s_charisma = 8 + rnd(4);
! 242:
! 243: /* Set the initial flags */
! 244: for (i=0; i<16; i++) tp->t_flags[i] = 0;
! 245: for (i=0; i<MAXFLAGS; i++)
! 246: turn_on(*tp, mp->m_flags[i]);
! 247:
! 248: /* suprising monsters don't always surprise you */
! 249: if (!max_monster && on(*tp, CANSURPRISE) &&
! 250: off(*tp, ISUNIQUE) && rnd(100) < 20)
! 251: turn_off(*tp, CANSURPRISE);
! 252:
! 253: /* If this monster is unique, gen it */
! 254: if (on(*tp, ISUNIQUE)) mp->m_normal = FALSE;
! 255:
! 256: /*
! 257: * if is it the quartermaster, then compute his level and exp pts
! 258: * based on the level. This will make it fair when thieves try to
! 259: * steal and give them reasonable experience if they succeed.
! 260: */
! 261: if (on(*tp, CANSELL)) {
! 262: tp->t_stats.s_exp = vlevel * 100;
! 263: tp->t_stats.s_lvl = vlevel/2 + 1;
! 264: attach(tp->t_pack, new_thing(ALL));
! 265: }
! 266:
! 267: /* Normally scared monsters have a chance to not be scared */
! 268: if (on(*tp, ISFLEE) && (rnd(4) == 0)) turn_off(*tp, ISFLEE);
! 269:
! 270: /* Figure intelligence */
! 271: min_intel = atoi(mp->m_intel);
! 272: if ((ip = (char *) strchr(mp->m_intel, '-')) == NULL)
! 273: tp->t_stats.s_intel = min_intel;
! 274: else {
! 275: max_intel = atoi(++ip);
! 276: if (max_monster)
! 277: tp->t_stats.s_intel = max_intel;
! 278: else
! 279: tp->t_stats.s_intel = min_intel + rnd(max_intel - min_intel);
! 280: }
! 281: if (vlevel > HARDER)
! 282: tp->t_stats.s_intel += ((vlevel - HARDER)/2);
! 283: tp->maxstats = tp->t_stats;
! 284:
! 285: /* If the monster can shoot, it may have a weapon */
! 286: if (on(*tp, CANSHOOT) && ((rnd(100) < (22 + vlevel)) || max_monster)) {
! 287: struct linked_list *item1;
! 288: register struct object *cur, *cur1;
! 289:
! 290: item = new_item(sizeof *cur);
! 291: item1 = new_item(sizeof *cur1);
! 292: cur = OBJPTR(item);
! 293: cur1 = OBJPTR(item1);
! 294: cur->o_hplus = (rnd(4) < 3) ? 0
! 295: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 296: cur->o_dplus = (rnd(4) < 3) ? 0
! 297: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 298: cur1->o_hplus = (rnd(4) < 3) ? 0
! 299: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 300: cur1->o_dplus = (rnd(4) < 3) ? 0
! 301: : (rnd(3) + 1) * ((rnd(3) < 2) ? 1 : -1);
! 302: strcpy(cur->o_damage,"0d0");
! 303: strcpy(cur->o_hurldmg,"0d0");
! 304: strcpy(cur1->o_damage,"0d0");
! 305: strcpy(cur1->o_hurldmg,"0d0");
! 306: cur->o_ac = cur1->o_ac = 11;
! 307: cur->o_count = cur1->o_count = 1;
! 308: cur->o_group = cur1->o_group = 0;
! 309: cur->contents = cur1->contents = NULL;
! 310: if ((cur->o_hplus <= 0) && (cur->o_dplus <= 0)) cur->o_flags = ISCURSED;
! 311: if ((cur1->o_hplus <= 0) && (cur1->o_dplus <= 0))
! 312: cur1->o_flags = ISCURSED;
! 313: cur->o_flags = cur1->o_flags = 0;
! 314: cur->o_type = cur1->o_type = WEAPON;
! 315: cur->o_mark[0] = cur1->o_mark[0] = '\0';
! 316:
! 317: /* The monster may use a crossbow, sling, or an arrow */
! 318: i = rnd(100);
! 319: if (i < 10) {
! 320: cur->o_which = CROSSBOW;
! 321: cur1->o_which = BOLT;
! 322: init_weapon(cur, CROSSBOW);
! 323: init_weapon(cur1, BOLT);
! 324: }
! 325: else if (i < 70) {
! 326: cur->o_which = BOW;
! 327: cur1->o_which = ARROW;
! 328: init_weapon(cur, BOW);
! 329: init_weapon(cur1, ARROW);
! 330: }
! 331: else {
! 332: cur->o_which = SLING;
! 333: cur1->o_which = ROCK;
! 334: init_weapon(cur, SLING);
! 335: init_weapon(cur1, ROCK);
! 336: }
! 337:
! 338: attach(tp->t_pack, item);
! 339: attach(tp->t_pack, item1);
! 340: }
! 341:
! 342:
! 343: if (ISWEARING(R_AGGR))
! 344: runto(tp, &hero);
! 345: if (on(*tp, ISDISGUISE))
! 346: {
! 347: char mch = 0;
! 348:
! 349: if (tp->t_pack != NULL)
! 350: mch = (OBJPTR(tp->t_pack))->o_type;
! 351: else
! 352: switch (rnd(10)) {
! 353: case 0: mch = GOLD;
! 354: when 1: mch = POTION;
! 355: when 2: mch = SCROLL;
! 356: when 3: mch = FOOD;
! 357: when 4: mch = WEAPON;
! 358: when 5: mch = ARMOR;
! 359: when 6: mch = RING;
! 360: when 7: mch = STICK;
! 361: when 8: mch = monsters[randmonster(FALSE, FALSE)].m_appear;
! 362: when 9: mch = MM;
! 363: }
! 364: tp->t_disguise = mch;
! 365: }
! 366: }
! 367:
! 368: /*
! 369: * randmonster:
! 370: * Pick a monster to show up. The lower the level,
! 371: * the meaner the monster.
! 372: */
! 373:
! 374: short
! 375: randmonster(bool wander, bool no_unique)
! 376: {
! 377: register int d, cur_level, range, i;
! 378:
! 379: /*
! 380: * Do we want a merchant? Merchant is always in place 'NUMMONST'
! 381: */
! 382: if (wander && monsters[NUMMONST].m_wander && rnd(100) < 3) return NUMMONST;
! 383:
! 384: cur_level = vlevel;
! 385: range = 4*NLEVMONS;
! 386: i = 0;
! 387: do
! 388: {
! 389: if (i++ > range*10) { /* just in case all have be genocided */
! 390: i = 0;
! 391: if (--cur_level <= 0)
! 392: fatal("Rogue could not find a monster to make");
! 393: }
! 394: d = NLEVMONS*(cur_level - 1) + (rnd(range) - (range - 1 - NLEVMONS));
! 395: if (d < 1)
! 396: d = rnd(NLEVMONS) + 1;
! 397: if (d > NUMMONST - NUMUNIQUE - 1) {
! 398: if (no_unique)
! 399: d = rnd(range) + (NUMMONST - NUMUNIQUE - 1) - (range - 1);
! 400: else if (d > NUMMONST - 1)
! 401: d = rnd(range+NUMUNIQUE) + (NUMMONST-1) - (range+NUMUNIQUE-1);
! 402: }
! 403: }
! 404: while (wander ? !monsters[d].m_wander || !monsters[d].m_normal
! 405: : !monsters[d].m_normal);
! 406: return d;
! 407: }
! 408:
! 409: /* Sell displays a menu of goods from which the player may choose
! 410: * to purchase something.
! 411: */
! 412:
! 413: void
! 414: sell(struct thing *tp)
! 415: {
! 416: register struct linked_list *item;
! 417: register struct object *obj;
! 418: register int i, j, min_worth, nitems, goods = 0, chance, which_item;
! 419: char buffer[LINELEN];
! 420: struct {
! 421: int which;
! 422: int plus1, plus2;
! 423: int count;
! 424: int worth;
! 425: char *name;
! 426: } selection[10];
! 427:
! 428: min_worth = 100000;
! 429: item = find_mons(tp->t_pos.y, tp->t_pos.x); /* Get pointer to monster */
! 430:
! 431: /* Select the items */
! 432: nitems = rnd(6) + 5;
! 433:
! 434: for (i=0; i<nitems; i++) {
! 435: selection[i].worth = selection[i].plus1
! 436: = selection[i].plus2
! 437: = selection[i].which
! 438: = selection[i].count
! 439: = 0;
! 440: }
! 441: switch (rnd(9)) {
! 442: /* Armor */
! 443: case 0:
! 444: case 1:
! 445: goods = ARMOR;
! 446: for (i=0; i<nitems; i++) {
! 447: chance = rnd(100);
! 448: for (j = 0; j < MAXARMORS; j++)
! 449: if (chance < armors[j].a_prob)
! 450: break;
! 451: if (j == MAXARMORS) {
! 452: debug("Picked a bad armor %d", chance);
! 453: j = 0;
! 454: }
! 455: selection[i].which = j;
! 456: selection[i].count = 1;
! 457: if (rnd(100) < 40) selection[i].plus1 = rnd(5) + 1;
! 458: else selection[i].plus1 = 0;
! 459: selection[i].name = armors[j].a_name;
! 460:
! 461: /* Calculate price */
! 462: selection[i].worth = armors[j].a_worth;
! 463: selection[i].worth +=
! 464: 2 * s_magic[S_ALLENCH].mi_worth * selection[i].plus1;
! 465: if (min_worth > selection[i].worth)
! 466: min_worth = selection[i].worth;
! 467: }
! 468: break;
! 469:
! 470: /* Weapon */
! 471: case 2:
! 472: case 3:
! 473: goods = WEAPON;
! 474: for (i=0; i<nitems; i++) {
! 475: selection[i].which = rnd(MAXWEAPONS);
! 476: selection[i].count = 1;
! 477: if (rnd(100) < 35) {
! 478: selection[i].plus1 = rnd(3);
! 479: selection[i].plus2 = rnd(3);
! 480: }
! 481: else {
! 482: selection[i].plus1 = 0;
! 483: selection[i].plus2 = 0;
! 484: }
! 485: if (weaps[selection[i].which].w_flags & ISMANY)
! 486: selection[i].count = rnd(15) + 5;
! 487: selection[i].name = weaps[selection[i].which].w_name;
! 488: /*
! 489: * note: use "count" before adding in the enchantment cost
! 490: * of an item. This will keep the price of arrows
! 491: * and such to a reasonable price.
! 492: */
! 493: j = selection[i].plus1 + selection[i].plus2;
! 494: selection[i].worth = weaps[selection[i].which].w_worth;
! 495: selection[i].worth *= selection[i].count;
! 496: selection[i].worth += 2 * s_magic[S_ALLENCH].mi_worth * j;
! 497: if (min_worth > selection[i].worth)
! 498: min_worth = selection[i].worth;
! 499: }
! 500: break;
! 501:
! 502: /* Staff or wand */
! 503: case 4:
! 504: goods = STICK;
! 505: for (i=0; i<nitems; i++) {
! 506: selection[i].which = pick_one(ws_magic, MAXSTICKS);
! 507: selection[i].plus1 = rnd(11) + 5; /* Charges */
! 508: selection[i].count = 1;
! 509: selection[i].name = ws_magic[selection[i].which].mi_name;
! 510: selection[i].worth = ws_magic[selection[i].which].mi_worth;
! 511: selection[i].worth += 20 * selection[i].plus1;
! 512: if (min_worth > selection[i].worth)
! 513: min_worth = selection[i].worth;
! 514: }
! 515: break;
! 516:
! 517: /* Ring */
! 518: case 5:
! 519: goods = RING;
! 520: for (i=0; i<nitems; i++) {
! 521: selection[i].which = pick_one(r_magic, MAXRINGS);
! 522: selection[i].plus1 = rnd(2) + 1; /* Armor class */
! 523: selection[i].count = 1;
! 524: if (rnd(100) < r_magic[selection[i].which].mi_bless + 10)
! 525: selection[i].plus1 += rnd(2) + 1;
! 526: selection[i].name = r_magic[selection[i].which].mi_name;
! 527: selection[i].worth = r_magic[selection[i].which].mi_worth;
! 528:
! 529: switch (selection[i].which) {
! 530: case R_DIGEST:
! 531: if (selection[i].plus1 > 2) selection[i].plus1 = 2;
! 532: else if (selection[i].plus1 < 1) selection[i].plus1 = 1;
! 533: /* fall thru here to other cases */
! 534: case R_ADDSTR:
! 535: case R_ADDDAM:
! 536: case R_PROTECT:
! 537: case R_ADDHIT:
! 538: case R_ADDINTEL:
! 539: case R_ADDWISDOM:
! 540: if (selection[i].plus1 > 0)
! 541: selection[i].worth += selection[i].plus1 * 50;
! 542: }
! 543: if(min_worth > selection[i].worth)
! 544: min_worth = selection[i].worth;
! 545: }
! 546: break;
! 547:
! 548: /* scroll */
! 549: case 6:
! 550: goods = SCROLL;
! 551: for (i=0; i<nitems; i++) {
! 552: selection[i].which = pick_one(s_magic, MAXSCROLLS);
! 553: selection[i].count = 1;
! 554: selection[i].name = s_magic[selection[i].which].mi_name;
! 555: selection[i].worth = s_magic[selection[i].which].mi_worth;
! 556: if (min_worth > selection[i].worth)
! 557: min_worth = selection[i].worth;
! 558: }
! 559: break;
! 560:
! 561: /* potions */
! 562: case 7:
! 563: goods = POTION;
! 564: for (i=0; i<nitems; i++) {
! 565: selection[i].which = pick_one(p_magic, MAXPOTIONS);
! 566: selection[i].count = 1;
! 567: selection[i].name = p_magic[selection[i].which].mi_name;
! 568: selection[i].worth = p_magic[selection[i].which].mi_worth;
! 569: if (min_worth > selection[i].worth)
! 570: min_worth = selection[i].worth;
! 571: }
! 572: break;
! 573:
! 574: /* Miscellaneous magic */
! 575: case 8:
! 576: goods = MM;
! 577: for (i=0; i<nitems; i++) { /* don't sell as many mm as others */
! 578: selection[i].which = pick_one(m_magic, MAXMM);
! 579: selection[i].count = 1;
! 580: selection[i].name = m_magic[selection[i].which].mi_name;
! 581: selection[i].worth = m_magic[selection[i].which].mi_worth;
! 582:
! 583: switch (selection[i].which) {
! 584: case MM_JUG:
! 585: switch(rnd(9)) {
! 586: case 0: selection[i].plus1 = P_PHASE;
! 587: when 1: selection[i].plus1 = P_CLEAR;
! 588: when 2: selection[i].plus1 = P_SEEINVIS;
! 589: when 3: selection[i].plus1 = P_HEALING;
! 590: when 4: selection[i].plus1 = P_MFIND;
! 591: when 5: selection[i].plus1 = P_TFIND;
! 592: when 6: selection[i].plus1 = P_HASTE;
! 593: when 7: selection[i].plus1 = P_RESTORE;
! 594: when 8: selection[i].plus1 = P_FLY;
! 595: }
! 596: when MM_OPEN:
! 597: case MM_HUNGER:
! 598: case MM_DRUMS:
! 599: case MM_DISAPPEAR:
! 600: case MM_CHOKE:
! 601: case MM_KEOGHTOM:
! 602: selection[i].plus1 = 3 + (rnd(3)+1) * 3;
! 603: selection[i].worth += selection[i].plus1 * 50;
! 604: when MM_BRACERS:
! 605: selection[i].plus1 = rnd(10)+1;
! 606: selection[i].worth += selection[i].plus1 * 75;
! 607: when MM_DISP:
! 608: selection[i].plus1 = 2;
! 609: when MM_PROTECT:
! 610: selection[i].plus1 = rnd(5)+1;
! 611: selection[i].worth += selection[i].plus1 * 100;
! 612: when MM_SKILLS:
! 613: selection[i].plus1 = player.t_ctype;
! 614: otherwise:
! 615: break;
! 616: }
! 617: if(min_worth > selection[i].worth)
! 618: min_worth = selection[i].worth;
! 619: }
! 620: break;
! 621: }
! 622:
! 623: /* See if player can afford an item */
! 624: if (min_worth > purse) {
! 625: msg("The %s eyes your small purse and departs.",
! 626: monsters[NUMMONST].m_name);
! 627: /* Get rid of the monster */
! 628: killed(item, FALSE, FALSE);
! 629: return;
! 630: }
! 631:
! 632: /* Display the goods */
! 633: msg("The %s shows you his wares.--More--", monsters[NUMMONST].m_name);
! 634: wait_for(cw,' ');
! 635: msg("");
! 636: clearok(cw, TRUE);
! 637: touchwin(cw);
! 638:
! 639: wclear(hw);
! 640: touchwin(hw);
! 641: for (i=0; i < nitems; i++) {
! 642: mvwaddch(hw, i+2, 0, '[');
! 643: waddch(hw, (char) ((int) 'a' + i));
! 644: waddstr(hw, "] ");
! 645: switch (goods) {
! 646: case ARMOR:
! 647: waddstr(hw, "Some ");
! 648: when WEAPON:
! 649: if (selection[i].count == 1)
! 650: waddstr(hw, " A ");
! 651: else {
! 652: sprintf(buffer, "%2d ", selection[i].count);
! 653: waddstr(hw, buffer);
! 654: }
! 655: when STICK:
! 656: wprintw(hw, "A %-5s of ", ws_type[selection[i].which]);
! 657: when RING:
! 658: waddstr(hw, "A ring of ");
! 659: when SCROLL:
! 660: waddstr(hw, "A scroll of ");
! 661: when POTION:
! 662: waddstr(hw, "A potion of ");
! 663: }
! 664: if (selection[i].count > 1)
! 665: sprintf(buffer, "%s%s ", selection[i].name, "s");
! 666: else
! 667: sprintf(buffer, "%s ", selection[i].name);
! 668: wprintw(hw, "%-24s", buffer);
! 669: wprintw(hw, " Price:%5d", selection[i].worth);
! 670: }
! 671: sprintf(buffer, "Purse: %d", purse);
! 672: mvwaddstr(hw, nitems+3, 0, buffer);
! 673: mvwaddstr(hw, 0, 0, "How about one of the following goods? ");
! 674: draw(hw);
! 675: /* Get rid of the monster */
! 676: killed(item, FALSE, FALSE);
! 677:
! 678: which_item = (int) (wgetch(hw) - 'a');
! 679: while (which_item < 0 || which_item >= nitems) {
! 680: if (which_item == (int) ESCAPE - (int) 'a') {
! 681: return;
! 682: }
! 683: mvwaddstr(hw, 0, 0, "Please enter one of the listed items. ");
! 684: draw(hw);
! 685: which_item = (int) (wgetch(hw) - 'a');
! 686: }
! 687:
! 688: if (selection[which_item].worth > purse) {
! 689: msg("You cannot afford it.");
! 690: return;
! 691: }
! 692:
! 693: purse -= selection[which_item].worth;
! 694:
! 695: item = spec_item(goods, selection[which_item].which,
! 696: selection[which_item].plus1, selection[which_item].plus2);
! 697:
! 698: obj = OBJPTR(item);
! 699: if (selection[which_item].count > 1) {
! 700: obj->o_count = selection[which_item].count;
! 701: obj->o_group = newgrp();
! 702: }
! 703: /* If a stick or ring, let player know the type */
! 704: switch (goods) {
! 705: case RING: r_know[selection[which_item].which] = TRUE;
! 706: when POTION:p_know[selection[which_item].which] = TRUE;
! 707: when SCROLL:s_know[selection[which_item].which] = TRUE;
! 708: when STICK: ws_know[selection[which_item].which] = TRUE;
! 709: when MM: m_know[selection[which_item].which] = TRUE;
! 710:
! 711: }
! 712:
! 713: if (add_pack(item, FALSE, NULL) == FALSE) {
! 714:
! 715: obj->o_pos = hero;
! 716: fall(item, TRUE);
! 717: }
! 718: }
! 719:
! 720:
! 721:
! 722: /*
! 723: * what to do when the hero steps next to a monster
! 724: */
! 725: struct linked_list *
! 726: wake_monster(int y, int x)
! 727: {
! 728: register struct thing *tp;
! 729: register struct linked_list *it;
! 730: register struct room *trp;
! 731: register const char *mname;
! 732: bool nasty; /* Will the monster "attack"? */
! 733: char ch;
! 734:
! 735: if ((it = find_mons(y, x)) == NULL) {
! 736: msg("Can't find monster in show");
! 737: return (NULL);
! 738: }
! 739: tp = THINGPTR(it);
! 740: ch = tp->t_type;
! 741:
! 742: trp = roomin(&tp->t_pos); /* Current room for monster */
! 743: mname = monsters[tp->t_index].m_name;
! 744:
! 745: /*
! 746: * Let greedy ones in a room guard gold
! 747: * (except in a maze where lots of creatures would all go for the
! 748: * same piece of gold)
! 749: */
! 750: if (on(*tp, ISGREED) && off(*tp, ISRUN) &&
! 751: levtype != MAZELEV && trp != NULL &&
! 752: lvl_obj != NULL) {
! 753: register struct linked_list *item;
! 754: register struct object *cur;
! 755:
! 756: for (item = lvl_obj; item != NULL; item = next(item)) {
! 757: cur = OBJPTR(item);
! 758: if ((cur->o_type == GOLD) &&
! 759: (roomin(&cur->o_pos) == trp)) {
! 760: /* Run to the gold */
! 761: tp->t_dest = &cur->o_pos;
! 762: turn_on(*tp, ISRUN);
! 763: turn_off(*tp, ISDISGUISE);
! 764:
! 765: /* Make it worth protecting */
! 766: cur->o_count += GOLDCALC + GOLDCALC;
! 767: break;
! 768: }
! 769: }
! 770: }
! 771:
! 772: /*
! 773: * Every time he sees mean monster, it might start chasing him
! 774: */
! 775: if (on(*tp, ISMEAN) &&
! 776: off(*tp, ISHELD) &&
! 777: off(*tp, ISRUN) &&
! 778: rnd(100) > 33 &&
! 779: (!is_stealth(&player) || (on(*tp, ISUNIQUE) && rnd(100) > 95)) &&
! 780: (off(player, ISINVIS) || on(*tp, CANSEE)) ||
! 781: (trp != NULL && (trp->r_flags & ISTREAS))) {
! 782: tp->t_dest = &hero;
! 783: turn_on(*tp, ISRUN);
! 784: turn_off(*tp, ISDISGUISE);
! 785: }
! 786:
! 787: /* See if the monster will bother the player */
! 788: nasty = (on(*tp, ISRUN) && cansee(tp->t_pos.y, tp->t_pos.x));
! 789:
! 790: /*
! 791: * Let the creature summon if it can.
! 792: * Also check to see if there is room around the player,
! 793: * if not then the creature will wait
! 794: */
! 795: if (on(*tp, CANSUMMON) && nasty &&
! 796: rnd(40) < tp->t_stats.s_lvl &&
! 797: fallpos(&hero, FALSE, 2) != NULL) {
! 798: const char *helpname;
! 799: int fail;
! 800: register int which, i;
! 801:
! 802: turn_off(*tp, CANSUMMON);
! 803: helpname = monsters[tp->t_index].m_typesum;
! 804: for (which=1; which<NUMMONST; which++) {
! 805: if (strcmp(helpname, monsters[which].m_name) == 0)
! 806: break;
! 807: }
! 808: if (which >= NUMMONST)
! 809: debug("couldn't find summoned one");
! 810: if ((off(*tp, ISINVIS) || on(player, CANSEE)) &&
! 811: (off(*tp, ISSHADOW) || on(player, CANSEE)) &&
! 812: (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT))) {
! 813: if (monsters[which].m_normal == FALSE) { /* genocided? */
! 814: msg("The %s appears dismayed", mname);
! 815: monsters[tp->t_index].m_numsum = 0;
! 816: }
! 817: else {
! 818: sprintf(outstring,"The %s summons %ss for help", mname, helpname);
! 819: msg(outstring);
! 820: }
! 821: }
! 822: else {
! 823: if (monsters[which].m_normal == FALSE) /* genocided? */
! 824: monsters[tp->t_index].m_numsum = 0;
! 825: else
! 826: msg("%ss seem to appear from nowhere!", helpname);
! 827: }
! 828: /*
! 829: * try to make all the creatures around player but remember
! 830: * if unsuccessful
! 831: */
! 832: for (i=0, fail=0; i<monsters[tp->t_index].m_numsum; i++) {
! 833: if (!creat_mons(&player, which, FALSE))
! 834: fail++; /* remember the failures */
! 835: }
! 836: /*
! 837: * try once again to make the buggers
! 838: */
! 839: for (i=0; i<fail; i++)
! 840: creat_mons(tp, which, FALSE);
! 841:
! 842: /* Now let the poor fellow see all the trouble */
! 843: light(&hero);
! 844: }
! 845:
! 846: /*
! 847: * Handle monsters that can gaze and do things while running
! 848: * Player must be able to see the monster and the monster must
! 849: * not be asleep
! 850: */
! 851: if (nasty && !invisible(tp)) {
! 852: /*
! 853: * Confusion
! 854: */
! 855: if (on(*tp, CANHUH) &&
! 856: (off(*tp, ISINVIS) || on(player, CANSEE)) &&
! 857: (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT))) {
! 858: if (!save(VS_MAGIC, &player, 0)) {
! 859: if (off(player, ISCLEAR)) {
! 860: if (find_slot(unconfuse))
! 861: lengthen(unconfuse, rnd(20)+HUHDURATION);
! 862: else {
! 863: fuse(unconfuse, 0, rnd(20)+HUHDURATION, AFTER);
! 864: msg("The %s's gaze has confused you.",mname);
! 865: turn_on(player, ISHUH);
! 866: }
! 867: }
! 868: else msg("You feel dizzy for a moment, but it quickly passes.");
! 869: }
! 870: else if (rnd(100) < 67)
! 871: turn_off(*tp, CANHUH); /* Once you save, maybe that's it */
! 872: }
! 873:
! 874: /* Sleep */
! 875: if(on(*tp, CANSNORE) &&
! 876: no_command == 0 &&
! 877: !save(VS_PARALYZATION, &player, 0)) {
! 878: if (ISWEARING(R_ALERT))
! 879: msg("You feel slightly drowsy for a moment.");
! 880: else {
! 881: msg("The %s's gaze puts you to sleep.", mname);
! 882: no_command += SLEEPTIME;
! 883: if (rnd(100) < 50) turn_off(*tp, CANSNORE);
! 884: }
! 885: }
! 886:
! 887: /* Fear */
! 888: if (on(*tp, CANFRIGHTEN)) {
! 889: turn_off(*tp, CANFRIGHTEN);
! 890: if (!ISWEARING(R_HEROISM) &&
! 891: !save(VS_WAND, &player, 0) &&
! 892: !(on(player, ISFLEE) && (player.t_dest == &tp->t_pos))) {
! 893: turn_on(player, ISFLEE);
! 894: player.t_dest = &tp->t_pos;
! 895: msg("The sight of the %s terrifies you.", mname);
! 896: }
! 897: }
! 898:
! 899: /* blinding creatures */
! 900: if(on(*tp, CANBLIND) &&
! 901: !find_slot(sight) &&
! 902: !save(VS_WAND,&player, 0)){
! 903: msg("The gaze of the %s blinds you", mname);
! 904: turn_on(player, ISBLIND);
! 905: fuse(sight, 0, rnd(30)+20, AFTER);
! 906: light(&hero);
! 907: }
! 908:
! 909: /* the sight of the ghost can age you! */
! 910: if (on(*tp, CANAGE)) {
! 911: turn_off (*tp, CANAGE);
! 912: if (!save(VS_MAGIC, &player, 0)) {
! 913: msg ("The sight of the %s ages you!", mname);
! 914: pstats.s_const--;
! 915: max_stats.s_const--;
! 916: if (pstats.s_const < 0)
! 917: death (D_CONSTITUTION);
! 918: }
! 919: }
! 920:
! 921:
! 922: /* Turning to stone */
! 923: if (on(*tp, LOOKSTONE)) {
! 924: turn_off(*tp, LOOKSTONE);
! 925:
! 926: if (on(player, CANINWALL))
! 927: msg("The gaze of the %s has no effect.", mname);
! 928: else {
! 929: if (!save(VS_PETRIFICATION, &player, 0) && rnd(100) < 15) {
! 930: pstats.s_hpt = -1;
! 931: msg("The gaze of the %s petrifies you.", mname);
! 932: msg("You are turned to stone !!! --More--");
! 933: wait_for(cw,' ');
! 934: death(D_PETRIFY);
! 935: }
! 936: else {
! 937: msg("The gaze of the %s stiffens your limbs.", mname);
! 938: no_command += STONETIME;
! 939: }
! 940: }
! 941: }
! 942: }
! 943:
! 944: return it;
! 945: }
! 946: /*
! 947: * wanderer:
! 948: * A wandering monster has awakened and is headed for the player
! 949: */
! 950:
! 951: void
! 952: wanderer(void)
! 953: {
! 954: register int i;
! 955: register struct room *hr = roomin(&hero);
! 956: register struct linked_list *item;
! 957: register struct thing *tp;
! 958: register const long *attr; /* Points to monsters' attributes */
! 959: int carry; /* Chance of wanderer carrying anything */
! 960: short rmonst; /* Our random wanderer */
! 961: bool canteleport = FALSE, /* Can the monster teleport? */
! 962: seehim; /* Is monster within sight? */
! 963: coord cp;
! 964:
! 965: rmonst = randmonster(TRUE, FALSE); /* Choose a random wanderer */
! 966: attr = &monsters[rmonst].m_flags[0]; /* Start of attributes */
! 967: for (i=0; i<MAXFLAGS; i++)
! 968: if (*attr++ == CANTELEPORT) {
! 969: canteleport = TRUE;
! 970: break;
! 971: }
! 972:
! 973: /* Find a place for it -- avoid the player's room if can't teleport */
! 974: do {
! 975: do {
! 976: i = rnd_room();
! 977: } until (canteleport || hr != &rooms[i] || levtype == MAZELEV ||
! 978: levtype == OUTSIDE || levtype == POSTLEV);
! 979:
! 980: /* Make sure the monster does not teleport on top of the player */
! 981: do {
! 982: rnd_pos(&rooms[i], &cp);
! 983: } while (hr == &rooms[i] && ce(cp, hero));
! 984: } until (step_ok(cp.y, cp.x, NOMONST, NULL));
! 985:
! 986: /* Create a new wandering monster */
! 987: item = new_item(sizeof *tp);
! 988: new_monster(item, rmonst, &cp, FALSE);
! 989: tp = THINGPTR(item);
! 990: turn_on(*tp, ISRUN);
! 991: turn_off(*tp, ISDISGUISE);
! 992: tp->t_dest = &hero;
! 993: tp->t_pos = cp; /* Assign the position to the monster */
! 994: seehim = cansee(tp->t_pos.y, tp->t_pos.x);
! 995: if (on(*tp, HASFIRE)) {
! 996: register struct room *rp;
! 997:
! 998: rp = roomin(&tp->t_pos);
! 999: if (rp) {
! 1000: register struct linked_list *fire_item;
! 1001:
! 1002: fire_item = creat_item();
! 1003: ldata(fire_item) = (char *) tp;
! 1004: attach(rp->r_fires, fire_item);
! 1005:
! 1006: rp->r_flags |= HASFIRE;
! 1007: if (seehim && next(rp->r_fires) == NULL)
! 1008: light(&hero);
! 1009: }
! 1010: }
! 1011:
! 1012: /* See if we give the monster anything */
! 1013: carry = monsters[tp->t_index].m_carry;
! 1014: if (off(*tp, ISUNIQUE)) carry /= 2; /* Non-unique has only a half chance */
! 1015: carry_obj(tp, carry);
! 1016:
! 1017: /* Alert the player if a monster just teleported in */
! 1018: if (hr == &rooms[i] && canteleport && seehim && !invisible(tp)) {
! 1019: msg("A %s just teleported in", monsters[rmonst].m_name);
! 1020: light(&hero);
! 1021: running = FALSE;
! 1022: }
! 1023:
! 1024: if (wizard)
! 1025: msg("Started a wandering %s", monsters[tp->t_index].m_name);
! 1026: }
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 / arogue5