initial commit

1 files changed, 688 insertions, 0 deletions

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");
+	}
+}