Wikia

Wikihack

Source:Explode.c

2,032pages on
this wiki
Talk0

Below is the full text to src/explode.c from NetHack 3.4.3. To link to a particular line, write [[explode.c#line123]], for example.

Top of file Edit

1.    /*	SCCS Id: @(#)explode.c	3.4	2002/11/10	*/
2.    /*	Copyright (C) 1990 by Ken Arromdee */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
The NetHack General Public License applies to screenshots, source code and other content from NetHack.
5.    #include "hack.h"
6.    
7.    #ifdef OVL0
8.    
9.    /* Note: Arrays are column first, while the screen is row first */
10.   static int expl[3][3] = {
11.   	{ S_explode1, S_explode4, S_explode7 },
12.   	{ S_explode2, S_explode5, S_explode8 },
13.   	{ S_explode3, S_explode6, S_explode9 }
14.   };
15.   

explode Edit

16.   /* Note: I had to choose one of three possible kinds of "type" when writing
17.    * this function: a wand type (like in zap.c), an adtyp, or an object type.
18.    * Wand types get complex because they must be converted to adtyps for
19.    * determining such things as fire resistance.  Adtyps get complex in that
20.    * they don't supply enough information--was it a player or a monster that
21.    * did it, and with a wand, spell, or breath weapon?  Object types share both
22.    * these disadvantages....
23.    */
24.   void
25.   explode(x, y, type, dam, olet, expltype)
26.   int x, y;
27.   int type; /* the same as in zap.c */
28.   int dam;
29.   char olet;
30.   int expltype;
31.   {
32.   	int i, j, k, damu = dam;
33.   	boolean starting = 1;
34.   	boolean visible, any_shield;
35.   	int uhurt = 0; /* 0=unhurt, 1=items damaged, 2=you and items damaged */
36.   	const char *str;
37.   	int idamres, idamnonres;
38.   	struct monst *mtmp;
39.   	uchar adtyp;
40.   	int explmask[3][3];
41.   		/* 0=normal explosion, 1=do shieldeff, 2=do nothing */
42.   	boolean shopdamage = FALSE;
43.   	boolean generic = FALSE;
44.   
45.   	if (olet == WAND_CLASS)		/* retributive strike */
46.   		switch (Role_switch) {
47.   			case PM_PRIEST:
48.   			case PM_MONK:
49.   			case PM_WIZARD: damu /= 5;
50.   				  break;
51.   			case PM_HEALER:
52.   			case PM_KNIGHT: damu /= 2;
53.   				  break;
54.   			default:  break;
55.   		}
56.   
57.   	if (olet == MON_EXPLODE) {
58.   	    str = killer;
59.   	    killer = 0;		/* set again later as needed */
60.   	    adtyp = AD_PHYS;
61.   	} else
62.   	switch (abs(type) % 10) {
63.   		case 0: str = "magical blast";
64.   			adtyp = AD_MAGM;
65.   			break;
66.   		case 1: str =   olet == BURNING_OIL ?	"burning oil" :
67.   				olet == SCROLL_CLASS ?	"tower of flame" :
68.   							"fireball";
69.   			adtyp = AD_FIRE;
70.   			break;
71.   		case 2: str = "ball of cold";
72.   			adtyp = AD_COLD;
73.   			break;
74.   		case 4: str =  (olet == WAND_CLASS) ? "death field" :
75.   							"disintegration field";
76.   			adtyp = AD_DISN;
77.   			break;
78.   		case 5: str = "ball of lightning";
79.   			adtyp = AD_ELEC;
80.   			break;
81.   		case 6: str = "poison gas cloud";
82.   			adtyp = AD_DRST;
83.   			break;
84.   		case 7: str = "splash of acid";
85.   			adtyp = AD_ACID;
86.   			break;
87.   		default: impossible("explosion base type %d?", type); return;
88.   	}
89.   
90.   	any_shield = visible = FALSE;
91.   	for (i=0; i<3; i++) for (j=0; j<3; j++) {
92.   		if (!isok(i+x-1, j+y-1)) {
93.   			explmask[i][j] = 2;
94.   			continue;
95.   		} else
96.   			explmask[i][j] = 0;
97.   
98.   		if (i+x-1 == u.ux && j+y-1 == u.uy) {
99.   		    switch(adtyp) {
100.  			case AD_PHYS:                        
101.  				explmask[i][j] = 0;
102.  				break;
103.  			case AD_MAGM:
104.  				explmask[i][j] = !!Antimagic;
105.  				break;
106.  			case AD_FIRE:
107.  				explmask[i][j] = !!Fire_resistance;
108.  				break;
109.  			case AD_COLD:
110.  				explmask[i][j] = !!Cold_resistance;
111.  				break;
112.  			case AD_DISN:
113.  				explmask[i][j] = (olet == WAND_CLASS) ?
114.  						!!(nonliving(youmonst.data) || is_demon(youmonst.data)) :
115.  						!!Disint_resistance;
116.  				break;
117.  			case AD_ELEC:
118.  				explmask[i][j] = !!Shock_resistance;
119.  				break;
120.  			case AD_DRST:
121.  				explmask[i][j] = !!Poison_resistance;
122.  				break;
123.  			case AD_ACID:
124.  				explmask[i][j] = !!Acid_resistance;
125.  				break;
126.  			default:
127.  				impossible("explosion type %d?", adtyp);
128.  				break;
129.  		    }
130.  		}
131.  		/* can be both you and mtmp if you're swallowed */
132.  		mtmp = m_at(i+x-1, j+y-1);
133.  #ifdef STEED
134.  		if (!mtmp && i+x-1 == u.ux && j+y-1 == u.uy)
135.  			mtmp = u.usteed;
136.  #endif
137.  		if (mtmp) {
138.  		    if (mtmp->mhp < 1) explmask[i][j] = 2;
139.  		    else switch(adtyp) {
140.  			case AD_PHYS:                        
141.  				break;
142.  			case AD_MAGM:
143.  				explmask[i][j] |= resists_magm(mtmp);
144.  				break;
145.  			case AD_FIRE:
146.  				explmask[i][j] |= resists_fire(mtmp);
147.  				break;
148.  			case AD_COLD:
149.  				explmask[i][j] |= resists_cold(mtmp);
150.  				break;
151.  			case AD_DISN:
152.  				explmask[i][j] |= (olet == WAND_CLASS) ?
153.  					(nonliving(mtmp->data) || is_demon(mtmp->data)) :
154.  					resists_disint(mtmp);
155.  				break;
156.  			case AD_ELEC:
157.  				explmask[i][j] |= resists_elec(mtmp);
158.  				break;
159.  			case AD_DRST:
160.  				explmask[i][j] |= resists_poison(mtmp);
161.  				break;
162.  			case AD_ACID:
163.  				explmask[i][j] |= resists_acid(mtmp);
164.  				break;
165.  			default:
166.  				impossible("explosion type %d?", adtyp);
167.  				break;
168.  		    }
169.  		}
170.  		if (mtmp && cansee(i+x-1,j+y-1) && !canspotmon(mtmp))
171.  		    map_invisible(i+x-1, j+y-1);
172.  		else if (!mtmp && glyph_is_invisible(levl[i+x-1][j+y-1].glyph)) {
173.  		    unmap_object(i+x-1, j+y-1);
174.  		    newsym(i+x-1, j+y-1);
175.  		}
176.  		if (cansee(i+x-1, j+y-1)) visible = TRUE;
177.  		if (explmask[i][j] == 1) any_shield = TRUE;
178.  	}
179.  
180.  	if (visible) {
181.  		/* Start the explosion */
182.  		for (i=0; i<3; i++) for (j=0; j<3; j++) {
183.  			if (explmask[i][j] == 2) continue;
184.  			tmp_at(starting ? DISP_BEAM : DISP_CHANGE,
185.  				explosion_to_glyph(expltype,expl[i][j]));
186.  			tmp_at(i+x-1, j+y-1);
187.  			starting = 0;
188.  		}
189.  		curs_on_u();	/* will flush screen and output */
190.  
191.  		if (any_shield && flags.sparkle) { /* simulate shield effect */
192.  		    for (k = 0; k < SHIELD_COUNT; k++) {
193.  			for (i=0; i<3; i++) for (j=0; j<3; j++) {
194.  			    if (explmask[i][j] == 1)
195.  				/*
196.  				 * Bypass tmp_at() and send the shield glyphs
197.  				 * directly to the buffered screen.  tmp_at()
198.  				 * will clean up the location for us later.
199.  				 */
200.  				show_glyph(i+x-1, j+y-1,
201.  					cmap_to_glyph(shield_static[k]));
202.  			}
203.  			curs_on_u();	/* will flush screen and output */
204.  			delay_output();
205.  		    }
206.  
207.  		    /* Cover last shield glyph with blast symbol. */
208.  		    for (i=0; i<3; i++) for (j=0; j<3; j++) {
209.  			if (explmask[i][j] == 1)
210.  			    show_glyph(i+x-1,j+y-1,
211.  					explosion_to_glyph(expltype, expl[i][j]));
212.  		    }
213.  
214.  		} else {		/* delay a little bit. */
215.  		    delay_output();
216.  		    delay_output();
217.  		}
218.  
219.  		tmp_at(DISP_END, 0); /* clear the explosion */
220.  	} else {
221.  	    if (olet == MON_EXPLODE) {
222.  		str = "explosion";
223.  		generic = TRUE;
224.  	    }
225.  	    if (flags.soundok) You_hear("a blast.");
226.  	}
227.  
228.      if (dam)
229.  	for (i=0; i<3; i++) for (j=0; j<3; j++) {
230.  		if (explmask[i][j] == 2) continue;
231.  		if (i+x-1 == u.ux && j+y-1 == u.uy)
232.  			uhurt = (explmask[i][j] == 1) ? 1 : 2;
233.  		idamres = idamnonres = 0;
234.  		if (type >= 0)
235.  		    (void)zap_over_floor((xchar)(i+x-1), (xchar)(j+y-1),
236.  		    		type, &shopdamage);
237.  
238.  		mtmp = m_at(i+x-1, j+y-1);
239.  #ifdef STEED
240.  		if (!mtmp && i+x-1 == u.ux && j+y-1 == u.uy)
241.  			mtmp = u.usteed;
242.  #endif
243.  		if (!mtmp) continue;
244.  		if (u.uswallow && mtmp == u.ustuck) {
245.  			if (is_animal(u.ustuck->data))
246.  				pline("%s gets %s!",
247.  				      Monnam(u.ustuck),
248.  				      (adtyp == AD_FIRE) ? "heartburn" :
249.  				      (adtyp == AD_COLD) ? "chilly" :
250.  				      (adtyp == AD_DISN) ? ((olet == WAND_CLASS) ?
251.  				       "irradiated by pure energy" : "perforated") :
252.  				      (adtyp == AD_ELEC) ? "shocked" :
253.  				      (adtyp == AD_DRST) ? "poisoned" :
254.  				      (adtyp == AD_ACID) ? "an upset stomach" :
255.  				       "fried");
256.  			else
257.  				pline("%s gets slightly %s!",
258.  				      Monnam(u.ustuck),
259.  				      (adtyp == AD_FIRE) ? "toasted" :
260.  				      (adtyp == AD_COLD) ? "chilly" :
261.  				      (adtyp == AD_DISN) ? ((olet == WAND_CLASS) ?
262.  				       "overwhelmed by pure energy" : "perforated") :
263.  				      (adtyp == AD_ELEC) ? "shocked" :
264.  				      (adtyp == AD_DRST) ? "intoxicated" :
265.  				      (adtyp == AD_ACID) ? "burned" :
266.  				       "fried");
267.  		} else if (cansee(i+x-1, j+y-1)) {
268.  		    if(mtmp->m_ap_type) seemimic(mtmp);
269.  		    pline("%s is caught in the %s!", Monnam(mtmp), str);
270.  		}
271.  
272.  		idamres += destroy_mitem(mtmp, SCROLL_CLASS, (int) adtyp);
273.  		idamres += destroy_mitem(mtmp, SPBOOK_CLASS, (int) adtyp);
274.  		idamnonres += destroy_mitem(mtmp, POTION_CLASS, (int) adtyp);
275.  		idamnonres += destroy_mitem(mtmp, WAND_CLASS, (int) adtyp);
276.  		idamnonres += destroy_mitem(mtmp, RING_CLASS, (int) adtyp);
277.  
278.  		if (explmask[i][j] == 1) {
279.  			golemeffects(mtmp, (int) adtyp, dam + idamres);
280.  			mtmp->mhp -= idamnonres;
281.  		} else {
282.  		/* call resist with 0 and do damage manually so 1) we can
283.  		 * get out the message before doing the damage, and 2) we can
284.  		 * call mondied, not killed, if it's not your blast
285.  		 */
286.  			int mdam = dam;
287.  
288.  			if (resist(mtmp, olet, 0, FALSE)) {
289.  			    if (cansee(i+x-1,j+y-1))
290.  				pline("%s resists the %s!", Monnam(mtmp), str);
291.  			    mdam = dam/2;
292.  			}
293.  			if (mtmp == u.ustuck)
294.  				mdam *= 2;
295.  			if (resists_cold(mtmp) && adtyp == AD_FIRE)
296.  				mdam *= 2;
297.  			else if (resists_fire(mtmp) && adtyp == AD_COLD)
298.  				mdam *= 2;
299.  			mtmp->mhp -= mdam;
300.  			mtmp->mhp -= (idamres + idamnonres);
301.  		}
302.  		if (mtmp->mhp <= 0) {
303.  			/* KMH -- Don't blame the player for pets killing gas spores */
304.  			if (!flags.mon_moving) killed(mtmp);
305.  			else monkilled(mtmp, "", (int)adtyp);
306.  		} else if (!flags.mon_moving) setmangry(mtmp);
307.  	}
308.  
309.  	/* Do your injury last */
310.  	if (uhurt) {
311.  		if ((type >= 0 || adtyp == AD_PHYS) &&	/* gas spores */
312.  				flags.verbose && olet != SCROLL_CLASS)
313.  			You("are caught in the %s!", str);
314.  		/* do property damage first, in case we end up leaving bones */
315.  		if (adtyp == AD_FIRE) burn_away_slime();
316.  		if (Invulnerable) {
317.  		    damu = 0;
318.  		    You("are unharmed!");
319.  		} else if (Half_physical_damage && adtyp == AD_PHYS)
320.  		    damu = (damu+1) / 2;
321.  		if (adtyp == AD_FIRE) (void) burnarmor(&youmonst);
322.  		destroy_item(SCROLL_CLASS, (int) adtyp);
323.  		destroy_item(SPBOOK_CLASS, (int) adtyp);
324.  		destroy_item(POTION_CLASS, (int) adtyp);
325.  		destroy_item(RING_CLASS, (int) adtyp);
326.  		destroy_item(WAND_CLASS, (int) adtyp);
327.  
328.  		ugolemeffects((int) adtyp, damu);
329.  		if (uhurt == 2) {
330.  		    if (Upolyd)
331.  		    	u.mh  -= damu;
332.  		    else
333.  			u.uhp -= damu;
334.  		    flags.botl = 1;
335.  		}
336.  
337.  		if (u.uhp <= 0 || (Upolyd && u.mh <= 0)) {
338.  		    if (Upolyd) {
339.  			rehumanize();
340.  		    } else {
341.  			if (olet == MON_EXPLODE) {
342.  			    /* killer handled by caller */
343.  			    if (str != killer_buf && !generic)
344.  				Strcpy(killer_buf, str);
345.  			    killer_format = KILLED_BY_AN;
346.  			} else if (type >= 0 && olet != SCROLL_CLASS) {
347.  			    killer_format = NO_KILLER_PREFIX;
348.  			    Sprintf(killer_buf, "caught %sself in %s own %s",
349.  				    uhim(), uhis(), str);
350.  			} else if (!strncmpi(str,"tower of flame", 8) ||
351.  				   !strncmpi(str,"fireball", 8)) {
352.  			    killer_format = KILLED_BY_AN;
353.  			    Strcpy(killer_buf, str);
354.  			} else {
355.  			    killer_format = KILLED_BY;
356.  			    Strcpy(killer_buf, str);
357.  			}
358.  			killer = killer_buf;
359.  			/* Known BUG: BURNING suppresses corpse in bones data,
360.  			   but done does not handle killer reason correctly */
361.  			done((adtyp == AD_FIRE) ? BURNING : DIED);
362.  		    }
363.  		}
364.  		exercise(A_STR, FALSE);
365.  	}
366.  
367.  	if (shopdamage) {
368.  		pay_for_damage(adtyp == AD_FIRE ? "burn away" :
369.  			       adtyp == AD_COLD ? "shatter" :
370.  			       adtyp == AD_DISN ? "disintegrate" : "destroy",
371.  			       FALSE);
372.  	}
373.  
374.  	/* explosions are noisy */
375.  	i = dam * dam;
376.  	if (i < 50) i = 50;	/* in case random damage is very small */
377.  	wake_nearto(x, y, i);
378.  }
379.  #endif /* OVL0 */

scatter Edit

380.  #ifdef OVL1
381.  
382.  struct scatter_chain {
383.  	struct scatter_chain *next;	/* pointer to next scatter item	*/
384.  	struct obj *obj;		/* pointer to the object	*/
385.  	xchar ox;			/* location of			*/
386.  	xchar oy;			/*	item			*/
387.  	schar dx;			/* direction of			*/
388.  	schar dy;			/*	travel			*/
389.  	int range;			/* range of object		*/
390.  	boolean stopped;		/* flag for in-motion/stopped	*/
391.  };
392.  
393.  /*
394.   * scflags:
395.   *	VIS_EFFECTS	Add visual effects to display
396.   *	MAY_HITMON	Objects may hit monsters
397.   *	MAY_HITYOU	Objects may hit hero
398.   *	MAY_HIT		Objects may hit you or monsters
399.   *	MAY_DESTROY	Objects may be destroyed at random
400.   *	MAY_FRACTURE	Stone objects can be fractured (statues, boulders)
401.   */
402.  
403.  /* returns number of scattered objects */
404.  long
405.  scatter(sx,sy,blastforce,scflags, obj)
406.  int sx,sy;				/* location of objects to scatter */
407.  int blastforce;				/* force behind the scattering	*/
408.  unsigned int scflags;
409.  struct obj *obj;			/* only scatter this obj        */
410.  {
411.  	register struct obj *otmp;
412.  	register int tmp;
413.  	int farthest = 0;
414.  	uchar typ;
415.  	long qtmp;
416.  	boolean used_up;
417.  	boolean individual_object = obj ? TRUE : FALSE;
418.  	struct monst *mtmp;
419.  	struct scatter_chain *stmp, *stmp2 = 0;
420.  	struct scatter_chain *schain = (struct scatter_chain *)0;
421.  	long total = 0L;
422.  
423.  	while ((otmp = individual_object ? obj : level.objects[sx][sy]) != 0) {
424.  	    if (otmp->quan > 1L) {
425.  		qtmp = otmp->quan - 1;
426.  		if (qtmp > LARGEST_INT) qtmp = LARGEST_INT;
427.  		qtmp = (long)rnd((int)qtmp);
428.  		otmp = splitobj(otmp, qtmp);
429.  	    } else {
430.  		obj = (struct obj *)0; /* all used */
431.  	    }
432.  	    obj_extract_self(otmp);
433.  	    used_up = FALSE;
434.  
435.  	    /* 9 in 10 chance of fracturing boulders or statues */
436.  	    if ((scflags & MAY_FRACTURE)
437.  			&& ((otmp->otyp == BOULDER) || (otmp->otyp == STATUE))
438.  			&& rn2(10)) {
439.  		if (otmp->otyp == BOULDER) {
440.  		    pline("%s apart.", Tobjnam(otmp, "break"));
441.  		    fracture_rock(otmp);
442.  		    place_object(otmp, sx, sy);
443.  		    if ((otmp = sobj_at(BOULDER, sx, sy)) != 0) {
444.  			/* another boulder here, restack it to the top */
445.  			obj_extract_self(otmp);
446.  			place_object(otmp, sx, sy);
447.  		    }
448.  		} else {
449.  		    struct trap *trap;
450.  
451.  		    if ((trap = t_at(sx,sy)) && trap->ttyp == STATUE_TRAP)
452.  			    deltrap(trap);
453.  		    pline("%s.", Tobjnam(otmp, "crumble"));
454.  		    (void) break_statue(otmp);
455.  		    place_object(otmp, sx, sy);	/* put fragments on floor */
456.  		}
457.  		used_up = TRUE;
458.  
459.  	    /* 1 in 10 chance of destruction of obj; glass, egg destruction */
460.  	    } else if ((scflags & MAY_DESTROY) && (!rn2(10)
461.  			|| (objects[otmp->otyp].oc_material == GLASS
462.  			|| otmp->otyp == EGG))) {
463.  		if (breaks(otmp, (xchar)sx, (xchar)sy)) used_up = TRUE;
464.  	    }
465.  
466.  	    if (!used_up) {
467.  		stmp = (struct scatter_chain *)
468.  					alloc(sizeof(struct scatter_chain));
469.  		stmp->next = (struct scatter_chain *)0;
470.  		stmp->obj = otmp;
471.  		stmp->ox = sx;
472.  		stmp->oy = sy;
473.  		tmp = rn2(8);		/* get the direction */
474.  		stmp->dx = xdir[tmp];
475.  		stmp->dy = ydir[tmp];
476.  		tmp = blastforce - (otmp->owt/40);
477.  		if (tmp < 1) tmp = 1;
478.  		stmp->range = rnd(tmp); /* anywhere up to that determ. by wt */
479.  		if (farthest < stmp->range) farthest = stmp->range;
480.  		stmp->stopped = FALSE;
481.  		if (!schain)
482.  		    schain = stmp;
483.  		else
484.  		    stmp2->next = stmp;
485.  		stmp2 = stmp;
486.  	    }
487.  	}
488.  
489.  	while (farthest-- > 0) {
490.  		for (stmp = schain; stmp; stmp = stmp->next) {
491.  		   if ((stmp->range-- > 0) && (!stmp->stopped)) {
492.  			bhitpos.x = stmp->ox + stmp->dx;
493.  			bhitpos.y = stmp->oy + stmp->dy;
494.  			typ = levl[bhitpos.x][bhitpos.y].typ;
495.  			if(!isok(bhitpos.x, bhitpos.y)) {
496.  				bhitpos.x -= stmp->dx;
497.  				bhitpos.y -= stmp->dy;
498.  				stmp->stopped = TRUE;
499.  			} else if(!ZAP_POS(typ) ||
500.  					closed_door(bhitpos.x, bhitpos.y)) {
501.  				bhitpos.x -= stmp->dx;
502.  				bhitpos.y -= stmp->dy;
503.  				stmp->stopped = TRUE;
504.  			} else if ((mtmp = m_at(bhitpos.x, bhitpos.y)) != 0) {
505.  				if (scflags & MAY_HITMON) {
506.  				    stmp->range--;
507.  				    if (ohitmon(mtmp, stmp->obj, 1, FALSE)) {
508.  					stmp->obj = (struct obj *)0;
509.  					stmp->stopped = TRUE;
510.  				    }
511.  				}
512.  			} else if (bhitpos.x==u.ux && bhitpos.y==u.uy) {
513.  				if (scflags & MAY_HITYOU) {
514.  				    int hitvalu, hitu;
515.  
516.  				    if (multi) nomul(0);
517.  				    hitvalu = 8 + stmp->obj->spe;
518.  				    if (bigmonst(youmonst.data)) hitvalu++;
519.  				    hitu = thitu(hitvalu,
520.  						 dmgval(stmp->obj, &youmonst),
521.  						 stmp->obj, (char *)0);
522.  				    if (hitu) {
523.  					stmp->range -= 3;
524.  					stop_occupation();
525.  				    }
526.  				}
527.  			} else {
528.  				if (scflags & VIS_EFFECTS) {
529.  				    /* tmp_at(bhitpos.x, bhitpos.y); */
530.  				    /* delay_output(); */
531.  				}
532.  			}
533.  			stmp->ox = bhitpos.x;
534.  			stmp->oy = bhitpos.y;
535.  		   }
536.  		}
537.  	}
538.  	for (stmp = schain; stmp; stmp = stmp2) {
539.  		int x,y;
540.  
541.  		stmp2 = stmp->next;
542.  		x = stmp->ox; y = stmp->oy;
543.  		if (stmp->obj) {
544.  			if ( x!=sx || y!=sy )
545.  			    total += stmp->obj->quan;
546.  			place_object(stmp->obj, x, y);
547.  			stackobj(stmp->obj);
548.  		}
549.  		free((genericptr_t)stmp);
550.  		newsym(x,y);
551.  	}
552.  
553.  	return total;
554.  }
555.  
556.  

splatter_burning_oil Edit

557.  /*
558.   * Splatter burning oil from x,y to the surrounding area.
559.   *
560.   * This routine should really take a how and direction parameters.
561.   * The how is how it was caused, e.g. kicked verses thrown.  The
562.   * direction is which way to spread the flaming oil.  Different
563.   * "how"s would give different dispersal patterns.  For example,
564.   * kicking a burning flask will splatter differently from a thrown
565.   * flask hitting the ground.
566.   *
567.   * For now, just perform a "regular" explosion.
568.   */
569.  void
570.  splatter_burning_oil(x, y)
571.      int x, y;
572.  {
573.  /* ZT_SPELL(ZT_FIRE) = ZT_SPELL(AD_FIRE-1) = 10+(2-1) = 11 */
574.  #define ZT_SPELL_O_FIRE 11 /* value kludge, see zap.c */
575.      explode(x, y, ZT_SPELL_O_FIRE, d(4,4), BURNING_OIL, EXPL_FIERY);
576.  }
577.  
578.  #endif /* OVL1 */
579.  
580.  /*explode.c*/

Around Wikia's network

Random Wiki