Annotation of early-roguelike/arogue7/fight.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: * fight.c - All the fighting gets done here
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: * All the fighting gets done here
17: *
18: */
19:
20: #include "curses.h"
21: #include <ctype.h>
22: #include <string.h>
23: #include <stdlib.h>
24: #include "rogue.h"
25:
26: bool roll_em(struct thing *att_er, struct thing *def_er, struct object *weap,
27: bool hurl, struct object *cur_weapon, bool back_stab);
28: void hit(struct object *weapon, bool see_att, bool see_def, char *er, char *ee,
29: bool back_stab, bool thrown, bool short_msg);
30: void miss(struct object *weapon, bool see_att, bool see_def, char *er, char *ee,
31: bool thrown, bool short_msg);
32: int add_dam(short str);
33: int hung_dam(void);
34:
35: #define CONF_DAMAGE -1
36: #define PARAL_DAMAGE -2
37: #define DEST_DAMAGE -3
38: #define DRAIN_DAMAGE -4
39:
40: /*
41: * returns true if player has a any chance to hit the monster
42: */
43: bool
44: player_can_hit(struct thing *tp, struct object *weap)
45: {
46: if (off(*tp, CMAGICHIT) && off(*tp, BMAGICHIT) && off(*tp, MAGICHIT))
47: return(TRUE);
48: if (weap && weap->o_type == RELIC)
49: return(TRUE);
50: if (on(*tp, CMAGICHIT) && weap && (weap->o_hplus>2 || weap->o_dplus>2))
51: return(TRUE);
52: if (on(*tp, BMAGICHIT) && weap && (weap->o_hplus>1 || weap->o_dplus>1))
53: return(TRUE);
54: if (on(*tp, MAGICHIT) && weap && (weap->o_hplus>0 || weap->o_dplus>0))
55: return(TRUE);
56: if (player.t_ctype == C_MONK) {
57: if (on(*tp, CMAGICHIT) && pstats.s_lvl > 15)
58: return(TRUE);
59: if (on(*tp, BMAGICHIT) && pstats.s_lvl > 10)
60: return(TRUE);
61: if (on(*tp, MAGICHIT) && pstats.s_lvl > 5)
62: return(TRUE);
63: }
64: return(FALSE);
65: }
66:
67: /*
68: * fight:
69: * The player attacks the monster.
70: */
71:
72: bool
73: fight(coord *mp, struct object *weap, bool thrown)
74: {
75: register struct thing *tp;
76: register struct linked_list *item;
77: register bool did_hit = TRUE;
78: bool see_def, back_stab = FALSE;
79: register char *mname;
80:
81: /*
82: * Find the monster we want to fight
83: */
84: if ((item = find_mons(mp->y, mp->x)) == NULL) {
85: return(FALSE); /* must have killed him already */
86: }
87: tp = THINGPTR(item);
88:
89: /*
90: * Since we are fighting, things are not quiet so no healing takes
91: * place. The -1 also tells us that we are in a fight.
92: */
93: player.t_quiet = -1;
94: tp->t_quiet = -1;
95:
96: see_def = ((off(*tp, ISINVIS) || on(player, CANSEE)) &&
97: (off(*tp, ISSHADOW) || on(player, CANSEE)) &&
98: (!thrown || cansee(unc(tp->t_pos))));
99:
100: mname = see_def ? monster_name(tp) : "something";
101:
102: /*
103: * if its in the wall, we can't hit it
104: */
105: if (on(*tp, ISINWALL) && off(player, CANINWALL))
106: return(FALSE);
107:
108: if (on(*tp, ISSTONE)) {
109: killed(item, FALSE, FALSE, FALSE);
110: if (see_def)
111: msg("%s shatters into a million pieces!", prname(mname, TRUE));
112: count = 0;
113: return (TRUE);
114: }
115: /*
116: * Let him know it was really a mimic (if it was one).
117: */
118: if (on(*tp, ISDISGUISE) && (tp->t_type != tp->t_disguise) &&
119: off(player, ISBLIND))
120: {
121: if (see_def) {
122: msg("Wait! That's a %s!", mname);
123: turn_off(*tp, ISDISGUISE);
124: }
125: did_hit = thrown;
126: }
127: if (on(*tp, CANSURPRISE) && off(player, ISBLIND) && !ISWEARING(R_ALERT)) {
128: if (see_def) {
129: msg("Wait! There's a %s!", mname);
130: turn_off(*tp, CANSURPRISE);
131: }
132: did_hit = thrown;
133: }
134:
135: /*
136: * if he's a thief or assassin and the creature is asleep then he gets
137: * a chance for a backstab
138: */
139: if ((player.t_ctype == C_THIEF || player.t_ctype == C_ASSASIN) &&
140: !thrown &&
141: !on(*tp, NOSTAB) &&
142: !invisible(tp) &&
143: (!on(*tp, ISRUN) || on(*tp, ISHELD) || tp->t_action == A_FREEZE))
144: back_stab = TRUE;
145:
146: /*
147: * assassins get an assassination chance, if it fails then its normal
148: * damage
149: */
150: if (back_stab && player.t_ctype == C_ASSASIN) {
151: int chance;
152:
153: chance = 50 + (pstats.s_lvl - tp->t_stats.s_lvl) * 5;
154: if (cur_weapon && (cur_weapon->o_flags & ISPOISON))
155: chance += 20;
156: if (roll(1,100) > chance || on(*tp, ISUNIQUE))
157: back_stab = FALSE;
158: }
159:
160: runto(tp, &hero);
161:
162: /* Let the monster know that the player has missiles! */
163: if (thrown) tp->t_wasshot = TRUE;
164:
165: if (did_hit)
166: {
167:
168: did_hit = FALSE;
169: if (!can_blink(tp) &&
170: player_can_hit(tp, weap) &&
171: roll_em(&player, tp, weap, thrown, cur_weapon, back_stab))
172: {
173: did_hit = TRUE;
174:
175: if (on(*tp, NOMETAL) && weap != NULL &&
176: weap->o_type != RELIC && weap->o_flags & ISMETAL) {
177: msg("Your %s passes right through %s!",
178: weaps[weap->o_which].w_name, prname(mname, FALSE));
179: }
180: else if (weap != NULL && weap->o_type == MISSILE && on(*tp, CARRYBAMULET)) {
181: msg("The magic missile has no affect on %s",
182: prname(mname, FALSE));
183: }
184: else {
185: hit(thrown ? NULL : weap,
186: TRUE, see_def,
187: thrown ? weap_name(weap) : NULL,
188: mname, back_stab, thrown, terse);
189:
190: /* See if there are any special effects */
191: if (effect(&player, tp, weap, thrown, TRUE, see_def) != 0)
192: killed(item, FALSE, FALSE, TRUE);
193:
194: /*
195: * Merchants just disappear if hit
196: */
197: else if (on(*tp, CANSELL)) {
198: if (see_def)
199: msg("%s disappears with his wares in a flash.",
200: prname(mname, FALSE));
201: killed(item, FALSE, FALSE, FALSE);
202: }
203:
204: else if (tp->t_stats.s_hpt <= 0)
205: killed(item, TRUE, TRUE, TRUE);
206:
207: else {
208: /* If the victim was charmed, it now gets a saving throw! */
209: if (on(*tp, ISCHARMED) && save(VS_MAGIC, tp, 0)) {
210: msg("The eyes of %s turn clear.", prname(mname, FALSE));
211: turn_off(*tp, ISCHARMED);
212: }
213:
214: dsrpt_monster(tp, FALSE, see_def); /* Disrupt a spell? */
215: }
216: }
217: }
218: else {
219: miss(thrown ? NULL : weap,
220: TRUE, see_def,
221: thrown ? weap_name(weap) : NULL,
222: mname, thrown, terse);
223: }
224: }
225: count = 0;
226: return did_hit;
227: }
228:
229: /*
230: * attack:
231: * The monster attacks the player
232: */
233:
234: bool
235: attack(struct thing *mp, struct object *weapon, bool thrown)
236: {
237: register char *mname;
238: register bool see_att, did_hit = FALSE;
239: register struct object *wielded; /* The wielded weapon */
240: struct linked_list *get_wield; /* Linked list header for wielded */
241:
242: /*
243: * Since this is an attack, stop running and any healing that was
244: * going on at the time. The -1 also tells us that we're fighting.
245: */
246: running = FALSE;
247: player.t_quiet = -1;
248: mp->t_quiet = -1;
249:
250: if (on(*mp, ISDISGUISE) && off(player, ISBLIND))
251: turn_off(*mp, ISDISGUISE);
252:
253: see_att = ((off(*mp, ISINVIS) || on(player, CANSEE)) &&
254: (off(*mp, ISSHADOW) || on(player, CANSEE)) &&
255: (!thrown || cansee(unc(mp->t_pos))));
256:
257: mname = see_att ? monster_name(mp) : "something";
258:
259: /*
260: * Try to find a weapon to wield. Wield_weap will return a
261: * projector if weapon is a projectile (eg. bow for arrow).
262: * If weapon is NULL, it will try to find a suitable weapon.
263: */
264: get_wield = wield_weap(weapon, mp);
265: if (get_wield) wielded = OBJPTR(get_wield);
266: else wielded = NULL;
267:
268: /* If we aren't wielding a weapon, wield what we found (could be NULL) */
269: if (weapon == NULL) weapon = wielded;
270:
271: if (roll_em(mp, &player, weapon, thrown, wielded, FALSE)) {
272: int death_type; /* From one of the effects of getting hit */
273:
274: did_hit = TRUE;
275:
276: if (weapon != NULL && weapon->o_type == MISSILE && cur_relic[STONEBONES_AMULET]) {
277: hit(weapon, see_att, TRUE, mname, NULL, FALSE, thrown, terse);
278: msg("Your amulet seems to absorb the magic missile");
279: }
280: else {
281: hit(weapon, see_att, TRUE, mname, NULL, FALSE, thrown, terse);
282: dsrpt_player(); /* see if we disrupted some activity */
283: if (pstats.s_hpt <= 0)
284: death(mp->t_index); /* Bye bye life ... */
285: death_type = effect(mp, &player, weapon, thrown, see_att, TRUE);
286: if (death_type != 0) death(death_type);
287: }
288:
289: }
290: else {
291: /* If the thing was trying to surprise, no good */
292: if (on(*mp, CANSURPRISE)) turn_off(*mp, CANSURPRISE);
293:
294: /* If it couldn't surprise, let's tell the player. */
295: else miss(weapon, see_att, TRUE, mname, NULL, thrown, terse);
296: }
297: if (fight_flush) md_flushinp();
298: count = 0;
299: status(FALSE);
300: return(did_hit);
301: }
302:
303: /*
304: * swing:
305: * returns true if the swing hits
306: */
307:
308: bool
309: swing(short class, int at_lvl, int op_arm, int wplus)
310: {
311: register int res = rnd(20)+1;
312: register int need;
313:
314: need = char_class[class].base -
315: char_class[class].factor *
316: ((min(at_lvl, char_class[class].max_lvl) -
317: char_class[class].offset)/char_class[class].range) +
318: (10 - op_arm);
319: if (need > 20 && need <= 25) need = 20;
320:
321: return (res+wplus >= need);
322: }
323:
324: /*
325: * roll_em:
326: * Roll several attacks
327: */
328:
329: bool
330: roll_em(struct thing *att_er, struct thing *def_er, struct object *weap,
331: bool hurl, struct object *cur_weapon, bool back_stab)
332: {
333: register struct stats *att, *def;
334: register char *cp = NULL;
335: register int ndice, nsides, nplus, def_arm;
336: bool did_hit = FALSE;
337: int prop_hplus, prop_dplus;
338: int vampiric_damage;
339:
340: /* Get statistics */
341: att = &att_er->t_stats;
342: def = &def_er->t_stats;
343:
344: prop_hplus = prop_dplus = 0;
345: if (weap == NULL) {
346: static char dmgbuf[20];
347:
348: /*
349: * monks damage grows with level
350: */
351: if (att == &pstats && player.t_ctype == C_MONK) {
352: sprintf(dmgbuf, "%dd4", att->s_lvl/3+1);
353: cp = dmgbuf;
354: }
355: else
356: cp = att->s_dmg;
357: }
358: else if (weap->o_type == RELIC) {
359: switch (weap->o_which) {
360: case MUSTY_DAGGER: cp = "1d4+1/1d4+1";
361: when YEENOGHU_FLAIL: cp = "3d6/paralyze/confuse";
362: when HRUGGEK_MSTAR: cp = "3d10";
363: when MING_STAFF: cp = "1d8";
364: when ASMO_ROD: cp = "2d8+1";
365: when ORCUS_WAND: cp = "destroy";
366: when AXE_AKLAD: if (hurl) cp = "1d6/drain";
367: else cp = "3d6/drain";
368: }
369: }
370: else if (hurl) {
371: if ((weap->o_flags&ISMISL) && cur_weapon != NULL &&
372: cur_weapon->o_which == weap->o_launch)
373: {
374: cp = weap->o_hurldmg;
375: prop_hplus = cur_weapon->o_hplus;
376: prop_dplus = cur_weapon->o_dplus;
377: }
378: else
379: cp = (weap->o_flags&ISMISL ? weap->o_damage : weap->o_hurldmg);
380: }
381: else {
382: cp = weap->o_damage;
383: /*
384: * Drain a staff of striking
385: */
386: if(weap->o_type==STICK && weap->o_which==WS_HIT && weap->o_charges==0)
387: {
388: strncpy(weap->o_damage, "1d6", sizeof(weap->o_damage));
389: weap->o_hplus = weap->o_dplus = 0;
390: }
391: }
392: /*
393: * If defender is wearing a cloak of displacement -- no damage
394: * the first time. (unless its a hurled magic missile or the
395: * attacker is very smart and can see thru the illusion)
396: */
397: if ((weap == NULL || weap->o_type != MISSILE) &&
398: def == &pstats &&
399: off(*att_er, MISSEDDISP) &&
400: att->s_intel < 22 &&
401: ((cur_misc[WEAR_CLOAK]!=NULL &&
402: cur_misc[WEAR_CLOAK]->o_which==MM_DISP) ||
403: cur_relic[EMORI_CLOAK])) {
404: turn_on(*att_er, MISSEDDISP);
405: if (cansee(att_er->t_pos.y, att_er->t_pos.x) && !invisible(att_er))
406: msg("%s looks amazed", prname(monster_name(att_er), TRUE));
407: return (FALSE);
408: }
409: if (on(*def_er, CARRYCLOAK) && def != &pstats &&
410: (weap == NULL || weap->o_type != MISSILE) && off(*att_er, MISSEDDISP) &&
411: pstats.s_intel < 22) {
412: turn_on(*att_er, MISSEDDISP);
413: msg("You feel amazed");
414: return(FALSE);
415: }
416: for (;;)
417: {
418: int damage;
419: int hplus = prop_hplus;
420: int dplus = prop_dplus;
421:
422: if (weap != NULL && weap->o_type == RELIC) {
423: switch (weap->o_which) {
424: case MUSTY_DAGGER:
425: if (att != &pstats || /* Not player or good stats */
426: (str_compute() > 15 && dex_compute() > 15)) {
427:
428: hplus += 6;
429: dplus += 6;
430:
431: /* Give an additional strength and dex bonus */
432: if (att == &pstats) {
433: hplus += str_plus(str_compute()) +
434: dext_plus(dex_compute());
435: dplus += dext_plus(dex_compute()) +
436: add_dam(str_compute());
437: }
438: else {
439: hplus += str_plus(att->s_str) +
440: dext_plus(att->s_dext);
441: dplus += dext_plus(att->s_dext) +
442: add_dam(att->s_str);
443: }
444: }
445: else {
446: hplus -= 3;
447: dplus -= 3;
448: }
449: when YEENOGHU_FLAIL:
450: case HRUGGEK_MSTAR:
451: hplus += 3;
452: dplus += 3;
453: when MING_STAFF:
454: hplus += 2;
455: dplus += 2;
456: when AXE_AKLAD:
457: hplus += 5;
458: dplus += 5;
459: }
460: }
461: else if (weap != NULL) {
462: hplus += weap->o_hplus;
463: dplus += weap->o_dplus;
464: }
465:
466: /* Is attacker weak? */
467: if (on(*att_er, HASSTINK)) hplus -= 2;
468:
469: if (att == &pstats) /* Is the attacker the player? */
470: {
471: hplus += hitweight(); /* adjust for encumberence */
472: dplus += hung_dam(); /* adjust damage for hungry player */
473: dplus += ring_value(R_ADDDAM);
474: }
475: if (back_stab || (weap && att != &pstats && on(*att_er, CANBSTAB)))
476: hplus += 4; /* add in pluses for backstabbing */
477:
478: /* Get the damage */
479: while (isspace(*cp)) cp++;
480: if (!isdigit(*cp)) {
481: if (strncmp(cp, "confuse", 7) == 0) ndice = CONF_DAMAGE;
482: else if (strncmp(cp, "paralyze", 8) == 0) ndice = PARAL_DAMAGE;
483: else if (strncmp(cp, "destroy", 7) == 0) ndice = DEST_DAMAGE;
484: else if (strncmp(cp, "drain", 5) == 0) ndice = DRAIN_DAMAGE;
485: else ndice = 0;
486: nsides = 0;
487: nplus = 0;
488: }
489: else {
490: char *oldcp;
491:
492: /* Get the number of damage dice */
493: ndice = atoi(cp);
494: if ((cp = strchr(cp, 'd')) == NULL)
495: break;
496:
497: /* Skip the 'd' and get the number of sides per die */
498: nsides = atoi(++cp);
499:
500: /* Check for an addition -- save old place in case none is found */
501: oldcp = cp;
502: if ((cp = strchr(cp, '+')) != NULL) nplus = atoi(++cp);
503: else {
504: nplus = 0;
505: cp = oldcp;
506: }
507: }
508:
509: if (def == &pstats) { /* Monster attacks player */
510: if (on(*att_er, NOMETAL))
511: def_arm = ac_compute(TRUE) - dext_prot(dex_compute());
512: else
513: def_arm = ac_compute(FALSE) - dext_prot(dex_compute());
514: hplus += str_plus(att->s_str)+dext_plus(att->s_dext);
515: }
516: else if (att == &pstats) { /* Player attacks monster */
517: def_arm = def->s_arm - dext_prot(def->s_dext);
518: if (player.t_ctype == C_MONK) /* no strength bonus for monk */
519: if (weap == NULL)
520: hplus += att->s_lvl/5; /* monks hplus varies with level */
521: else
522: hplus += str_plus(str_compute())+dext_plus(dex_compute());
523: }
524: else { /* Monster attacks monster */
525: def_arm = def->s_arm - dext_prot(def->s_dext);
526: hplus += str_plus(att->s_str)+dext_plus(att->s_dext);
527: }
528:
529: if (swing(att_er->t_ctype, att->s_lvl, def_arm, hplus)) {
530: register int proll;
531:
532: /* Take care of special effects */
533: switch (ndice) {
534: case CONF_DAMAGE:
535: if (def == &pstats) { /* Monster attacks player */
536: if (!save(VS_MAGIC, &player, 0) && off(player, ISCLEAR)) {
537: msg("You feel disoriented.");
538: if (find_slot(unconfuse))
539: lengthen(unconfuse, HUHDURATION);
540: else
541: fuse(unconfuse, NULL, HUHDURATION, AFTER);
542: turn_on(player, ISHUH);
543: }
544: else msg("You feel dizzy, but it quickly passes.");
545: }
546: /* Player or monster hits monster */
547: else if (!save(VS_MAGIC, def_er, 0) && off(*def_er, ISCLEAR)) {
548: if (att == &pstats)
549: msg("The artifact warms with pleasure.");
550: turn_on(*def_er, ISHUH);
551: }
552: did_hit = TRUE;
553: when PARAL_DAMAGE:
554: if (def == &pstats) { /* Monster attacks player */
555: if (!save(VS_MAGIC, &player, 0) && off(player, CANINWALL)) {
556: msg("You stiffen up.");
557: player.t_no_move += movement(&player) * FREEZETIME;
558: player.t_action = A_FREEZE;
559: }
560: }
561: else if (!save(VS_MAGIC, def_er, 0)) { /* Player hits monster */
562: if (att == &pstats) msg("The artifact hums happily.");
563: turn_off(*def_er, ISRUN);
564: turn_on(*def_er, ISHELD);
565: }
566: did_hit = TRUE;
567: when DEST_DAMAGE:
568: if (def == &pstats) { /* Monster attacks player */
569: msg("You feel a tug at your life force.");
570: if (!save(VS_MAGIC, &player, -4)) {
571: msg("The wand devours your soul.");
572: def->s_hpt = 0;
573: }
574: }
575: /* Player hits monster */
576: else if (!save(VS_MAGIC, def_er, -4)) {
577: if (att == &pstats)
578: msg("The artifact draws energy.");
579:
580: /* Give the attacker half the monster's hits */
581: att->s_hpt += def->s_hpt/2;
582: if (att->s_hpt > att_er->maxstats.s_hpt)
583: att->s_hpt = att_er->maxstats.s_hpt;
584:
585: /* Kill the monster */
586: def->s_hpt = 0;
587: }
588: did_hit = TRUE;
589: when DRAIN_DAMAGE:
590: if (def == &pstats) { /* Monster attacks player */
591: if (!save(VS_MAGIC, &player, -4)) {
592: lower_level(att_er->t_index);
593: }
594: }
595: /* Player hits monster */
596: else if (!save(VS_MAGIC, def_er, -4)) {
597: def->s_hpt -= roll(1, 8);
598: def->s_lvl--;
599: if (def->s_lvl <= 0)
600: def->s_hpt = 0; /* he's dead */
601: if (att == &pstats)
602: msg("The artifact cackles with laughter");
603: }
604: did_hit = TRUE;
605: otherwise:
606: /* Heil's ankh always gives maximum damage */
607: if (att == &pstats && cur_relic[HEIL_ANKH])
608: proll = ndice * nsides;
609: else proll = roll(ndice, nsides);
610:
611: if (ndice + nsides > 0 && proll < 1)
612: debug("Damage for %dd%d came out %d.",
613: ndice, nsides, proll);
614: damage = dplus + proll + nplus;
615: if (att == &pstats) {
616: /*
617: * Monks do not get strength bonus on damage. Instead,
618: * if they are wielding a weapon, they get at extra
619: * 1/2 point per level of damage.
620: */
621: if(player.t_ctype == C_MONK) {
622: /* Bonus does not apply for hands. */
623: if (weap != NULL) damage += att->s_lvl / 2;
624: }
625: else
626: damage += add_dam(str_compute());
627: }
628: else
629: damage += add_dam(att->s_str);
630:
631: /* Check for half damage monsters */
632: if (on(*def_er, HALFDAMAGE)) damage /= 2;
633:
634: /* add in multipliers for backstabbing */
635: if (back_stab ||
636: (weap && att != &pstats && on(*att_er, CANBSTAB))) {
637: int mult = 2 + (att->s_lvl-1)/4; /* Normal multiplier */
638:
639: if (mult > 5)
640: mult = 5;
641: if (weap && weap->o_type == RELIC &&
642: weap->o_which == MUSTY_DAGGER)
643: mult++;
644: damage *= mult;
645: }
646: if (att == &pstats) {
647: if (cur_weapon && (cur_weapon->o_flags & ISPOISON)) {
648: cur_weapon->o_flags &= ~ISPOISON;
649: if (save(VS_POISON, def_er, -2))
650: damage += def->s_hpt/4;
651: else
652: damage += def->s_hpt/2;
653: }
654: if (back_stab && player.t_ctype == C_ASSASIN)
655: damage = def->s_hpt + 1;
656: }
657: /* Check for no-damage and division */
658: if (on(*def_er, BLOWDIVIDE)) {
659: damage = 0;
660: creat_mons(def_er, def_er->t_index, FALSE);
661: if (cansee(unc(def_er->t_pos))) light(&hero);
662: }
663: /* check for immunity to metal -- RELICS are always bad */
664: if (on(*def_er, NOMETAL) && weap != NULL &&
665: weap->o_type != RELIC && weap->o_flags & ISMETAL) {
666: damage = 0;
667: }
668: if (weap != NULL && weap->o_type == MISSILE) {
669: if ((def == &pstats && cur_relic[STONEBONES_AMULET]) ||
670: (att == &pstats && on(*def_er, CARRYBAMULET))) {
671: damage = 0;
672: }
673: }
674:
675:
676: def->s_hpt -= max(0, damage); /* Do the damage */
677: did_hit = TRUE;
678: vampiric_damage = damage;
679: if (def->s_hpt < 0) /* only want REAL damage inflicted */
680: vampiric_damage += def->s_hpt;
681: if (vampiric_damage < 0)
682: vampiric_damage = 0;
683: if (att == &pstats && ISWEARING(R_VAMPREGEN) && !hurl) {
684: if ((pstats.s_hpt += vampiric_damage/2) > max_stats.s_hpt)
685: pstats.s_hpt = max_stats.s_hpt;
686: }
687: debug ("hplus=%d dmg=%d", hplus, damage);
688: }
689: }
690: if ((cp = strchr(cp, '/')) == NULL)
691: break;
692: cp++;
693: }
694: return did_hit;
695: }
696:
697: /*
698: * prname:
699: * The print name of a combatant
700: */
701:
702: char *
703: prname(char *who, bool upper)
704: {
705: static char tbuf[LINELEN];
706:
707: *tbuf = '\0';
708: if (who == 0)
709: strcpy(tbuf, "you");
710: else if (on(player, ISBLIND) || strcmp(who, "something") == 0)
711: strcpy(tbuf, "something");
712: else
713: {
714: /* If we have a name (starts with a capital), don't use a "the" */
715: if (islower(*who)) strcpy(tbuf, "the ");
716: strcat(tbuf, who);
717: }
718: if (upper)
719: *tbuf = toupper(*tbuf);
720: return tbuf;
721: }
722:
723: /*
724: * hit:
725: * Print a message to indicate a succesful hit
726: */
727:
728: void
729: hit(struct object *weapon, bool see_att, bool see_def, char *er, char *ee,
730: bool back_stab, bool thrown, bool short_msg)
731: {
732: register char *s = "";
733: char att_name[LINELEN], /* Name of attacker */
734: def_name[LINELEN]; /* Name of defender */
735:
736: /* If we can't see either the attacker or defender, don't say anything */
737: if (!see_att && !see_def) return;
738:
739: /* What do we call the attacker? */
740: strcpy(att_name, see_att ? prname(er, TRUE) : "Something");
741: if (er) { /* A monster is attacking */
742:
743: /* If the monster is using a weapon and we can see it, report it */
744: if (weapon != NULL && (see_att || thrown)) {
745: strcat(att_name, "'s ");
746: strcat(att_name, weap_name(weapon));
747: }
748: }
749:
750: /* What do we call the defender? */
751: strcpy(def_name, see_def ? prname(ee, FALSE) : "something");
752:
753: addmsg(att_name);
754: if (short_msg) {
755: if (back_stab) {
756: if (player.t_ctype == C_ASSASIN)
757: s = (er == 0 ? " assassinate!" : " assassinates!");
758: else
759: s = (er == 0 ? " backstab!" : " backstabs!");
760: }
761: else
762: s = " hit.";
763: }
764: else {
765: if (back_stab) {
766: if (player.t_ctype == C_ASSASIN)
767: s = (er == 0 ? " have assassinated " : " has assassinated ");
768: else
769: s = (er == 0 ? " have backstabbed " : " has backstabbed ");
770: }
771: else {
772: switch (rnd(thrown ? 2 : 3))
773: {
774: case 0: s = " hit ";
775: when 1: s = " injured ";
776: when 2: s = " smacked ";
777: }
778: }
779: }
780: if (short_msg) addmsg(s);
781: else addmsg("%s%s.", s, def_name);
782: endmsg();
783: }
784:
785: /*
786: * miss:
787: * Print a message to indicate a poor swing
788: */
789:
790: void
791: miss(struct object *weapon, bool see_att, bool see_def, char *er, char *ee,
792: bool thrown, bool short_msg)
793: {
794: register char *s = "";
795: char
796: att_name[LINELEN], /* Name of attacker */
797: def_name[LINELEN]; /* Name of defender */
798:
799: /* If we can't see either the attacker or defender, don't say anything */
800: if (!see_att && !see_def) return;
801:
802: /* What do we call the attacker? */
803: strcpy(att_name, see_att ? prname(er, TRUE) : "Something");
804: if (er) { /* A monster is attacking */
805:
806: /* If the monster is using a weapon and we can see it, report it */
807: if (weapon != NULL && (see_att || thrown)) {
808: strcat(att_name, "'s ");
809: strcat(att_name, weap_name(weapon));
810: }
811: }
812:
813: /* What do we call the defender? */
814: strcpy(def_name, see_def ? prname(ee, FALSE) : "something");
815:
816: addmsg(att_name);
817: switch (short_msg ? 0 : rnd(thrown ? 3 : 2))
818: {
819: case 0: s = (er == 0 ? " miss" : " misses");
820: when 1: s = (er == 0 ? " don't hit" : " doesn't hit");
821: when 2: s = (" whizzes by");
822: }
823: if (short_msg) addmsg("%s.", s);
824: else addmsg("%s %s.", s, def_name);
825: endmsg();
826: }
827:
828: /*
829: * dext_plus:
830: * compute to-hit bonus for dexterity
831: */
832:
833: int
834: dext_plus(int dexterity)
835: {
836: return (dexterity > 10 ? (dexterity-13)/3 : (dexterity-10)/3);
837: }
838:
839:
840: /*
841: * dext_prot:
842: * compute armor class bonus for dexterity
843: */
844:
845: int
846: dext_prot(int dexterity)
847: {
848: return ((dexterity-10)/2);
849: }
850: /*
851: * str_plus:
852: * compute bonus/penalties for strength on the "to hit" roll
853: */
854:
855: int
856: str_plus(short str)
857: {
858: return((str-10)/3);
859: }
860:
861: /*
862: * add_dam:
863: * compute additional damage done for exceptionally high or low strength
864: */
865:
866: int
867: add_dam(short str)
868: {
869: return((str-9)/2);
870: }
871:
872: /*
873: * hung_dam:
874: * Calculate damage depending on players hungry state
875: */
876: int
877: hung_dam(void)
878: {
879: reg int howmuch;
880:
881: switch(hungry_state) {
882: case F_SATIATED:
883: case F_OKAY:
884: case F_HUNGRY: howmuch = 0;
885: when F_WEAK: howmuch = -1;
886: when F_FAINT: howmuch = -2;
887: }
888: return howmuch;
889: }
890:
891: #ifdef THUNK
892: /*
893: * thunk:
894: * A missile hits a monster
895: * tp: defender
896: */
897:
898: void
899: thunk(struct object *weap, struct thing *tp, char *mname)
900: {
901: char *def_name; /* Name of defender */
902:
903: /* What do we call the defender? */
904: if (!cansee(tp->t_pos.y, tp->t_pos.x) || invisible(tp))
905: def_name = "something";
906: else def_name = prname(mname, FALSE);
907:
908: if (weap->o_type == WEAPON)
909: msg("The %s hits %s.", weaps[weap->o_which].w_name, def_name);
910: else if (weap->o_type == MISSILE)
911: msg("The %s hits %s.",ws_magic[weap->o_which].mi_name, def_name);
912: else
913: msg("You hit %s.", def_name);
914: }
915:
916: /*
917: * mthunk:
918: * A missile from a monster hits the player
919: */
920:
921: void
922: m_thunk(struct object *weap, struct thing *tp, char *mname)
923: {
924: char *att_name; /* Name of attacker */
925:
926: /* What do we call the attacker? */
927: if (!cansee(tp->t_pos.y, tp->t_pos.x) || invisible(tp))
928: att_name = "Something";
929: else att_name = prname(mname, TRUE);
930:
931: if (weap->o_type == WEAPON)
932: msg("%s's %s hits you.", att_name, weaps[weap->o_which].w_name);
933: else if (weap->o_type == MISSILE)
934: msg("%s's %s hits you.", att_name, ws_magic[weap->o_which].mi_name);
935: else
936: msg("%s hits you.", att_name);
937: }
938:
939: /*
940: * bounce:
941: * A missile misses a monster
942: * tp: defender
943: */
944:
945: void
946: bounce(struct object *weap, struct thing *tp, char *mname)
947: {
948: char *def_name; /* Name of defender */
949:
950: /* What do we call the defender? */
951: if (!cansee(tp->t_pos.y, tp->t_pos.x) || invisible(tp))
952: def_name = "something";
953: else def_name = prname(mname, FALSE);
954:
955: if (weap->o_type == WEAPON)
956: msg("The %s misses %s.",weaps[weap->o_which].w_name, def_name);
957: else if (weap->o_type == MISSILE)
958: msg("The %s misses %s.",ws_magic[weap->o_which].mi_name, def_name);
959: else
960: msg("You missed %s.", def_name);
961: }
962:
963: /*
964: * m_bounce:
965: * A missle from a monster misses the player
966: */
967:
968: void
969: m_bounce(struct object *weap, struct thing *tp, char *mname)
970: {
971: char *att_name; /* Name of attacker */
972:
973: /* What do we call the attacker? */
974: if (!cansee(tp->t_pos.y, tp->t_pos.x) || invisible(tp))
975: att_name = "Something";
976: else att_name = prname(mname, TRUE);
977:
978: if (weap->o_type == WEAPON)
979: msg("%s's %s misses you.", att_name, weaps[weap->o_which].w_name);
980: else if (weap->o_type == MISSILE)
981: msg("%s's %s misses you.", att_name, ws_magic[weap->o_which].mi_name);
982: else
983: msg("%s misses you.", att_name);
984: }
985: #endif
986:
987:
988: /*
989: * is_magic:
990: * Returns true if an object radiates magic
991: */
992:
993: bool
994: is_magic(struct object *obj)
995: {
996: switch (obj->o_type)
997: {
998: case ARMOR:
999: return obj->o_ac != armors[obj->o_which].a_class;
1000: when WEAPON:
1001: return obj->o_hplus != 0 || obj->o_dplus != 0;
1002: when POTION:
1003: case SCROLL:
1004: case STICK:
1005: case RING:
1006: case MM:
1007: case RELIC:
1008: return TRUE;
1009: }
1010: return FALSE;
1011: }
1012:
1013: /*
1014: * killed:
1015: * Called to put a monster to death
1016: */
1017:
1018: int chance = 0;/* cumulative chance for goodies to loose it */
1019:
1020: void
1021: killed(struct linked_list *item, bool pr, bool points, bool treasure)
1022: {
1023: register struct thing *tp, *mp;
1024: register struct linked_list *pitem, *nexti, *mitem;
1025: char *monst;
1026:
1027: tp = THINGPTR(item);
1028:
1029: if (pr)
1030: {
1031: addmsg(terse ? "Defeated " : "You have defeated ");
1032: if (on(player, ISBLIND))
1033: msg("it.");
1034: else
1035: {
1036: if (cansee(tp->t_pos.y, tp->t_pos.x) && !invisible(tp))
1037: monst = monster_name(tp);
1038: else {
1039: if (terse) monst = "something";
1040: else monst = "thing";
1041: }
1042: if (!terse)
1043: addmsg("the ");
1044: msg("%s.", monst);
1045: }
1046: }
1047:
1048: /* Take care of any residual effects of the monster */
1049: check_residue(tp);
1050:
1051: /* Make sure that no one is still chasing us */
1052: for (mitem = mlist; mitem != NULL; mitem = next(mitem)) {
1053: mp = THINGPTR(mitem);
1054: if (mp->t_dest == &tp->t_pos) {
1055: mp->t_dest = &hero;
1056: mp->t_wasshot = FALSE;
1057: turn_off(*mp, ISFLEE); /* Be sure we aren't running away! */
1058: }
1059: }
1060:
1061: if (points) {
1062: if ((off(*tp, ISMEAN) || on(*tp, ISFRIENDLY)) &&
1063: (player.t_ctype == C_RANGER || player.t_ctype == C_PALADIN)) {
1064: if (tp->t_stats.s_exp > pstats.s_exp)
1065: pstats.s_exp = 0;
1066: else
1067: pstats.s_exp -= tp->t_stats.s_exp;
1068: if (roll(1,100) < chance++)
1069: changeclass(C_FIGHTER);
1070: else
1071: msg("You feel uneasy for a moment");
1072: }
1073: else {
1074: unsigned long test; /* For overflow check */
1075: /*
1076: * Do an overflow check before increasing experience
1077: */
1078: test = pstats.s_exp + tp->t_stats.s_exp;
1079: if (test > pstats.s_exp)
1080: pstats.s_exp = test;
1081: }
1082:
1083: /*
1084: * Do adjustments if he went up a level
1085: */
1086: check_level();
1087: }
1088:
1089: /*
1090: * Empty the monsters pack
1091: */
1092: pitem = tp->t_pack;
1093:
1094: /*
1095: * Get rid of the monster.
1096: */
1097: mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, ' ');
1098: mvwaddch(cw, tp->t_pos.y, tp->t_pos.x, tp->t_oldch);
1099: detach(mlist, item);
1100: if (on(*tp, AREMANY) && levtype == NORMLEV) /* AREMANYs stick together */
1101: wake_room(roomin(&tp->t_pos));
1102: /*
1103: * empty his pack
1104: */
1105: while (pitem != NULL)
1106: {
1107: nexti = next(tp->t_pack);
1108: (OBJPTR(pitem))->o_pos = tp->t_pos;
1109: detach(tp->t_pack, pitem);
1110: if (treasure)
1111: fall(pitem, FALSE);
1112: else
1113: o_discard(pitem);
1114: pitem = nexti;
1115: }
1116: turn_on(*tp,ISDEAD);
1117: attach(monst_dead,item);
1118: }
1119:
1120:
1121: /*
1122: * Returns a pointer to the weapon the monster is wielding corresponding to
1123: * the given thrown weapon. If no thrown item is given, try to find any
1124: * decent weapon.
1125: */
1126:
1127: struct linked_list *
1128: wield_weap(struct object *thrown, struct thing *mp)
1129: {
1130: int look_for, /* The projectile weapon we are looking for */
1131: new_rate, /* The rating of a prospective weapon */
1132: cand_rate = -1; /* Rating of current candidate -- higher is better */
1133: register struct linked_list *pitem, *candidate = NULL;
1134: register struct object *obj;
1135:
1136: if (thrown != NULL) { /* Using a projectile weapon */
1137: switch (thrown->o_which) {
1138: case BOLT: look_for = CROSSBOW; /* Find the crossbow */
1139: when ARROW: look_for = BOW; /* Find the bow */
1140: when ROCK: look_for = SLING; /* find the sling */
1141: otherwise: return(NULL);
1142: }
1143: }
1144: else if (off(*mp, ISUNIQUE) && off(*mp, CARRYWEAPON)) return(NULL);
1145:
1146: for (pitem=mp->t_pack; pitem; pitem=next(pitem)) {
1147: obj = OBJPTR(pitem);
1148:
1149: /*
1150: * If we have a thrown weapon, just return the first match
1151: * we come to.
1152: */
1153: if (thrown != NULL && obj->o_type == WEAPON && obj->o_which == look_for)
1154: return(pitem);
1155:
1156: /* If we have a usable RELIC, return it */
1157: if (thrown == NULL && obj->o_type == RELIC) {
1158: switch (obj->o_which) {
1159: case MUSTY_DAGGER:
1160: case YEENOGHU_FLAIL:
1161: case HRUGGEK_MSTAR:
1162: case AXE_AKLAD:
1163: case MING_STAFF:
1164: case ASMO_ROD:
1165: case ORCUS_WAND:
1166: return(pitem);
1167: }
1168: }
1169:
1170: /* Otherwise if it's a usable weapon, it is a good candidate */
1171: else if (thrown == NULL && obj->o_type == WEAPON) {
1172: switch (obj->o_which) {
1173: case DAGGER:
1174: case SPEAR:
1175: new_rate = 0;
1176: when BATTLEAXE:
1177: new_rate = 1;
1178: when MACE:
1179: new_rate = 2;
1180: when SWORD:
1181: new_rate = 3;
1182: when PIKE:
1183: new_rate = 4;
1184: when HALBERD:
1185: case SPETUM:
1186: new_rate = 6;
1187: when BARDICHE:
1188: new_rate = 7;
1189: when TRIDENT:
1190: new_rate = 8;
1191: when BASWORD:
1192: new_rate = 9;
1193: when TWOSWORD:
1194: new_rate = 10;
1195: otherwise:
1196: new_rate = -1;
1197: }
1198:
1199: /* Only switch if this is better than the current candidate */
1200: if (new_rate > cand_rate) {
1201: cand_rate = new_rate;
1202: candidate = pitem;
1203: }
1204: }
1205: }
1206:
1207: return(candidate);
1208: }
1209:
1210: void
1211: explode(struct thing *tp)
1212: {
1213:
1214: register int x,y, damage;
1215: struct linked_list *item;
1216: struct thing *th;
1217:
1218: /*
1219: * check to see if it got the hero
1220: */
1221: if (off(player, ISINWALL) &&
1222: DISTANCE(hero.x, hero.y, tp->t_pos.x, tp->t_pos.y) <= 25) {
1223: msg("The explosion hits you");
1224: damage = roll(6,6);
1225: if (save(VS_WAND, &player, 0))
1226: damage /= 2;
1227: pstats.s_hpt -= damage;
1228: }
1229:
1230: /*
1231: * now check for monsters in vicinity
1232: */
1233: for (x = tp->t_pos.x-5; x<=tp->t_pos.x+5; x++) {
1234: if (x < 0 || x > cols - 1)
1235: continue;
1236: for (y = tp->t_pos.y-5; y<=tp->t_pos.y+5; y++) {
1237: if (y < 1 || y > lines - 3)
1238: continue;
1239: if (isalpha(mvwinch(mw, y, x))) {
1240: if ((item = find_mons(y, x)) != NULL) {
1241: th = THINGPTR(item);
1242: if (th == tp || /* don't count gas spore */
1243: on(*th, ISINWALL)) /* Don't count monsters in wall */
1244: continue;
1245: damage = roll(6, 6);
1246: if (save(VS_WAND, th, 0))
1247: damage /= 2;
1248: runto(th, &hero);
1249: if ((th->t_stats.s_hpt -= damage) <= 0) {
1250: msg("The explosion kills %s",
1251: prname(monster_name(th), FALSE));
1252: killed(item, FALSE, FALSE, TRUE);
1253: }
1254: }
1255: }
1256: }
1257: }
1258: }
1259:
1260: /*
1261: * skirmish:
1262: * Called when one monster attacks another monster.
1263: */
1264:
1265: bool
1266: skirmish(struct thing *attacker, coord *mp, struct object *weap, bool thrown)
1267: {
1268: register struct thing *defender;
1269: register struct linked_list *item;
1270: register bool did_hit = TRUE, see_att, see_def;
1271: char attname[LINELEN+1], defname[LINELEN+1];
1272: struct object *wielded; /* The wielded weapon */
1273: struct linked_list *get_wield; /* Linked list header for wielded */
1274:
1275: /*
1276: * Find the monster we want to fight
1277: */
1278: if ((item = find_mons(mp->y, mp->x)) == NULL) {
1279: return(FALSE); /* must have killed him already */
1280: }
1281: defender = THINGPTR(item);
1282:
1283: /* Can the player see either of the fighters? */
1284: see_att = (cansee(unc(attacker->t_pos)) &&
1285: (off(*attacker, ISINVIS) || on(player, CANSEE)) &&
1286: (off(*attacker, ISSHADOW) || on(player, CANSEE)));
1287: see_def = (cansee(unc(defender->t_pos)) &&
1288: (off(*defender, ISINVIS) || on(player, CANSEE)) &&
1289: (off(*defender, ISSHADOW) || on(player, CANSEE)));
1290:
1291: /*
1292: * Since we are fighting, things are not quiet so no healing takes
1293: * place. The -1 also tells us that we are in a fight.
1294: */
1295: attacker->t_quiet = -1;
1296: defender->t_quiet = -1;
1297:
1298: if (see_att) strcpy(attname, monster_name(attacker));
1299: else strcpy(attname, "something");
1300:
1301: if (see_def) strcpy(defname, monster_name(defender));
1302: else strcpy(defname, "something");
1303:
1304: /*
1305: * if its in the wall, we can't hit it
1306: */
1307: if (on(*defender, ISINWALL) && off(*attacker, CANINWALL))
1308: return(FALSE);
1309:
1310: if (on(*defender, ISSTONE)) {
1311: killed(item, FALSE, FALSE, FALSE);
1312: if (see_def)
1313: msg("%s shatters into a million pieces!", prname(defname, TRUE));
1314: return (TRUE);
1315: }
1316:
1317: /*
1318: * Let him know it was really a mimic (if it was one).
1319: */
1320: if (see_def && on(*defender, ISDISGUISE) &&
1321: (defender->t_type != defender->t_disguise)) {
1322: msg("Wait! There's a %s!", defname);
1323: turn_off(*defender, ISDISGUISE);
1324: did_hit = thrown;
1325: }
1326:
1327: if (see_def && on(*defender, CANSURPRISE) && !ISWEARING(R_ALERT)) {
1328: msg("Wait! There's a %s!", defname);
1329: turn_off(*defender, CANSURPRISE);
1330: did_hit = thrown;
1331: }
1332:
1333: if (did_hit) {
1334:
1335: did_hit = FALSE;
1336:
1337: /*
1338: * Try to find a weapon to wield. Wield_weap will return a
1339: * projector if weapon is a projectile (eg. bow for arrow).
1340: * If weapon is NULL, it will try to find a suitable weapon.
1341: */
1342: get_wield = wield_weap(weap, attacker);
1343: if (get_wield) wielded = OBJPTR(get_wield);
1344: else wielded = NULL;
1345:
1346: #ifdef DOBLINK
1347: /*
1348: * For now Blink Dogs will not blink away from monsters. We
1349: * have to fix can_blink so it isn't dependant on the player
1350: * before we can add it.
1351: */
1352: if (!can_blink(defender) &&
1353: #endif
1354: if (((weap && weap->o_type == RELIC) ||
1355: ((off(*defender, MAGICHIT) ||
1356: attacker->t_stats.s_lvl > 4 ||
1357: (weap && (weap->o_hplus > 0 || weap->o_dplus > 0))) &&
1358: (off(*defender, BMAGICHIT) ||
1359: attacker->t_stats.s_lvl > 6 ||
1360: (weap && (weap->o_hplus > 1 || weap->o_dplus > 1))) &&
1361: (off(*defender, CMAGICHIT) ||
1362: attacker->t_stats.s_lvl > 8 ||
1363: (weap && (weap->o_hplus > 2 || weap->o_dplus > 2)))))
1364: && roll_em(attacker, defender, weap, thrown, wielded, FALSE))
1365: {
1366: did_hit = TRUE;
1367:
1368: /* Should we start to chase this creature? */
1369: if (attacker->t_index != defender->t_index &&
1370: (off(*defender, ISRUN) || rnd(100) < 50)) {
1371: /*
1372: * If we're intelligent enough to realize that this
1373: * is a friendly monster, we will attack the hero instead.
1374: */
1375: if (on(*attacker, ISFRIENDLY) &&
1376: roll(3,6) < defender->t_stats.s_intel) {
1377: runto(defender, &hero);
1378: debug("%s attacking %s's hero", defname, attname);
1379: }
1380:
1381: /* Otherwise, let's chase the monster */
1382: else {
1383: runto(defender, &attacker->t_pos);
1384: debug("%s now attacking %s", defname, attname);
1385: }
1386: }
1387: else if (off(*defender, ISRUN)) runto(defender, &hero);
1388:
1389: /* Let the defender know that the attacker has missiles! */
1390: if ((defender->t_dest == &attacker->t_pos) && thrown)
1391: defender->t_wasshot = TRUE;
1392:
1393: if (on(*defender, NOMETAL) && weap != NULL &&
1394: weap->o_type != RELIC && weap->o_flags & ISMETAL) {
1395: if (see_def && see_att)
1396: msg("The %s passes right through %s!",
1397: weaps[weap->o_which].w_name, prname(defname, FALSE));
1398: }
1399: else {
1400: hit(weap, see_att, see_def,
1401: attname, defname, FALSE, thrown, FALSE);
1402: }
1403:
1404: /* See if there are any special effects */
1405: if (effect(attacker, defender,
1406: weap, thrown, see_att, see_def) != 0) {
1407: killed(item, FALSE, FALSE, TRUE);
1408: if (see_def) msg("%s dies.", prname(defname, TRUE));
1409: else msg("You hear a blood-curdling scream.");
1410: }
1411:
1412: /*
1413: * Merchants just disappear if hit
1414: */
1415: else if (on(*defender, CANSELL)) {
1416: if (see_def)
1417: msg("%s disappears with his wares in a flash.",
1418: prname(defname, TRUE));
1419: killed(item, FALSE, FALSE, FALSE);
1420: }
1421:
1422: else if (defender->t_stats.s_hpt <= 0) {
1423: killed(item, FALSE, FALSE, TRUE);
1424: if (see_def) msg("%s dies.", prname(defname, TRUE));
1425: else msg("You hear a blood-curdling scream.");
1426: }
1427:
1428: else {
1429: /* Did we disrupt a spell? */
1430: /* Don't turn on WASDISRUPTED since player didn't do it */
1431: if (defender->t_action == A_SUMMON ||
1432: defender->t_action == A_MISSILE) {
1433: /* Just make the old fellow start over again */
1434: defender->t_action = A_NIL;
1435: defender->t_no_move = movement(defender);
1436: defender->t_using = NULL;
1437:
1438: if (see_def)
1439: msg("%s was disrupted.", prname(defname, TRUE));
1440: }
1441:
1442: #ifdef FLEEMONST
1443: /*
1444: * If the monster is fairly intelligent and about to die, it
1445: * may turn tail and run. WE STILL NEED TO FIGURE OUT HOW
1446: * WE WANT THIS TO WORK.
1447: */
1448: if ((tp->t_stats.s_hpt < max(10, tp->maxstats.s_hpt/10)) &&
1449: (rnd(25) < tp->t_stats.s_intel)) {
1450: turn_on(*tp, ISFLEE);
1451:
1452: /* If monster was suffocating, stop it */
1453: if (on(*tp, DIDSUFFOCATE)) {
1454: turn_off(*tp, DIDSUFFOCATE);
1455: extinguish(suffocate);
1456: }
1457:
1458: /* If monster held us, stop it */
1459: if (on(*tp, DIDHOLD) && (--hold_count == 0))
1460: turn_off(player, ISHELD);
1461: turn_off(*tp, DIDHOLD);
1462:
1463: /* It is okay to turn tail */
1464: tp->t_oldpos = tp->t_pos;
1465: }
1466: #endif
1467: }
1468: }
1469: else {
1470: /* If the thing was trying to surprise, no good */
1471: if (on(*attacker, CANSURPRISE)) {
1472: /* If we can't see it, it keeps surprise (from us) */
1473: if (see_att) turn_off(*attacker, CANSURPRISE);
1474: }
1475:
1476: miss(weap, see_att, see_def, attname, defname, thrown, FALSE);
1477: }
1478: }
1479: return did_hit;
1480: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fight.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue7