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