From 013ac7742311556022304e8b30ca170d48b3a016 Mon Sep 17 00:00:00 2001 From: "B. Watson" Date: Thu, 7 May 2015 16:32:32 -0400 Subject: initial commit --- hack/hack.zap.c | 688 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 688 insertions(+) create mode 100644 hack/hack.zap.c (limited to 'hack/hack.zap.c') diff --git a/hack/hack.zap.c b/hack/hack.zap.c new file mode 100644 index 0000000..61eb963 --- /dev/null +++ b/hack/hack.zap.c @@ -0,0 +1,688 @@ +/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ +/* hack.zap.c - version 1.0.3 */ +/* $FreeBSD: src/games/hack/hack.zap.c,v 1.4 1999/11/16 10:26:38 marcel Exp $ */ +/* $DragonFly: src/games/hack/hack.zap.c,v 1.5 2006/08/21 19:45:32 pavalos Exp $ */ + +#include "hack.h" + +extern struct monst youmonst; + +static const char *fl[]= { + "magic missile", + "bolt of fire", + "sleep ray", + "bolt of cold", + "death ray" +}; + +static void bhitm(struct monst *, struct obj *); +static bool bhito(struct obj *, struct obj *); +static char dirlet(int, int); +static int zhit(struct monst *, int); +static bool revive(struct obj *); +static void rloco(struct obj *); +static void burn_scrolls(void); + +/* Routines for IMMEDIATE wands. */ +/* bhitm: monster mtmp was hit by the effect of wand otmp */ +static void +bhitm(struct monst *mtmp, struct obj *otmp) +{ + wakeup(mtmp); + switch (otmp->otyp) { + case WAN_STRIKING: + if (u.uswallow || rnd(20) < 10 + mtmp->data->ac) { + int tmp = d(2, 12); + hit("wand", mtmp, exclam(tmp)); + mtmp->mhp -= tmp; + if (mtmp->mhp < 1) + killed(mtmp); + } else + miss("wand", mtmp); + break; + case WAN_SLOW_MONSTER: + mtmp->mspeed = MSLOW; + break; + case WAN_SPEED_MONSTER: + mtmp->mspeed = MFAST; + break; + case WAN_UNDEAD_TURNING: + if (strchr(UNDEAD, mtmp->data->mlet)) { + mtmp->mhp -= rnd(8); + if (mtmp->mhp < 1) + killed(mtmp); + else + mtmp->mflee = 1; + } + break; + case WAN_POLYMORPH: + if (newcham(mtmp, &mons[rn2(CMNUM)])) + objects[otmp->otyp].oc_name_known = 1; + break; + case WAN_CANCELLATION: + mtmp->mcan = 1; + break; + case WAN_TELEPORTATION: + rloc(mtmp); + break; + case WAN_MAKE_INVISIBLE: + mtmp->minvis = 1; + break; +#ifdef WAN_PROBING + case WAN_PROBING: + mstatusline(mtmp); + break; +#endif /* WAN_PROBING */ + default: + impossible("What an interesting wand (%u)", otmp->otyp); + } +} + +/* + * object obj was hit by the effect of wand otmp + * returns TRUE if sth was done + */ +static bool +bhito(struct obj *obj, struct obj *otmp) +{ + int res = TRUE; + + if (obj == uball || obj == uchain) + res = FALSE; + else + switch (otmp->otyp) { + case WAN_POLYMORPH: + /* preserve symbol and quantity, but turn rocks into gems */ + mkobj_at((obj->otyp == ROCK || obj->otyp == ENORMOUS_ROCK) + ? GEM_SYM : obj->olet, + obj->ox, obj->oy)->quan = obj->quan; + delobj(obj); + break; + case WAN_STRIKING: + if (obj->otyp == ENORMOUS_ROCK) + fracture_rock(obj); + else + res = FALSE; + break; + case WAN_CANCELLATION: + if (obj->spe && obj->olet != AMULET_SYM) { + obj->known = 0; + obj->spe = 0; + } + break; + case WAN_TELEPORTATION: + rloco(obj); + break; + case WAN_MAKE_INVISIBLE: + obj->oinvis = 1; + break; + case WAN_UNDEAD_TURNING: + res = revive(obj); + break; + case WAN_SLOW_MONSTER: /* no effect on objects */ + case WAN_SPEED_MONSTER: +#ifdef WAN_PROBING + case WAN_PROBING: +#endif /* WAN_PROBING */ + res = FALSE; + break; + default: + impossible("What an interesting wand (%u)", otmp->otyp); + } + return (res); +} + +int +dozap(void) +{ + struct obj *obj; + xchar zx, zy; + + obj = getobj("/", "zap"); + if (!obj) + return (0); + if (obj->spe < 0 || (obj->spe == 0 && rn2(121))) { + pline("Nothing Happens."); + return (1); + } + if (obj->spe == 0) + pline("You wrest one more spell from the worn-out wand."); + if (!(objects[obj->otyp].bits & NODIR) && !getdir(1)) + return (1); /* make him pay for knowing !NODIR */ + obj->spe--; + if (objects[obj->otyp].bits & IMMEDIATE) { + if (u.uswallow) + bhitm(u.ustuck, obj); + else if (u.dz) { + if (u.dz > 0) { + struct obj *otmp = o_at(u.ux, u.uy); + if (otmp) + bhito(otmp, obj); + } + } else + bhit(u.dx, u.dy, rn1(8, 6), 0, bhitm, bhito, obj); + } else { + switch (obj->otyp) { + case WAN_LIGHT: + litroom(TRUE); + break; + case WAN_SECRET_DOOR_DETECTION: + if (!findit()) + return (1); + break; + case WAN_CREATE_MONSTER: + { + int cnt = 1; + if (!rn2(23)) + cnt += rn2(7) + 1; + while (cnt--) + makemon(NULL, u.ux, u.uy); + } + break; + case WAN_WISHING: + { + char buf[BUFSZ]; + struct obj *otmp; + if (u.uluck + rn2(5) < 0) { + pline("Unfortunately, nothing happens."); + break; + } + pline("You may wish for an object. What do you want? "); + getlin(buf); + if (buf[0] == '\033') + buf[0] = 0; + otmp = readobjnam(buf); + otmp = addinv(otmp); + prinv(otmp); + break; + } + case WAN_DIGGING: + /* + * Original effect (approximately): + * from CORR: dig until we pierce a wall + * from ROOM: piece wall and dig until we reach + * an ACCESSIBLE place. + * Currently: dig for digdepth positions; + * also down on request of Lennart Augustsson. + */ + { + struct rm *room; + int digdepth; + if (u.uswallow) { + struct monst *mtmp = u.ustuck; + + pline("You pierce %s's stomach wall!", + monnam(mtmp)); + mtmp->mhp = 1; /* almost dead */ + unstuck(mtmp); + mnexto(mtmp); + break; + } + if (u.dz) { + if (u.dz < 0) { + pline("You loosen a rock from the ceiling."); + pline("It falls on your head!"); + losehp(1, "falling rock"); + mksobj_at(ROCK, u.ux, u.uy); + fobj->quan = 1; + stackobj(fobj); + if (Invisible) + newsym(u.ux, u.uy); + } else + dighole(); + break; + } + zx = u.ux + u.dx; + zy = u.uy + u.dy; + digdepth = 8 + rn2(18); + Tmp_at(-1, '*'); /* open call */ + while (--digdepth >= 0) { + if (!isok(zx, zy)) + break; + room = &levl[zx][zy]; + Tmp_at(zx, zy); + if (!xdnstair) { + if (zx < 3 || zx > COLNO - 3 || + zy < 3 || zy > ROWNO - 3) + break; + if (room->typ == HWALL || + room->typ == VWALL) { + room->typ = ROOM; + break; + } + } else if (room->typ == HWALL || room->typ == VWALL || + room->typ == SDOOR || room->typ == LDOOR) { + room->typ = DOOR; + digdepth -= 2; + } else if (room->typ == SCORR || !room->typ) { + room->typ = CORR; + digdepth--; + } + mnewsym(zx, zy); + zx += u.dx; + zy += u.dy; + } + mnewsym(zx, zy); /* not always necessary */ + Tmp_at(-1, -1); /* closing call */ + break; + } + default: + buzz((int)obj->otyp - WAN_MAGIC_MISSILE, + u.ux, u.uy, u.dx, u.dy); + break; + } + if (!objects[obj->otyp].oc_name_known) { + objects[obj->otyp].oc_name_known = 1; + more_experienced(0, 10); + } + } + return (1); +} + +const char * +exclam(int force) +{ + /* force == 0 occurs e.g. with sleep ray */ + /* note that large force is usual with wands so that !! would + require information about hand/weapon/wand */ + return ((force < 0) ? "?" : (force <= 4) ? "." : "!"); +} + +void +hit(const char *str, struct monst *mtmp, const char *force) +{ + /* force: usually either "." or "!" */ + if (!cansee(mtmp->mx, mtmp->my)) + pline("The %s hits it.", str); + else + pline("The %s hits %s%s", str, monnam(mtmp), force); +} + +void +miss(const char *str, struct monst *mtmp) +{ + if (!cansee(mtmp->mx, mtmp->my)) + pline("The %s misses it.", str); + else + pline("The %s misses %s.", str, monnam(mtmp)); +} + +/* + * bhit: called when a weapon is thrown (sym = obj->olet) or when an + * IMMEDIATE wand is zapped (sym = 0); the weapon falls down at end of range + * or when a monster is hit; the monster is returned, and bhitpos is set to + * the final position of the weapon thrown; the ray of a wand may affect + * several objects and monsters on its path - for each of these an argument + * function is called. + */ +/* check !u.uswallow before calling bhit() */ + +/* ddx, ddy, range: direction and range + * sym: symbol displayed on path + * fhitm, fhito: fns called when mon/obj hit + * obj: 2nd arg to fhitm/fhito + */ +struct monst * +bhit(int ddx, int ddy, int range, char sym, + void (*fhitm)(struct monst *, struct obj *), + bool (*fhito)(struct obj *, struct obj *), struct obj *obj) +{ + struct monst *mtmp; + struct obj *otmp; + int typ; + + bhitpos.x = u.ux; + bhitpos.y = u.uy; + + if (sym) /* open call */ + tmp_at(-1, sym); + while (range-- > 0) { + bhitpos.x += ddx; + bhitpos.y += ddy; + typ = levl[bhitpos.x][bhitpos.y].typ; + if ((mtmp = m_at(bhitpos.x, bhitpos.y))) { + if (sym) { + tmp_at(-1, -1); /* close call */ + return (mtmp); + } + (*fhitm)(mtmp, obj); + range -= 3; + } + if (fhito && (otmp = o_at(bhitpos.x, bhitpos.y))) { + if ((*fhito)(otmp, obj)) + range--; + } + if (!ZAP_POS(typ)) { + bhitpos.x -= ddx; + bhitpos.y -= ddy; + break; + } + if (sym) + tmp_at(bhitpos.x, bhitpos.y); + } + + /* leave last symbol unless in a pool */ + if (sym) + tmp_at(-1, (levl[bhitpos.x][bhitpos.y].typ == POOL) ? -1 : 0); + return (0); +} + +struct monst * +boomhit(int dx, int dy) +{ + int i, ct; + struct monst *mtmp; + char sym = ')'; + + bhitpos.x = u.ux; + bhitpos.y = u.uy; + + for (i = 0; i < 8; i++) + if (xdir[i] == dx && ydir[i] == dy) + break; + tmp_at(-1, sym); /* open call */ + for (ct = 0; ct < 10; ct++) { + if (i == 8) + i = 0; + sym = ')' + '(' - sym; + tmp_at(-2, sym); /* change let call */ + dx = xdir[i]; + dy = ydir[i]; + bhitpos.x += dx; + bhitpos.y += dy; + if ((mtmp = m_at(bhitpos.x, bhitpos.y)) != NULL) { + tmp_at(-1, -1); + return (mtmp); + } + if (!ZAP_POS(levl[bhitpos.x][bhitpos.y].typ)) { + bhitpos.x -= dx; + bhitpos.y -= dy; + break; + } + if (bhitpos.x == u.ux && bhitpos.y == u.uy) { /* ct == 9 */ + if (rn2(20) >= 10 + u.ulevel) { /* we hit ourselves */ + thitu(10, rnd(10), "boomerang"); + break; + } else { /* we catch it */ + tmp_at(-1, -1); + pline("Skillfully, you catch the boomerang."); + return (&youmonst); + } + } + tmp_at(bhitpos.x, bhitpos.y); + if (ct % 5 != 0) + i++; + } + tmp_at(-1, -1); /* do not leave last symbol */ + return (0); +} + +static char +dirlet(int dx, int dy) +{ + return + (dx == dy) ? '\\' : (dx && dy) ? '/' : dx ? '-' : '|'; +} + +/* type == -1: monster spitting fire at you */ +/* type == -1,-2,-3: bolts sent out by wizard */ +/* called with dx = dy = 0 with vertical bolts */ +void +buzz(int type, xchar sx, xchar sy, int dx, int dy) +{ + int abstype = abs(type); + const char *fltxt = (type == -1) ? "blaze of fire" : fl[abstype]; + struct rm *lev; + xchar range; + struct monst *mon; + + if (u.uswallow) { + int tmp; + + if (type < 0) + return; + tmp = zhit(u.ustuck, type); + pline("The %s rips into %s%s", + fltxt, monnam(u.ustuck), exclam(tmp)); + return; + } + if (type < 0) + pru(); + range = rn1(7, 7); + Tmp_at(-1, dirlet(dx, dy)); /* open call */ + while (range-- > 0) { + sx += dx; + sy += dy; + if ((lev = &levl[sx][sy])->typ) + Tmp_at(sx, sy); + else { + int bounce = 0; + if (cansee(sx - dx, sy - dy)) + pline("The %s bounces!", fltxt); + if (ZAP_POS(levl[sx][sy - dy].typ)) + bounce = 1; + if (ZAP_POS(levl[sx - dx][sy].typ)) { + if (!bounce || rn2(2)) + bounce = 2; + } + switch (bounce) { + case 0: + dx = -dx; + dy = -dy; + continue; + case 1: + dy = -dy; + sx -= dx; + break; + case 2: + dx = -dx; + sy -= dy; + break; + } + Tmp_at(-2, dirlet(dx, dy)); + continue; + } + if (lev->typ == POOL && abstype == 1 /* fire */) { + range -= 3; + lev->typ = ROOM; + if (cansee(sx, sy)) { + mnewsym(sx, sy); + pline("The water evaporates."); + } else + pline("You hear a hissing sound."); + } + if ((mon = m_at(sx, sy)) && + (type != -1 || mon->data->mlet != 'D')) { + wakeup(mon); + if (rnd(20) < 18 + mon->data->ac) { + int tmp = zhit(mon, abstype); + if (mon->mhp < 1) { + if (type < 0) { + if (cansee(mon->mx, mon->my)) + pline("%s is killed by the %s!", + Monnam(mon), fltxt); + mondied(mon); + } else + killed(mon); + } else + hit(fltxt, mon, exclam(tmp)); + range -= 2; + } else + miss(fltxt, mon); + } else if (sx == u.ux && sy == u.uy) { + nomul(0); + if (rnd(20) < 18 + u.uac) { + int dam = 0; + range -= 2; + pline("The %s hits you!", fltxt); + switch (abstype) { + case 0: + dam = d(2, 6); + break; + case 1: + if (Fire_resistance) + pline("You don't feel hot!"); + else + dam = d(6, 6); + if (!rn2(3)) + burn_scrolls(); + break; + case 2: + nomul(-rnd(25)); /* sleep ray */ + break; + case 3: + if (Cold_resistance) + pline("You don't feel cold!"); + else + dam = d(6, 6); + break; + case 4: + u.uhp = -1; + } + losehp(dam, fltxt); + } else + pline("The %s whizzes by you!", fltxt); + stop_occupation(); + } + if (!ZAP_POS(lev->typ)) { + int bounce = 0, rmn; + if (cansee(sx, sy)) + pline("The %s bounces!", fltxt); + range--; + if (!dx || !dy || !rn2(20)) { + dx = -dx; + dy = -dy; + } else { + if (ZAP_POS(rmn = levl[sx][sy - dy].typ) && + (IS_ROOM(rmn) || ZAP_POS(levl[sx + dx][sy - dy].typ))) + bounce = 1; + if (ZAP_POS(rmn = levl[sx - dx][sy].typ) && + (IS_ROOM(rmn) || ZAP_POS(levl[sx - dx][sy + dy].typ))) + if (!bounce || rn2(2)) + bounce = 2; + + switch (bounce) { + case 0: + dy = -dy; + dx = -dx; + break; + case 1: + dy = -dy; + break; + case 2: + dx = -dx; + break; + } + Tmp_at(-2, dirlet(dx, dy)); + } + } + } + Tmp_at(-1, -1); +} + +static int +zhit(struct monst *mon, int type) /* returns damage to mon */ +{ + int tmp = 0; + + switch (type) { + case 0: /* magic missile */ + tmp = d(2, 6); + break; + case -1: /* Dragon blazing fire */ + case 1: /* fire */ + if (strchr("Dg", mon->data->mlet)) + break; + tmp = d(6, 6); + if (strchr("YF", mon->data->mlet)) + tmp += 7; + break; + case 2: /* sleep*/ + mon->mfroz = 1; + break; + case 3: /* cold */ + if (strchr("YFgf", mon->data->mlet)) + break; + tmp = d(6, 6); + if (mon->data->mlet == 'D') + tmp += 7; + break; + case 4: /* death*/ + if (strchr(UNDEAD, mon->data->mlet)) + break; + tmp = mon->mhp + 1; + break; + } + mon->mhp -= tmp; + return (tmp); +} + +#define CORPSE_I_TO_C(otyp) (char) ((otyp >= DEAD_ACID_BLOB)\ + ? 'a' + (otyp - DEAD_ACID_BLOB)\ + : '@' + (otyp - DEAD_HUMAN)) +static bool +revive(struct obj *obj) +{ + struct monst *mtmp = NULL; + + if (obj->olet == FOOD_SYM && obj->otyp > CORPSE) { + /* do not (yet) revive shopkeepers */ + /* Note: this might conceivably produce two monsters + * at the same position - strange, but harmless */ + mtmp = mkmon_at(CORPSE_I_TO_C(obj->otyp), obj->ox, obj->oy); + delobj(obj); + } + return (!!mtmp); /* TRUE if some monster created */ +} + +static void +rloco(struct obj *obj) +{ + int tx, ty, otx, oty; + + otx = obj->ox; + oty = obj->oy; + do { + tx = rn1(COLNO - 3, 2); + ty = rn2(ROWNO); + } while (!goodpos(tx, ty)); + obj->ox = tx; + obj->oy = ty; + if (cansee(otx, oty)) + newsym(otx, oty); +} + +/* fractured by pick-axe or wand of striking */ +/* no texts here! */ +void +fracture_rock(struct obj *obj) +{ + obj->otyp = ROCK; + obj->quan = 7 + rn2(60); + obj->owt = weight(obj); + obj->olet = WEAPON_SYM; + if (cansee(obj->ox, obj->oy)) + prl(obj->ox, obj->oy); +} + +static void +burn_scrolls(void) +{ + struct obj *obj, *obj2; + int cnt = 0; + + for (obj = invent; obj; obj = obj2) { + obj2 = obj->nobj; + if (obj->olet == SCROLL_SYM) { + cnt++; + useup(obj); + } + } + if (cnt > 1) { + pline("Your scrolls catch fire!"); + losehp(cnt, "burning scrolls"); + } else if (cnt) { + pline("Your scroll catches fire!"); + losehp(1, "burning scroll"); + } +} -- cgit v1.2.3