Generally use NULL instead of explicitly casting 0 to some pointer type (part2).
[dragonfly.git] / games / hack / hack.zap.c
CommitLineData
984263bc
MD
1/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2/* hack.zap.c - version 1.0.3 */
3/* $FreeBSD: src/games/hack/hack.zap.c,v 1.4 1999/11/16 10:26:38 marcel Exp $ */
c7106d58 4/* $DragonFly: src/games/hack/hack.zap.c,v 1.5 2006/08/21 19:45:32 pavalos Exp $ */
984263bc
MD
5
6#include "hack.h"
7
c7106d58 8extern struct monst youmonst;
984263bc 9
fd2d026f 10static const char *fl[]= {
984263bc
MD
11 "magic missile",
12 "bolt of fire",
13 "sleep ray",
14 "bolt of cold",
15 "death ray"
16};
17
c7106d58
PA
18static void bhitm(struct monst *, struct obj *);
19static bool bhito(struct obj *, struct obj *);
20static char dirlet(int, int);
21static int zhit(struct monst *, int);
22static bool revive(struct obj *);
23static void rloco(struct obj *);
24static void burn_scrolls(void);
25
984263bc
MD
26/* Routines for IMMEDIATE wands. */
27/* bhitm: monster mtmp was hit by the effect of wand otmp */
c7106d58
PA
28static void
29bhitm(struct monst *mtmp, struct obj *otmp)
984263bc
MD
30{
31 wakeup(mtmp);
32 switch(otmp->otyp) {
33 case WAN_STRIKING:
34 if(u.uswallow || rnd(20) < 10+mtmp->data->ac) {
35 int tmp = d(2,12);
36 hit("wand", mtmp, exclam(tmp));
37 mtmp->mhp -= tmp;
38 if(mtmp->mhp < 1) killed(mtmp);
39 } else miss("wand", mtmp);
40 break;
41 case WAN_SLOW_MONSTER:
42 mtmp->mspeed = MSLOW;
43 break;
44 case WAN_SPEED_MONSTER:
45 mtmp->mspeed = MFAST;
46 break;
47 case WAN_UNDEAD_TURNING:
48 if(index(UNDEAD,mtmp->data->mlet)) {
49 mtmp->mhp -= rnd(8);
50 if(mtmp->mhp < 1) killed(mtmp);
51 else mtmp->mflee = 1;
52 }
53 break;
54 case WAN_POLYMORPH:
55 if( newcham(mtmp,&mons[rn2(CMNUM)]) )
56 objects[otmp->otyp].oc_name_known = 1;
57 break;
58 case WAN_CANCELLATION:
59 mtmp->mcan = 1;
60 break;
61 case WAN_TELEPORTATION:
62 rloc(mtmp);
63 break;
64 case WAN_MAKE_INVISIBLE:
65 mtmp->minvis = 1;
66 break;
67#ifdef WAN_PROBING
68 case WAN_PROBING:
69 mstatusline(mtmp);
70 break;
304d60d9 71#endif /* WAN_PROBING */
984263bc
MD
72 default:
73 impossible("What an interesting wand (%u)", otmp->otyp);
74 }
75}
76
c7106d58
PA
77static bool
78bhito(struct obj *obj, struct obj *otmp)
79 /* object obj was hit by the effect of wand otmp */
80 /* returns TRUE if sth was done */
984263bc
MD
81{
82 int res = TRUE;
83
84 if(obj == uball || obj == uchain)
85 res = FALSE;
86 else
87 switch(otmp->otyp) {
88 case WAN_POLYMORPH:
89 /* preserve symbol and quantity, but turn rocks into gems */
90 mkobj_at((obj->otyp == ROCK || obj->otyp == ENORMOUS_ROCK)
91 ? GEM_SYM : obj->olet,
92 obj->ox, obj->oy) -> quan = obj->quan;
93 delobj(obj);
94 break;
95 case WAN_STRIKING:
96 if(obj->otyp == ENORMOUS_ROCK)
97 fracture_rock(obj);
98 else
99 res = FALSE;
100 break;
101 case WAN_CANCELLATION:
102 if(obj->spe && obj->olet != AMULET_SYM) {
103 obj->known = 0;
104 obj->spe = 0;
105 }
106 break;
107 case WAN_TELEPORTATION:
108 rloco(obj);
109 break;
110 case WAN_MAKE_INVISIBLE:
111 obj->oinvis = 1;
112 break;
113 case WAN_UNDEAD_TURNING:
114 res = revive(obj);
115 break;
116 case WAN_SLOW_MONSTER: /* no effect on objects */
117 case WAN_SPEED_MONSTER:
118#ifdef WAN_PROBING
119 case WAN_PROBING:
304d60d9 120#endif /* WAN_PROBING */
984263bc
MD
121 res = FALSE;
122 break;
123 default:
124 impossible("What an interesting wand (%u)", otmp->otyp);
125 }
126 return(res);
127}
128
c7106d58
PA
129int
130dozap(void)
984263bc
MD
131{
132 struct obj *obj;
133 xchar zx,zy;
134
135 obj = getobj("/", "zap");
136 if(!obj) return(0);
137 if(obj->spe < 0 || (obj->spe == 0 && rn2(121))) {
138 pline("Nothing Happens.");
139 return(1);
140 }
141 if(obj->spe == 0)
142 pline("You wrest one more spell from the worn-out wand.");
143 if(!(objects[obj->otyp].bits & NODIR) && !getdir(1))
144 return(1); /* make him pay for knowing !NODIR */
145 obj->spe--;
146 if(objects[obj->otyp].bits & IMMEDIATE) {
147 if(u.uswallow)
148 bhitm(u.ustuck, obj);
149 else if(u.dz) {
150 if(u.dz > 0) {
151 struct obj *otmp = o_at(u.ux, u.uy);
152 if(otmp)
c7106d58 153 bhito(otmp, obj);
984263bc
MD
154 }
155 } else
c7106d58 156 bhit(u.dx,u.dy,rn1(8,6),0,bhitm,bhito,obj);
984263bc
MD
157 } else {
158 switch(obj->otyp){
159 case WAN_LIGHT:
160 litroom(TRUE);
161 break;
162 case WAN_SECRET_DOOR_DETECTION:
163 if(!findit()) return(1);
164 break;
165 case WAN_CREATE_MONSTER:
166 { int cnt = 1;
167 if(!rn2(23)) cnt += rn2(7) + 1;
168 while(cnt--)
902ec341 169 makemon(NULL, u.ux, u.uy);
984263bc
MD
170 }
171 break;
172 case WAN_WISHING:
173 { char buf[BUFSZ];
174 struct obj *otmp;
984263bc
MD
175 if(u.uluck + rn2(5) < 0) {
176 pline("Unfortunately, nothing happens.");
177 break;
178 }
179 pline("You may wish for an object. What do you want? ");
180 getlin(buf);
181 if(buf[0] == '\033') buf[0] = 0;
182 otmp = readobjnam(buf);
183 otmp = addinv(otmp);
184 prinv(otmp);
185 break;
186 }
187 case WAN_DIGGING:
188 /* Original effect (approximately):
189 * from CORR: dig until we pierce a wall
190 * from ROOM: piece wall and dig until we reach
191 * an ACCESSIBLE place.
192 * Currently: dig for digdepth positions;
193 * also down on request of Lennart Augustsson.
194 */
195 { struct rm *room;
196 int digdepth;
197 if(u.uswallow) {
198 struct monst *mtmp = u.ustuck;
199
200 pline("You pierce %s's stomach wall!",
201 monnam(mtmp));
202 mtmp->mhp = 1; /* almost dead */
203 unstuck(mtmp);
204 mnexto(mtmp);
205 break;
206 }
207 if(u.dz) {
208 if(u.dz < 0) {
209 pline("You loosen a rock from the ceiling.");
210 pline("It falls on your head!");
211 losehp(1, "falling rock");
212 mksobj_at(ROCK, u.ux, u.uy);
213 fobj->quan = 1;
214 stackobj(fobj);
215 if(Invisible) newsym(u.ux, u.uy);
216 } else {
217 dighole();
218 }
219 break;
220 }
221 zx = u.ux+u.dx;
222 zy = u.uy+u.dy;
223 digdepth = 8 + rn2(18);
224 Tmp_at(-1, '*'); /* open call */
225 while(--digdepth >= 0) {
226 if(!isok(zx,zy)) break;
227 room = &levl[zx][zy];
228 Tmp_at(zx,zy);
229 if(!xdnstair){
230 if(zx < 3 || zx > COLNO-3 ||
231 zy < 3 || zy > ROWNO-3)
232 break;
233 if(room->typ == HWALL ||
234 room->typ == VWALL){
235 room->typ = ROOM;
236 break;
237 }
238 } else
239 if(room->typ == HWALL || room->typ == VWALL ||
240 room->typ == SDOOR || room->typ == LDOOR){
241 room->typ = DOOR;
242 digdepth -= 2;
243 } else
244 if(room->typ == SCORR || !room->typ) {
245 room->typ = CORR;
246 digdepth--;
247 }
248 mnewsym(zx,zy);
249 zx += u.dx;
250 zy += u.dy;
251 }
252 mnewsym(zx,zy); /* not always necessary */
253 Tmp_at(-1,-1); /* closing call */
254 break;
255 }
256 default:
257 buzz((int) obj->otyp - WAN_MAGIC_MISSILE,
258 u.ux, u.uy, u.dx, u.dy);
259 break;
260 }
261 if(!objects[obj->otyp].oc_name_known) {
262 objects[obj->otyp].oc_name_known = 1;
263 more_experienced(0,10);
264 }
265 }
266 return(1);
267}
268
fd2d026f
YT
269const char *
270exclam(int force)
984263bc
MD
271{
272 /* force == 0 occurs e.g. with sleep ray */
273 /* note that large force is usual with wands so that !! would
274 require information about hand/weapon/wand */
275 return( (force < 0) ? "?" : (force <= 4) ? "." : "!" );
276}
277
c7106d58
PA
278void
279hit(const char *str, struct monst *mtmp, const char *force)
280 /* force: usually either "." or "!" */
984263bc
MD
281{
282 if(!cansee(mtmp->mx,mtmp->my)) pline("The %s hits it.", str);
283 else pline("The %s hits %s%s", str, monnam(mtmp), force);
284}
285
c7106d58
PA
286void
287miss(const char *str, struct monst *mtmp)
984263bc
MD
288{
289 if(!cansee(mtmp->mx,mtmp->my)) pline("The %s misses it.",str);
290 else pline("The %s misses %s.",str,monnam(mtmp));
291}
292
293/* bhit: called when a weapon is thrown (sym = obj->olet) or when an
294 IMMEDIATE wand is zapped (sym = 0); the weapon falls down at end of
295 range or when a monster is hit; the monster is returned, and bhitpos
296 is set to the final position of the weapon thrown; the ray of a wand
297 may affect several objects and monsters on its path - for each of
298 these an argument function is called. */
299/* check !u.uswallow before calling bhit() */
300
c7106d58
PA
301/* ddx, ddy, range: direction and range
302 * sym: symbol displayed on path
303 * fhitm, fhito: fns called when mon/obj hit
304 * obj: 2nd arg to fhitm/fhito
305 */
984263bc 306struct monst *
c7106d58
PA
307bhit(int ddx, int ddy, int range, char sym,
308 void (*fhitm)(struct monst *, struct obj *),
309 bool (*fhito)(struct obj *, struct obj *), struct obj *obj)
984263bc
MD
310{
311 struct monst *mtmp;
312 struct obj *otmp;
313 int typ;
314
315 bhitpos.x = u.ux;
316 bhitpos.y = u.uy;
317
318 if(sym) tmp_at(-1, sym); /* open call */
319 while(range-- > 0) {
320 bhitpos.x += ddx;
321 bhitpos.y += ddy;
322 typ = levl[bhitpos.x][bhitpos.y].typ;
c7106d58 323 if((mtmp = m_at(bhitpos.x,bhitpos.y))){
984263bc
MD
324 if(sym) {
325 tmp_at(-1, -1); /* close call */
326 return(mtmp);
327 }
328 (*fhitm)(mtmp, obj);
329 range -= 3;
330 }
331 if(fhito && (otmp = o_at(bhitpos.x,bhitpos.y))){
332 if((*fhito)(otmp, obj))
333 range--;
334 }
335 if(!ZAP_POS(typ)) {
336 bhitpos.x -= ddx;
337 bhitpos.y -= ddy;
338 break;
339 }
340 if(sym) tmp_at(bhitpos.x, bhitpos.y);
341 }
342
343 /* leave last symbol unless in a pool */
344 if(sym)
345 tmp_at(-1, (levl[bhitpos.x][bhitpos.y].typ == POOL) ? -1 : 0);
346 return(0);
347}
348
349struct monst *
c7106d58
PA
350boomhit(int dx, int dy)
351{
984263bc
MD
352 int i, ct;
353 struct monst *mtmp;
354 char sym = ')';
984263bc
MD
355
356 bhitpos.x = u.ux;
357 bhitpos.y = u.uy;
358
359 for(i=0; i<8; i++) if(xdir[i] == dx && ydir[i] == dy) break;
360 tmp_at(-1, sym); /* open call */
361 for(ct=0; ct<10; ct++) {
362 if(i == 8) i = 0;
363 sym = ')' + '(' - sym;
364 tmp_at(-2, sym); /* change let call */
365 dx = xdir[i];
366 dy = ydir[i];
367 bhitpos.x += dx;
368 bhitpos.y += dy;
c7106d58 369 if((mtmp = m_at(bhitpos.x, bhitpos.y))){
984263bc
MD
370 tmp_at(-1,-1);
371 return(mtmp);
372 }
373 if(!ZAP_POS(levl[bhitpos.x][bhitpos.y].typ)) {
374 bhitpos.x -= dx;
375 bhitpos.y -= dy;
376 break;
377 }
378 if(bhitpos.x == u.ux && bhitpos.y == u.uy) { /* ct == 9 */
379 if(rn2(20) >= 10+u.ulevel){ /* we hit ourselves */
c7106d58 380 thitu(10, rnd(10), "boomerang");
984263bc
MD
381 break;
382 } else { /* we catch it */
383 tmp_at(-1,-1);
384 pline("Skillfully, you catch the boomerang.");
385 return(&youmonst);
386 }
387 }
388 tmp_at(bhitpos.x, bhitpos.y);
389 if(ct % 5 != 0) i++;
390 }
391 tmp_at(-1, -1); /* do not leave last symbol */
392 return(0);
393}
394
c7106d58
PA
395static char
396dirlet(int dx, int dy)
397{
984263bc
MD
398 return
399 (dx == dy) ? '\\' : (dx && dy) ? '/' : dx ? '-' : '|';
400}
401
402/* type == -1: monster spitting fire at you */
403/* type == -1,-2,-3: bolts sent out by wizard */
404/* called with dx = dy = 0 with vertical bolts */
c7106d58
PA
405void
406buzz(int type, xchar sx, xchar sy, int dx, int dy)
984263bc
MD
407{
408 int abstype = abs(type);
fd2d026f 409 const char *fltxt = (type == -1) ? "blaze of fire" : fl[abstype];
984263bc
MD
410 struct rm *lev;
411 xchar range;
412 struct monst *mon;
413
414 if(u.uswallow) {
415 int tmp;
416
417 if(type < 0) return;
418 tmp = zhit(u.ustuck, type);
419 pline("The %s rips into %s%s",
420 fltxt, monnam(u.ustuck), exclam(tmp));
421 return;
422 }
423 if(type < 0) pru();
424 range = rn1(7,7);
425 Tmp_at(-1, dirlet(dx,dy)); /* open call */
426 while(range-- > 0) {
427 sx += dx;
428 sy += dy;
429 if((lev = &levl[sx][sy])->typ) Tmp_at(sx,sy);
430 else {
431 int bounce = 0;
432 if(cansee(sx-dx,sy-dy))
433 pline("The %s bounces!", fltxt);
434 if(ZAP_POS(levl[sx][sy-dy].typ))
435 bounce = 1;
436 if(ZAP_POS(levl[sx-dx][sy].typ)) {
437 if(!bounce || rn2(2)) bounce = 2;
438 }
439 switch(bounce){
440 case 0:
441 dx = -dx;
442 dy = -dy;
443 continue;
444 case 1:
445 dy = -dy;
446 sx -= dx;
447 break;
448 case 2:
449 dx = -dx;
450 sy -= dy;
451 break;
452 }
453 Tmp_at(-2,dirlet(dx,dy));
454 continue;
455 }
456 if(lev->typ == POOL && abstype == 1 /* fire */) {
457 range -= 3;
458 lev->typ = ROOM;
459 if(cansee(sx,sy)) {
460 mnewsym(sx,sy);
461 pline("The water evaporates.");
462 } else
463 pline("You hear a hissing sound.");
464 }
465 if((mon = m_at(sx,sy)) &&
466 (type != -1 || mon->data->mlet != 'D')) {
467 wakeup(mon);
468 if(rnd(20) < 18 + mon->data->ac) {
469 int tmp = zhit(mon,abstype);
470 if(mon->mhp < 1) {
471 if(type < 0) {
472 if(cansee(mon->mx,mon->my))
473 pline("%s is killed by the %s!",
474 Monnam(mon), fltxt);
475 mondied(mon);
476 } else
477 killed(mon);
478 } else
479 hit(fltxt, mon, exclam(tmp));
480 range -= 2;
481 } else
482 miss(fltxt,mon);
483 } else if(sx == u.ux && sy == u.uy) {
484 nomul(0);
485 if(rnd(20) < 18+u.uac) {
486 int dam = 0;
487 range -= 2;
488 pline("The %s hits you!",fltxt);
489 switch(abstype) {
490 case 0:
491 dam = d(2,6);
492 break;
493 case 1:
494 if(Fire_resistance)
495 pline("You don't feel hot!");
496 else dam = d(6,6);
497 if(!rn2(3))
498 burn_scrolls();
499 break;
500 case 2:
501 nomul(-rnd(25)); /* sleep ray */
502 break;
503 case 3:
504 if(Cold_resistance)
505 pline("You don't feel cold!");
506 else dam = d(6,6);
507 break;
508 case 4:
509 u.uhp = -1;
510 }
511 losehp(dam,fltxt);
512 } else pline("The %s whizzes by you!",fltxt);
513 stop_occupation();
514 }
515 if(!ZAP_POS(lev->typ)) {
516 int bounce = 0, rmn;
517 if(cansee(sx,sy)) pline("The %s bounces!",fltxt);
518 range--;
519 if(!dx || !dy || !rn2(20)){
520 dx = -dx;
521 dy = -dy;
522 } else {
523 if(ZAP_POS(rmn = levl[sx][sy-dy].typ) &&
524 (IS_ROOM(rmn) || ZAP_POS(levl[sx+dx][sy-dy].typ)))
525 bounce = 1;
526 if(ZAP_POS(rmn = levl[sx-dx][sy].typ) &&
527 (IS_ROOM(rmn) || ZAP_POS(levl[sx-dx][sy+dy].typ)))
528 if(!bounce || rn2(2))
529 bounce = 2;
530
531 switch(bounce){
532 case 0:
533 dy = -dy;
534 dx = -dx;
535 break;
536 case 1:
537 dy = -dy;
538 break;
539 case 2:
540 dx = -dx;
541 break;
542 }
543 Tmp_at(-2, dirlet(dx,dy));
544 }
545 }
546 }
547 Tmp_at(-1,-1);
548}
549
c7106d58
PA
550static int
551zhit(struct monst *mon, int type) /* returns damage to mon */
984263bc
MD
552{
553 int tmp = 0;
554
555 switch(type) {
556 case 0: /* magic missile */
557 tmp = d(2,6);
558 break;
559 case -1: /* Dragon blazing fire */
560 case 1: /* fire */
561 if(index("Dg", mon->data->mlet)) break;
562 tmp = d(6,6);
563 if(index("YF", mon->data->mlet)) tmp += 7;
564 break;
565 case 2: /* sleep*/
566 mon->mfroz = 1;
567 break;
568 case 3: /* cold */
569 if(index("YFgf", mon->data->mlet)) break;
570 tmp = d(6,6);
571 if(mon->data->mlet == 'D') tmp += 7;
572 break;
573 case 4: /* death*/
574 if(index(UNDEAD, mon->data->mlet)) break;
575 tmp = mon->mhp+1;
576 break;
577 }
578 mon->mhp -= tmp;
579 return(tmp);
580}
581
582#define CORPSE_I_TO_C(otyp) (char) ((otyp >= DEAD_ACID_BLOB)\
583 ? 'a' + (otyp - DEAD_ACID_BLOB)\
584 : '@' + (otyp - DEAD_HUMAN))
c7106d58
PA
585static bool
586revive(struct obj *obj)
984263bc 587{
c7106d58 588 struct monst *mtmp = NULL;
984263bc
MD
589
590 if(obj->olet == FOOD_SYM && obj->otyp > CORPSE) {
591 /* do not (yet) revive shopkeepers */
592 /* Note: this might conceivably produce two monsters
593 at the same position - strange, but harmless */
594 mtmp = mkmon_at(CORPSE_I_TO_C(obj->otyp),obj->ox,obj->oy);
595 delobj(obj);
596 }
597 return(!!mtmp); /* TRUE if some monster created */
598}
599
c7106d58
PA
600static void
601rloco(struct obj *obj)
984263bc
MD
602{
603 int tx,ty,otx,oty;
604
605 otx = obj->ox;
606 oty = obj->oy;
607 do {
608 tx = rn1(COLNO-3,2);
609 ty = rn2(ROWNO);
610 } while(!goodpos(tx,ty));
611 obj->ox = tx;
612 obj->oy = ty;
613 if(cansee(otx,oty))
614 newsym(otx,oty);
615}
616
c7106d58
PA
617void
618fracture_rock(struct obj *obj) /* fractured by pick-axe or wand of striking */
619 /* no texts here! */
984263bc 620{
984263bc
MD
621 obj->otyp = ROCK;
622 obj->quan = 7 + rn2(60);
623 obj->owt = weight(obj);
624 obj->olet = WEAPON_SYM;
625 if(cansee(obj->ox,obj->oy))
626 prl(obj->ox,obj->oy);
627}
628
c7106d58
PA
629static void
630burn_scrolls(void)
984263bc
MD
631{
632 struct obj *obj, *obj2;
633 int cnt = 0;
634
635 for(obj = invent; obj; obj = obj2) {
636 obj2 = obj->nobj;
637 if(obj->olet == SCROLL_SYM) {
638 cnt++;
639 useup(obj);
640 }
641 }
642 if(cnt > 1) {
643 pline("Your scrolls catch fire!");
644 losehp(cnt, "burning scrolls");
645 } else if(cnt) {
646 pline("Your scroll catches fire!");
647 losehp(1, "burning scroll");
648 }
649}