Fandom

Wikihack

Source:SLASH'EM 0.0.7E7F2/mcastu.c

2,034pages on
this wiki
Add New Page
Talk0

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.

Below is the full text to mcastu.c from the source code of SLASH'EM 0.0.7E7F2. To link to a particular line, write [[SLASH'EM 0.0.7E7F2/mcastu.c#line123]], for example.

The latest source code for vanilla NetHack is at Source code.


The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)mcastu.c	3.4	2003/01/08	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #include "hack.h"
6.    
7.    /* monster mage spells */
8.    #define MGC_PSI_BOLT	 0
9.    #define MGC_CURE_SELF	 1
10.   #define MGC_HASTE_SELF	 2
11.   #define MGC_STUN_YOU	 3
12.   #define MGC_DISAPPEAR	 4
13.   #define MGC_WEAKEN_YOU	 5
14.   #define MGC_DESTRY_ARMR	 6
15.   #define MGC_CURSE_ITEMS	 7
16.   #define MGC_AGGRAVATION	 8
17.   #define MGC_SUMMON_MONS	 9
18.   #define MGC_CLONE_WIZ	10
19.   #define MGC_DEATH_TOUCH	11
20.   #define MGC_CREATE_POOL	12
21.   #define MGC_CALL_UNDEAD	13
22.   
23.   /* monster cleric spells */
24.   #define CLC_OPEN_WOUNDS	 0
25.   #define CLC_CURE_SELF	 1
26.   #define CLC_CONFUSE_YOU	 2
27.   #define CLC_PARALYZE	 3
28.   #define CLC_BLIND_YOU	 4
29.   #define CLC_INSECTS	 5
30.   #define CLC_CURSE_ITEMS	 6
31.   #define CLC_LIGHTNING	 7
32.   #define CLC_FIRE_PILLAR	 8
33.   #define CLC_GEYSER	 9
34.   
35.   STATIC_DCL void FDECL(cursetxt,(struct monst *,BOOLEAN_P));
36.   STATIC_DCL int FDECL(choose_magic_spell, (int));
37.   STATIC_DCL int FDECL(choose_clerical_spell, (int));
38.   STATIC_DCL void FDECL(cast_wizard_spell,(struct monst *, int,int));
39.   STATIC_DCL void FDECL(cast_cleric_spell,(struct monst *, int,int));
40.   STATIC_DCL boolean FDECL(is_undirected_spell,(unsigned int,int));
41.   STATIC_DCL boolean FDECL(spell_would_be_useless,(struct monst *,unsigned int,int));
42.   
43.   #ifdef OVL0
44.   
45.   extern const char * const flash_types[];	/* from zap.c */
46.   
47.   /* feedback when frustrated monster couldn't cast a spell */
48.   STATIC_OVL
49.   void
50.   cursetxt(mtmp, undirected)
51.   struct monst *mtmp;
52.   boolean undirected;
53.   {
54.   	if (canseemon(mtmp) && couldsee(mtmp->mx, mtmp->my)) {
55.   	    const char *point_msg;  /* spellcasting monsters are impolite */
56.   
57.   	    if (undirected)
58.   		point_msg = "all around, then curses";
59.   	    else if ((Invis && !perceives(mtmp->data) &&
60.   			(mtmp->mux != u.ux || mtmp->muy != u.uy)) ||
61.   		    (youmonst.m_ap_type == M_AP_OBJECT &&
62.   			youmonst.mappearance == STRANGE_OBJECT) ||
63.   		    u.uundetected)
64.   		point_msg = "and curses in your general direction";
65.   	    else if (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy))
66.   		point_msg = "and curses at your displaced image";
67.   	    else
68.   		point_msg = "at you, then curses";
69.   
70.   	    pline("%s points %s.", Monnam(mtmp), point_msg);
71.   	} else if ((!(moves % 4) || !rn2(4))) {
72.   	    if (flags.soundok) Norep("You hear a mumbled curse.");
73.   	}
74.   }
75.   
76.   #endif /* OVL0 */
77.   #ifdef OVLB
78.   
79.   /* convert a level based random selection into a specific mage spell;
80.      inappropriate choices will be screened out by spell_would_be_useless() */
81.   STATIC_OVL int
82.   choose_magic_spell(spellval)
83.   int spellval;
84.   {
85.       switch (spellval) {
86.       case 22:
87.       case 21:
88.       case 20:
89.   	return MGC_DEATH_TOUCH;
90.       case 19:
91.       case 18:
92.   	return MGC_CLONE_WIZ;
93.       case 17:
94.       case 16:
95.       case 15:
96.   	return MGC_SUMMON_MONS;
97.       case 14:
98.       case 13:
99.   	return MGC_AGGRAVATION;
100.      case 12:
101.  	return MGC_CREATE_POOL;
102.      case 11:
103.      case 10:
104.  	return MGC_CURSE_ITEMS;
105.      case 9:
106.  	return MGC_CALL_UNDEAD;
107.      case 8:
108.  	return MGC_DESTRY_ARMR;
109.      case 7:
110.      case 6:
111.  	return MGC_WEAKEN_YOU;
112.      case 5:
113.      case 4:
114.  	return MGC_DISAPPEAR;
115.      case 3:
116.  	return MGC_STUN_YOU;
117.      case 2:
118.  	return MGC_HASTE_SELF;
119.      case 1:
120.  	return MGC_CURE_SELF;
121.      case 0:
122.      default:
123.  	return MGC_PSI_BOLT;
124.      }
125.  }
126.  
127.  /* convert a level based random selection into a specific cleric spell */
128.  STATIC_OVL int
129.  choose_clerical_spell(spellnum)
130.  int spellnum;
131.  {
132.      switch (spellnum) {
133.      case 13:
134.  	return CLC_GEYSER;
135.      case 12:
136.  	return CLC_FIRE_PILLAR;
137.      case 11:
138.  	return CLC_LIGHTNING;
139.      case 10:
140.      case 9:
141.  	return CLC_CURSE_ITEMS;
142.      case 8:
143.  	return CLC_INSECTS;
144.      case 7:
145.      case 6:
146.  	return CLC_BLIND_YOU;
147.      case 5:
148.      case 4:
149.  	return CLC_PARALYZE;
150.      case 3:
151.      case 2:
152.  	return CLC_CONFUSE_YOU;
153.      case 1:
154.  	return CLC_CURE_SELF;
155.      case 0:
156.      default:
157.  	return CLC_OPEN_WOUNDS;
158.      }
159.  }
160.  
161.  /* return values:
162.   * 1: successful spell
163.   * 0: unsuccessful spell
164.   */
165.  int
166.  castmu(mtmp, mattk, thinks_it_foundyou, foundyou)
167.  	register struct monst *mtmp;
168.  	register struct attack *mattk;
169.  	boolean thinks_it_foundyou;
170.  	boolean foundyou;
171.  {
172.  	int	dmg, ml = mtmp->m_lev;
173.  	int ret;
174.  	int spellnum = 0;
175.  	int spellev, chance, difficulty, splcaster, learning;
176.  
177.  	/* Three cases:
178.  	 * -- monster is attacking you.  Search for a useful spell.
179.  	 * -- monster thinks it's attacking you.  Search for a useful spell,
180.  	 *    without checking for undirected.  If the spell found is directed,
181.  	 *    it fails with cursetxt() and loss of mspec_used.
182.  	 * -- monster isn't trying to attack.  Select a spell once.  Don't keep
183.  	 *    searching; if that spell is not useful (or if it's directed),
184.  	 *    return and do something else. 
185.  	 * Since most spells are directed, this means that a monster that isn't
186.  	 * attacking casts spells only a small portion of the time that an
187.  	 * attacking monster does.
188.  	 */
189.  	if ((mattk->adtyp == AD_SPEL || mattk->adtyp == AD_CLRC) && ml) {
190.  	    int cnt = 40;
191.  
192.  	    do {
193.  		spellnum = rn2(ml);
194.  		/* Casting level is limited by available energy */
195.  		spellev = spellnum / 7 + 1;
196.  		if (spellev > 10) spellev = 10;
197.  		if (spellev * 5 > mtmp->m_en) {
198.  		    spellev = mtmp->m_en / 5;
199.  		    spellnum = (spellev - 1) * 7 + 1;
200.  		}
201.  		if (mattk->adtyp == AD_SPEL)
202.  		    spellnum = choose_magic_spell(spellnum);
203.  		else
204.  		    spellnum = choose_clerical_spell(spellnum);
205.  		/* not trying to attack?  don't allow directed spells */
206.  		if (!thinks_it_foundyou) {
207.  		    if (!is_undirected_spell(mattk->adtyp, spellnum) ||
208.  			spell_would_be_useless(mtmp, mattk->adtyp, spellnum)) {
209.  			if (foundyou)
210.  			    impossible("spellcasting monster found you and doesn't know it?");
211.  			return 0;
212.  		    }
213.  		    break;
214.  		}
215.  	    } while(--cnt > 0 &&
216.  		    spell_would_be_useless(mtmp, mattk->adtyp, spellnum));
217.  	    if (cnt == 0) return 0;
218.  	} else {
219.  	    /* Casting level is limited by available energy */
220.  	    spellev = ml / 7 + 1;
221.  	    if (spellev > 10) spellev = 10;
222.  	    if (spellev * 5 > mtmp->m_en) {
223.  		spellev = mtmp->m_en / 5;
224.  		ml = (spellev - 1) * 7 + 1;
225.  	    }
226.  	}
227.  
228.  	/* monster unable to cast spells? */
229.  	if (mtmp->mcan || mtmp->m_en < 5 || mtmp->mspec_used || !ml) {
230.  	    cursetxt(mtmp, is_undirected_spell(mattk->adtyp, spellnum));
231.  	    return(0);
232.  	}
233.  
234.  	if (mattk->adtyp == AD_SPEL || mattk->adtyp == AD_CLRC) {
235.  	    /*
236.  	     * Spell use (especially MGC) is more common in Slash'EM.
237.  	     * Still using mspec_used, just so monsters don't go bonkers.
238.  	     */
239.  #if 0
240.  	    mtmp->mspec_used = 10 - mtmp->m_lev;
241.  	    if (mtmp->mspec_used < 2) mtmp->mspec_used = 2;
242.  #endif
243.  	    mtmp->mspec_used = rn2(15) - mtmp->m_lev;
244.  	    if (mattk->adtyp == AD_SPEL)
245.  		mtmp->mspec_used = mtmp->mspec_used > 0 ? 2 : 0;
246.  	    else if (mtmp->mspec_used < 2) mtmp->mspec_used = 2;
247.  	}
248.  
249.  	/* monster can cast spells, but is casting a directed spell at the
250.  	   wrong place?  If so, give a message, and return.  Do this *after*
251.  	   penalizing mspec_used. */
252.  	if (!foundyou && thinks_it_foundyou &&
253.  		!is_undirected_spell(mattk->adtyp, spellnum)) {
254.  	    pline("%s casts a spell at %s!",
255.  		canseemon(mtmp) ? Monnam(mtmp) : "Something",
256.  		levl[mtmp->mux][mtmp->muy].typ == WATER
257.  		    ? "empty water" : "thin air");
258.  	    return(0);
259.  	}
260.  
261.  	nomul(0);
262.  
263.  	mtmp->m_en -= spellev * 5; /* Use up the energy now */
264.  
265.  	/* We should probably do similar checks to what is done for
266.  	 * the player - armor, etc.
267.  	 * Checks for armour and other intrinsic ability change splcaster
268.  	 * Difficulty and experience affect chance
269.  	 * Assume that monsters only cast spells that they know well
270.  	 */
271.  	splcaster = 15 - (mtmp->m_lev / 2); /* Base for a wizard is 5...*/
272.  
273.  	if (splcaster < 5) splcaster = 5;
274.  	if (splcaster > 20) splcaster = 20;
275.  
276.  	chance = 11 * (mtmp->m_lev > 25 ? 18 : (12 + (mtmp->m_lev / 5)));
277.  	chance++ ;  /* Minimum chance of 1 */
278.  
279.  	difficulty = (spellev - 1) * 4 - (mtmp->m_lev - 1);
280.  	    /* law of diminishing returns sets in quickly for
281.  	     * low-level spells.  That is, higher levels quickly
282.  	     * result in almost no gain
283.  	     */
284.  	learning = 15 * (-difficulty / spellev);
285.  	chance += learning > 20 ? 20 : learning;
286.  
287.  	/* clamp the chance */
288.  	if (chance < 0) chance = 0;
289.  	if (chance > 120) chance = 120;
290.  
291.  	/* combine */
292.  	chance = chance * (20-splcaster) / 15 - splcaster;
293.  
294.  	/* Clamp to percentile */
295.  	if (chance > 100) chance = 100;
296.  	if (chance < 0) chance = 0;
297.  
298.  #if 0
299.  	if(rn2(ml*10) < (mtmp->mconf ? 100 : 20)) {	/* fumbled attack */
300.  #else
301.  	if (mtmp->mconf || rnd(100) > chance) { /* fumbled attack */
302.  #endif
303.  	    if (canseemon(mtmp) && flags.soundok)
304.  		pline_The("air crackles around %s.", mon_nam(mtmp));
305.  	    return(0);
306.  	}
307.  	if (canspotmon(mtmp) || !is_undirected_spell(mattk->adtyp, spellnum)) {
308.  	    pline("%s casts a spell%s!",
309.  		  canspotmon(mtmp) ? Monnam(mtmp) : "Something",
310.  		  is_undirected_spell(mattk->adtyp, spellnum) ? "" :
311.  		  (Invisible && !perceives(mtmp->data) && 
312.  		   (mtmp->mux != u.ux || mtmp->muy != u.uy)) ?
313.  		  " at a spot near you" :
314.  		  (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy)) ?
315.  		  " at your displaced image" :
316.  		  " at you");
317.  	}
318.  
319.  /*
320.   *	As these are spells, the damage is related to the level
321.   *	of the monster casting the spell.
322.   */
323.  	if (!foundyou) {
324.  	    dmg = 0;
325.  	    if (mattk->adtyp != AD_SPEL && mattk->adtyp != AD_CLRC) {
326.  		impossible(
327.  	      "%s casting non-hand-to-hand version of hand-to-hand spell %d?",
328.  			   Monnam(mtmp), mattk->adtyp);
329.  		return(0);
330.  	    }
331.  	} else if (mattk->damd)
332.  	    dmg = d((int)((ml/2) + mattk->damn), (int)mattk->damd);
333.  	else dmg = d((int)((ml/2) + 1), 6);
334.  	if (Half_spell_damage) dmg = (dmg+1) / 2;
335.  
336.  	ret = 1;
337.  
338.  	switch (mattk->adtyp) {
339.  
340.  	    case AD_FIRE:
341.  		pline("You're enveloped in flames.");
342.  		if(Fire_resistance) {
343.  			shieldeff(u.ux, u.uy);
344.  			pline("But you resist the effects.");
345.  			dmg = 0;
346.  		}
347.  		if (Slimed) {
348.  			pline("The slime is burned away!");
349.  			Slimed =0;
350.  		}
351.  		burn_away_slime();
352.  		break;
353.  	    case AD_COLD:
354.  		pline("You're covered in frost.");
355.  		if(Cold_resistance) {
356.  			shieldeff(u.ux, u.uy);
357.  			pline("But you resist the effects.");
358.  			dmg = 0;
359.  		}
360.  		break;
361.  	    case AD_MAGM:
362.  		You("are hit by a shower of missiles!");
363.  		if(Antimagic) {
364.  			shieldeff(u.ux, u.uy);
365.  			pline_The("missiles bounce off!");
366.  			dmg = 0;
367.  		}
368.  		break;
369.  	    case AD_SPEL:	/* wizard spell */
370.  	    case AD_CLRC:       /* clerical spell */
371.  	    {
372.  		if (mattk->adtyp == AD_SPEL)
373.  		    cast_wizard_spell(mtmp, dmg, spellnum);
374.  		else
375.  		    cast_cleric_spell(mtmp, dmg, spellnum);
376.  		dmg = 0; /* done by the spell casting functions */
377.  		break;
378.  	    }
379.  	}
380.  	if(dmg) mdamageu(mtmp, dmg);
381.  	return(ret);
382.  }
383.  
384.  /* monster wizard and cleric spellcasting functions */
385.  /*
386.     If dmg is zero, then the monster is not casting at you.
387.     If the monster is intentionally not casting at you, we have previously
388.     called spell_would_be_useless() and spellnum should always be a valid
389.     undirected spell.
390.     If you modify either of these, be sure to change is_undirected_spell()
391.     and spell_would_be_useless().
392.   */
393.  STATIC_OVL
394.  void
395.  cast_wizard_spell(mtmp, dmg, spellnum)
396.  struct monst *mtmp;
397.  int dmg;
398.  int spellnum;
399.  {
400.      if (dmg == 0 && !is_undirected_spell(AD_SPEL, spellnum)) {
401.  	impossible("cast directed wizard spell (%d) with dmg=0?", spellnum);
402.  	return;
403.      }
404.  
405.      switch (spellnum) {
406.      case MGC_DEATH_TOUCH:
407.  	pline("Oh no, %s's using the touch of death!", mhe(mtmp));
408.  	if (nonliving(youmonst.data) || is_demon(youmonst.data)) {
409.  	    You("seem no deader than before.");
410.  	} else if (!Antimagic && rn2(mtmp->m_lev) > 12) {
411.  	    if (Hallucination) {
412.  		You("have an out of body experience.");
413.  	    } else {
414.  		killer_format = KILLED_BY_AN;
415.  		killer = "touch of death";
416.  		done(DIED);
417.  	    }
418.  	} else {
419.  	    if (Antimagic) shieldeff(u.ux, u.uy);
420.  	    pline("Lucky for you, it didn't work!");
421.  	}
422.  	dmg = 0;
423.  	break;
424.      case MGC_CREATE_POOL:
425.  	if (levl[u.ux][u.uy].typ == ROOM || levl[u.ux][u.uy].typ == CORR) {
426.  	    pline("A pool appears beneath you!");
427.  	    levl[u.ux][u.uy].typ = POOL;
428.  	    del_engr_at(u.ux, u.uy);
429.  	    water_damage(level.objects[u.ux][u.uy], FALSE, TRUE);
430.  	    spoteffects(FALSE);  /* possibly drown, notice objects */
431.  	}
432.  	else
433.  	    impossible("bad pool creation?");
434.  	dmg = 0;
435.  	break;
436.      case MGC_CLONE_WIZ:
437.  	if (mtmp->iswiz && flags.no_of_wizards == 1) {
438.  	    pline("Double Trouble...");
439.  	    clonewiz();
440.  	    dmg = 0;
441.  	} else
442.  	    impossible("bad wizard cloning?");
443.  	break;
444.      case MGC_SUMMON_MONS:
445.      {
446.  	int count;
447.  
448.  	count = nasty(mtmp);	/* summon something nasty */
449.  	if (mtmp->iswiz)
450.  	    verbalize("Destroy the thief, my pet%s!", plur(count));
451.  	else {
452.  	    const char *mappear =
453.  		(count == 1) ? "A monster appears" : "Monsters appear";
454.  
455.  	    /* messages not quite right if plural monsters created but
456.  	       only a single monster is seen */
457.  	    if (Invisible && !perceives(mtmp->data) &&
458.  				    (mtmp->mux != u.ux || mtmp->muy != u.uy))
459.  		pline("%s around a spot near you!", mappear);
460.  	    else if (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy))
461.  		pline("%s around your displaced image!", mappear);
462.  	    else
463.  		pline("%s from nowhere!", mappear);
464.  	}
465.  	dmg = 0;
466.  	break;
467.      }
468.  	case MGC_CALL_UNDEAD:
469.  	{
470.  		coord mm;   
471.  		mm.x = u.ux;   
472.  		mm.y = u.uy;   
473.  		pline("Undead creatures are called forth from the grave!");   
474.  		mkundead(&mm, FALSE, NO_MINVENT);   
475.  	}
476.  	dmg = 0;   
477.  	break;   
478.      case MGC_AGGRAVATION:
479.  	You_feel("that monsters are aware of your presence.");
480.  	aggravate();
481.  	dmg = 0;
482.  	break;
483.      case MGC_CURSE_ITEMS:
484.  	You_feel("as if you need some help.");
485.  	rndcurse();
486.  	dmg = 0;
487.  	break;
488.      case MGC_DESTRY_ARMR:
489.  	if (Antimagic) {
490.  	    shieldeff(u.ux, u.uy);
491.  	    pline("A field of force surrounds you!");
492.  	} else if (!destroy_arm(some_armor(&youmonst))) {
493.  	    Your("skin itches.");
494.  	}
495.  	dmg = 0;
496.  	break;
497.      case MGC_WEAKEN_YOU:		/* drain strength */
498.  	if (Antimagic) {
499.  	    shieldeff(u.ux, u.uy);
500.  	    You_feel("momentarily weakened.");
501.  	} else {
502.  	    You("suddenly feel weaker!");
503.  	    dmg = mtmp->m_lev - 6;
504.  	    if (Half_spell_damage) dmg = (dmg + 1) / 2;
505.  	    losestr(rnd(dmg));
506.  	    if (u.uhp < 1)
507.  		done_in_by(mtmp);
508.  	}
509.  	dmg = 0;
510.  	break;
511.      case MGC_DISAPPEAR:		/* makes self invisible */
512.  	if (!mtmp->minvis && !mtmp->invis_blkd) {
513.  	    if (canseemon(mtmp))
514.  		pline("%s suddenly %s!", Monnam(mtmp),
515.  		      !See_invisible ? "disappears" : "becomes transparent");
516.  	    mon_set_minvis(mtmp);
517.  	    dmg = 0;
518.  	} else
519.  	    impossible("no reason for monster to cast disappear spell?");
520.  	break;
521.      case MGC_STUN_YOU:
522.  	if (Antimagic || Free_action) {
523.  	    shieldeff(u.ux, u.uy);
524.  	    if (!Stunned)
525.  		You_feel("momentarily disoriented.");
526.  	    make_stunned(1L, FALSE);
527.  	} else {
528.  	    You(Stunned ? "struggle to keep your balance." : "reel...");
529.  	    dmg = d(ACURR(A_DEX) < 12 ? 6 : 4, 4);
530.  	    if (Half_spell_damage) dmg = (dmg + 1) / 2;
531.  	    make_stunned(HStun + dmg, FALSE);
532.  	}
533.  	dmg = 0;
534.  	break;
535.      case MGC_HASTE_SELF:
536.  	mon_adjust_speed(mtmp, 1, (struct obj *)0);
537.  	dmg = 0;
538.  	break;
539.      case MGC_CURE_SELF:
540.  	if (mtmp->mhp < mtmp->mhpmax) {
541.  	    if (canseemon(mtmp))
542.  		pline("%s looks better.", Monnam(mtmp));
543.  	    /* note: player healing does 6d4; this used to do 1d8 */
544.  	    if ((mtmp->mhp += d(3,6)) > mtmp->mhpmax)
545.  		mtmp->mhp = mtmp->mhpmax;
546.  	    dmg = 0;
547.  	}
548.  	break;
549.      case MGC_PSI_BOLT:
550.  	/* prior to 3.4.0 Antimagic was setting the damage to 1--this
551.  	   made the spell virtually harmless to players with magic res. */
552.  	if (Antimagic) {
553.  	    shieldeff(u.ux, u.uy);
554.  	    dmg = (dmg + 1) / 2;
555.  	}
556.  	if (dmg <= 5)
557.  	    You("get a slight %sache.", body_part(HEAD));
558.  	else if (dmg <= 10)
559.  	    Your("brain is on fire!");
560.  	else if (dmg <= 20)
561.  	    Your("%s suddenly aches painfully!", body_part(HEAD));
562.  	else
563.  	    Your("%s suddenly aches very painfully!", body_part(HEAD));
564.  	break;
565.      default:
566.  	impossible("mcastu: invalid magic spell (%d)", spellnum);
567.  	dmg = 0;
568.  	break;
569.      }
570.  
571.      if (dmg) mdamageu(mtmp, dmg);
572.  }
573.  
574.  STATIC_OVL
575.  void
576.  cast_cleric_spell(mtmp, dmg, spellnum)
577.  struct monst *mtmp;
578.  int dmg;
579.  int spellnum;
580.  {
581.      if (dmg == 0 && !is_undirected_spell(AD_CLRC, spellnum)) {
582.  	impossible("cast directed cleric spell (%d) with dmg=0?", spellnum);
583.  	return;
584.      }
585.  
586.      switch (spellnum) {
587.      case CLC_GEYSER:
588.  	/* this is physical damage, not magical damage */
589.  	pline("A sudden geyser slams into you from nowhere!");
590.  	dmg = d(8, 6);
591.  	if (Half_physical_damage) dmg = (dmg + 1) / 2;
592.  	break;
593.      case CLC_FIRE_PILLAR:
594.  	pline("A pillar of fire strikes all around you!");
595.  	if (Fire_resistance) {
596.  	    shieldeff(u.ux, u.uy);
597.  	    dmg = 0;
598.  	} else
599.  	    dmg = d(8, 6);
600.  	if (Half_spell_damage) dmg = (dmg + 1) / 2;
601.  	burn_away_slime();
602.  	(void) burnarmor(&youmonst);
603.  	destroy_item(SCROLL_CLASS, AD_FIRE);
604.  	destroy_item(POTION_CLASS, AD_FIRE);
605.  	destroy_item(SPBOOK_CLASS, AD_FIRE);
606.  	(void) burn_floor_paper(u.ux, u.uy, TRUE, FALSE);
607.  	break;
608.      case CLC_LIGHTNING:
609.      {
610.  	boolean reflects;
611.  
612.  	/* WAC add lightning strike effect */
613.  	zap_strike_fx(u.ux, u.uy, AD_ELEC - 1);
614.  	pline("A bolt of lightning strikes down at you from above!");
615.  	reflects = ureflects("It bounces off your %s%s.", "");
616.  	if (!Blind) {
617.  	    pline("You are blinded by the flash!");
618.  	    make_blinded(Half_spell_damage ? 10L : 20L, FALSE);
619.  	}
620.  	if (reflects || Shock_resistance) {
621.  	    shieldeff(u.ux, u.uy);
622.  	    dmg = 0;
623.  	    if (reflects)
624.  		break;
625.  	} else
626.  	    dmg = d(8, 6);
627.  	if (Half_spell_damage) dmg = (dmg + 1) / 2;
628.  	destroy_item(WAND_CLASS, AD_ELEC);
629.  	destroy_item(RING_CLASS, AD_ELEC);
630.  	break;
631.      }
632.      case CLC_CURSE_ITEMS:
633.  	You_feel("as if you need some help.");
634.  	rndcurse();
635.  	dmg = 0;
636.  	break;
637.      case CLC_INSECTS:
638.        {
639.  	/* Try for insects, and if there are none
640.  	   left, go for (sticks to) snakes.  -3. */
641.  	struct permonst *pm = mkclass(S_ANT,0);
642.  	struct monst *mtmp2 = (struct monst *)0;
643.  	char let = (pm ? S_ANT : S_SNAKE);
644.  	boolean success;
645.  	int i;
646.  	coord bypos;
647.  	int quan;
648.  
649.  	quan = (mtmp->m_lev < 2) ? 1 : rnd((int)mtmp->m_lev / 2);
650.  	if (quan < 3) quan = 3;
651.  	success = pm ? TRUE : FALSE;
652.  	for (i = 0; i <= quan; i++) {
653.  	    if (!enexto(&bypos, mtmp->mux, mtmp->muy, mtmp->data))
654.  		break;
655.  	    if ((pm = mkclass(let,0)) != 0 &&
656.  		    (mtmp2 = makemon(pm, bypos.x, bypos.y, NO_MM_FLAGS)) != 0) {
657.  		success = TRUE;
658.  		mtmp2->msleeping = mtmp2->mpeaceful = mtmp2->mtame = 0;
659.  		set_malign(mtmp2);
660.  	    }
661.  	}
662.  	/* Not quite right:
663.           * -- message doesn't always make sense for unseen caster (particularly
664.  	 *    the first message)
665.           * -- message assumes plural monsters summoned (non-plural should be
666.           *    very rare, unlike in nasty())
667.           * -- message assumes plural monsters seen
668.           */
669.  	if (!success)
670.  	    pline("%s casts at a clump of sticks, but nothing happens.",
671.  		Monnam(mtmp));
672.  	else if (let == S_SNAKE)
673.  	    pline("%s transforms a clump of sticks into snakes!",
674.  		Monnam(mtmp));
675.  	else if (Invisible && !perceives(mtmp->data) &&
676.  				(mtmp->mux != u.ux || mtmp->muy != u.uy))
677.  	    pline("%s summons insects around a spot near you!",
678.  		Monnam(mtmp));
679.  	else if (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy))
680.  	    pline("%s summons insects around your displaced image!",
681.  		Monnam(mtmp));
682.  	else
683.  	    pline("%s summons insects!", Monnam(mtmp));
684.  	dmg = 0;
685.  	break;
686.        }
687.      case CLC_BLIND_YOU:
688.  	/* note: resists_blnd() doesn't apply here */
689.  	if (!Blinded) {
690.  	    int num_eyes = eyecount(youmonst.data);
691.  	    pline("Scales cover your %s!",
692.  		  (num_eyes == 1) ?
693.  		  body_part(EYE) : makeplural(body_part(EYE)));
694.  	    make_blinded(Half_spell_damage ? 100L : 200L, FALSE);
695.  	    if (!Blind) Your(vision_clears);
696.  	    dmg = 0;
697.  	} else
698.  	    impossible("no reason for monster to cast blindness spell?");
699.  	break;
700.      case CLC_PARALYZE:
701.  	if (Antimagic || Free_action) {
702.  	    shieldeff(u.ux, u.uy);
703.  	    if (multi >= 0)
704.  		You("stiffen briefly.");
705.  	    nomul(-1);
706.  	} else {
707.  	    if (multi >= 0)
708.  		You("are frozen in place!");
709.  	    dmg = 4 + (int)mtmp->m_lev;
710.  	    if (Half_spell_damage) dmg = (dmg + 1) / 2;
711.  	    nomul(-dmg);
712.  	}
713.  	nomovemsg = 0;
714.  	dmg = 0;
715.  	break;
716.      case CLC_CONFUSE_YOU:
717.  	if (Antimagic) {
718.  	    shieldeff(u.ux, u.uy);
719.  	    You_feel("momentarily dizzy.");
720.  	} else {
721.  	    boolean oldprop = !!Confusion;
722.  
723.  	    dmg = (int)mtmp->m_lev;
724.  	    if (Half_spell_damage) dmg = (dmg + 1) / 2;
725.  	    make_confused(HConfusion + dmg, TRUE);
726.  	    if (Hallucination)
727.  		You_feel("%s!", oldprop ? "trippier" : "trippy");
728.  	    else
729.  		You_feel("%sconfused!", oldprop ? "more " : "");
730.  	}
731.  	dmg = 0;
732.  	break;
733.      case CLC_CURE_SELF:
734.  	if (mtmp->mhp < mtmp->mhpmax) {
735.  	    if (canseemon(mtmp))
736.  		pline("%s looks better.", Monnam(mtmp));
737.  	    /* note: player healing does 6d4; this used to do 1d8 */
738.  	    if ((mtmp->mhp += d(3,6)) > mtmp->mhpmax)
739.  		mtmp->mhp = mtmp->mhpmax;
740.  	    dmg = 0;
741.  	}
742.  	break;
743.      case CLC_OPEN_WOUNDS:
744.  	if (Antimagic) {
745.  	    shieldeff(u.ux, u.uy);
746.  	    dmg = (dmg + 1) / 2;
747.  	}
748.  	if (dmg <= 5)
749.  	    Your("skin itches badly for a moment.");
750.  	else if (dmg <= 10)
751.  	    pline("Wounds appear on your body!");
752.  	else if (dmg <= 20)
753.  	    pline("Severe wounds appear on your body!");
754.  	else
755.  	    Your("body is covered with painful wounds!");
756.  	break;
757.      default:
758.  	impossible("mcastu: invalid clerical spell (%d)", spellnum);
759.  	dmg = 0;
760.  	break;
761.      }
762.  
763.      if (dmg) mdamageu(mtmp, dmg);
764.  }
765.  
766.  STATIC_DCL
767.  boolean
768.  is_undirected_spell(adtyp, spellnum)
769.  unsigned int adtyp;
770.  int spellnum;
771.  {
772.      if (adtyp == AD_SPEL) {
773.  	switch (spellnum) {
774.  	case MGC_CLONE_WIZ:
775.  	case MGC_SUMMON_MONS:
776.  	case MGC_AGGRAVATION:
777.  	case MGC_DISAPPEAR:
778.  	case MGC_HASTE_SELF:
779.  	case MGC_CURE_SELF:
780.  	case MGC_CALL_UNDEAD:
781.  	    return TRUE;
782.  	default:
783.  	    break;
784.  	}
785.      } else if (adtyp == AD_CLRC) {
786.  	switch (spellnum) {
787.  	case CLC_INSECTS:
788.  	case CLC_CURE_SELF:
789.  	    return TRUE;
790.  	default:
791.  	    break;
792.  	}
793.      }
794.      return FALSE;
795.  }
796.  
797.  /* Some spells are useless under some circumstances. */
798.  STATIC_DCL
799.  boolean
800.  spell_would_be_useless(mtmp, adtyp, spellnum)
801.  struct monst *mtmp;
802.  unsigned int adtyp;
803.  int spellnum;
804.  {
805.      /* Some spells don't require the player to really be there and can be cast
806.       * by the monster when you're invisible, yet still shouldn't be cast when
807.       * the monster doesn't even think you're there.
808.       * This check isn't quite right because it always uses your real position.
809.       * We really want something like "if the monster could see mux, muy".
810.       */
811.      boolean mcouldseeu = couldsee(mtmp->mx, mtmp->my);
812.  
813.      if (adtyp == AD_SPEL) {
814.  	/* aggravate monsters, etc. won't be cast by peaceful monsters */
815.  	if (mtmp->mpeaceful && (spellnum == MGC_AGGRAVATION ||
816.                 spellnum == MGC_SUMMON_MONS || spellnum == MGC_CLONE_WIZ ||
817.                 spellnum == MGC_CALL_UNDEAD))
818.  	    return TRUE;
819.  	/* haste self when already fast */
820.  	if (mtmp->permspeed == MFAST && spellnum == MGC_HASTE_SELF)
821.  	    return TRUE;
822.  	/* invisibility when already invisible */
823.  	if ((mtmp->minvis || mtmp->invis_blkd) && spellnum == MGC_DISAPPEAR)
824.  	    return TRUE;
825.  	/* peaceful monster won't cast invisibility if you can't see invisible,
826.  	   same as when monsters drink potions of invisibility.  This doesn't
827.  	   really make a lot of sense, but lets the player avoid hitting
828.  	   peaceful monsters by mistake */
829.  	if (mtmp->mpeaceful && !See_invisible && spellnum == MGC_DISAPPEAR)
830.  	    return TRUE;
831.  	/* healing when already healed */
832.  	if (mtmp->mhp == mtmp->mhpmax && spellnum == MGC_CURE_SELF)
833.  	    return TRUE;
834.  	/* don't summon monsters if it doesn't think you're around */
835.  	if (!mcouldseeu && (spellnum == MGC_SUMMON_MONS ||
836.  		spellnum == MGC_CALL_UNDEAD ||
837.  		(!mtmp->iswiz && spellnum == MGC_CLONE_WIZ)))
838.  	    return TRUE;
839.  	/* only lichs can cast call undead */
840.  	if (mtmp->data->mlet != S_LICH && spellnum == MGC_CALL_UNDEAD)
841.  	    return TRUE;
842.  	/* pools can only be created in certain locations and then only
843.  	 * rarely unless you're carrying the amulet.
844.  	 */
845.  	if ((levl[u.ux][u.uy].typ != ROOM && levl[u.ux][u.uy].typ != CORR
846.  		|| !u.uhave.amulet && rn2(10)) && spellnum == MGC_CREATE_POOL)
847.  	    return TRUE;
848.  	if ((!mtmp->iswiz || flags.no_of_wizards > 1)
849.  						&& spellnum == MGC_CLONE_WIZ)
850.  	    return TRUE;
851.      } else if (adtyp == AD_CLRC) {
852.  	/* summon insects/sticks to snakes won't be cast by peaceful monsters */
853.  	if (mtmp->mpeaceful && spellnum == CLC_INSECTS)
854.  	    return TRUE;
855.  	/* healing when already healed */
856.  	if (mtmp->mhp == mtmp->mhpmax && spellnum == CLC_CURE_SELF)
857.  	    return TRUE;
858.  	/* don't summon insects if it doesn't think you're around */
859.  	if (!mcouldseeu && spellnum == CLC_INSECTS)
860.  	    return TRUE;
861.  	/* blindness spell on blinded player */
862.  	if (Blinded && spellnum == CLC_BLIND_YOU)
863.  	    return TRUE;
864.      }
865.      return FALSE;
866.  }
867.  
868.  #endif /* OVLB */
869.  #ifdef OVL0
870.  
871.  /* convert 1..10 to 0..9; add 10 for second group (spell casting) */
872.  #define ad_to_typ(k) (10 + (int)k - 1)
873.  
874.  int
875.  buzzmu(mtmp, mattk)		/* monster uses spell (ranged) */
876.  	register struct monst *mtmp;
877.  	register struct attack  *mattk;
878.  {
879.  	/* don't print constant stream of curse messages for 'normal'
880.  	   spellcasting monsters at range */
881.  	if (mattk->adtyp > AD_SPC2)
882.  	    return(0);
883.  
884.  	if (mtmp->mcan) {
885.  	    cursetxt(mtmp, FALSE);
886.  	    return(0);
887.  	}
888.  	if(lined_up(mtmp) && rn2(3)) {
889.  	    nomul(0);
890.  	    if(mattk->adtyp && (mattk->adtyp < 11)) { /* no cf unsigned >0 */
891.  		if(canseemon(mtmp))
892.  		    pline("%s zaps you with a %s!", Monnam(mtmp),
893.  			  flash_types[ad_to_typ(mattk->adtyp)]);
894.  		buzz(-ad_to_typ(mattk->adtyp), (int)mattk->damn,
895.  		     mtmp->mx, mtmp->my, sgn(tbx), sgn(tby));
896.  	    } else impossible("Monster spell %d cast", mattk->adtyp-1);
897.  	}
898.  	return(1);
899.  }
900.  
901.  #endif /* OVL0 */
902.  
903.  /*mcastu.c*/

Also on Fandom

Random Wiki