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.
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.
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 */
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*/
