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