Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/games/hack/hack.vault.c

385 lines
9.5 KiB
C
Raw Blame History

/* $NetBSD: hack.vault.c,v 1.9 2011/08/16 09:26:22 christos Exp $ */
/*
* Copyright (c) 1985, Stichting Centrum voor Wiskunde en Informatica,
* Amsterdam
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Stichting Centrum voor Wiskunde en
* Informatica, nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 1982 Jay Fenlason <hack@gnu.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: hack.vault.c,v 1.9 2011/08/16 09:26:22 christos Exp $");
#endif /* not lint */
#include "hack.h"
#include "extern.h"
#ifdef QUEST
void
setgd(void)
{
}
int
gd_move(void)
{
return (2);
}
void
gddead(void)
{
}
void
replgd(struct monst *mtmp __unused, struct monst *mtmp2 __unused)
{
}
void
invault(void)
{
}
#else
#include "def.mkroom.h"
#define FCSIZ (ROWNO+COLNO)
struct fakecorridor {
xchar fx, fy, ftyp;
};
struct egd {
int fcbeg, fcend; /* fcend: first unused pos */
xchar gdx, gdy; /* goal of guard's walk */
unsigned gddone:1;
struct fakecorridor fakecorr[FCSIZ];
};
static const struct permonst pm_guard =
{"guard", '@', 12, 12, -1, 4, 10, sizeof(struct egd)};
static struct monst *guard;
static int gdlevel;
static void restfakecorr(void);
static int goldincorridor(void);
static void
restfakecorr(void)
{
int fcx, fcy, fcbeg;
struct rm *crm;
struct egd *egd = monster_private(guard);
while ((fcbeg = egd->fcbeg) < egd->fcend) {
fcx = egd->fakecorr[fcbeg].fx;
fcy = egd->fakecorr[fcbeg].fy;
if ((u.ux == fcx && u.uy == fcy) || cansee(fcx, fcy) ||
m_at(fcx, fcy))
return;
crm = &levl[fcx][fcy];
crm->typ = egd->fakecorr[fcbeg].ftyp;
if (!crm->typ)
crm->seen = 0;
newsym(fcx, fcy);
egd->fcbeg++;
}
/* it seems he left the corridor - let the guard disappear */
mondead(guard);
guard = 0;
}
static int
goldincorridor(void)
{
int fci;
struct egd *egd = monster_private(guard);
for (fci = egd->fcbeg; fci < egd->fcend; fci++)
if (g_at(egd->fakecorr[fci].fx, egd->fakecorr[fci].fy))
return (1);
return (0);
}
void
setgd(void)
{
struct monst *mtmp;
for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
if (mtmp->isgd) {
guard = mtmp;
gdlevel = dlevel;
return;
}
guard = 0;
}
void
invault(void)
{
int tmp = inroom(u.ux, u.uy);
struct egd *egd;
if (tmp < 0 || rooms[tmp].rtype != VAULT) {
u.uinvault = 0;
return;
}
if (++u.uinvault % 50 == 0 && (!guard || gdlevel != dlevel)) {
char buf[BUFSZ];
int x, y, dd, gx, gy;
/* first find the goal for the guard */
for (dd = 1; (dd < ROWNO || dd < COLNO); dd++) {
for (y = u.uy - dd; y <= u.uy + dd; y++) {
if (y < 0 || y > ROWNO - 1)
continue;
for (x = u.ux - dd; x <= u.ux + dd; x++) {
if (y != u.uy - dd && y != u.uy + dd && x != u.ux - dd)
x = u.ux + dd;
if (x < 0 || x > COLNO - 1)
continue;
if (levl[x][y].typ == CORR)
goto fnd;
}
}
}
impossible("Not a single corridor on this level??");
tele();
return;
fnd:
gx = x;
gy = y;
/* next find a good place for a door in the wall */
x = u.ux;
y = u.uy;
while (levl[x][y].typ == ROOM) {
int dx, dy;
dx = (gx > x) ? 1 : (gx < x) ? -1 : 0;
dy = (gy > y) ? 1 : (gy < y) ? -1 : 0;
if (abs(gx - x) >= abs(gy - y))
x += dx;
else
y += dy;
}
/* make something interesting happen */
if (!(guard = makemon(&pm_guard, x, y)))
return;
guard->isgd = guard->mpeaceful = 1;
egd = monster_private(guard);
egd->gddone = 0;
gdlevel = dlevel;
if (!cansee(guard->mx, guard->my)) {
mondead(guard);
guard = 0;
return;
}
pline("Suddenly one of the Vault's guards enters!");
pmon(guard);
do {
pline("\"Hello stranger, who are you?\" - ");
getlin(buf);
} while (!letter(buf[0]));
if (!strcmp(buf, "Croesus") || !strcmp(buf, "Kroisos")) {
pline("\"Oh, yes - of course. Sorry to have disturbed you.\"");
mondead(guard);
guard = 0;
return;
}
clrlin();
pline("\"I don't know you.\"");
if (!u.ugold)
pline("\"Please follow me.\"");
else {
pline("\"Most likely all that gold was stolen from this vault.\"");
pline("\"Please drop your gold (say d$ ) and follow me.\"");
}
egd->gdx = gx;
egd->gdy = gy;
egd->fcbeg = 0;
egd->fakecorr[0].fx = x;
egd->fakecorr[0].fy = y;
egd->fakecorr[0].ftyp = levl[x][y].typ;
levl[x][y].typ = DOOR;
egd->fcend = 1;
}
}
int
gd_move(void)
{
int x, y, dx, dy, gx, gy, nx, ny, typ;
struct fakecorridor *fcp;
struct rm *crm;
struct egd *egd = monster_private(guard);
if (!guard || gdlevel != dlevel) {
impossible("Where is the guard?");
return (2); /* died */
}
if (u.ugold || goldincorridor())
return (0); /* didnt move */
if (dist(guard->mx, guard->my) > 1 || egd->gddone) {
restfakecorr();
return (0); /* didnt move */
}
x = guard->mx;
y = guard->my;
/* look around (hor & vert only) for accessible places */
for (nx = x - 1; nx <= x + 1; nx++)
for (ny = y - 1; ny <= y + 1; ny++) {
if (nx == x || ny == y)
if (nx != x || ny != y)
if (isok(nx, ny))
if (!IS_WALL(typ = (crm = &levl[nx][ny])->typ) && typ != POOL) {
int i;
for (i = egd->fcbeg; i < egd->fcend; i++)
if (egd->fakecorr[i].fx == nx &&
egd->fakecorr[i].fy == ny)
goto nextnxy;
if ((i = inroom(nx, ny)) >= 0 && rooms[i].rtype == VAULT)
goto nextnxy;
/*
* seems we found a
* good place to
* leave him alone
*/
egd->gddone = 1;
if (ACCESSIBLE(typ))
goto newpos;
crm->typ = (typ == SCORR) ? CORR : DOOR;
goto proceed;
}
nextnxy: ;
}
nx = x;
ny = y;
gx = egd->gdx;
gy = egd->gdy;
dx = (gx > x) ? 1 : (gx < x) ? -1 : 0;
dy = (gy > y) ? 1 : (gy < y) ? -1 : 0;
if (abs(gx - x) >= abs(gy - y))
nx += dx;
else
ny += dy;
while ((typ = (crm = &levl[nx][ny])->typ) != 0) {
/*
* in view of the above we must have IS_WALL(typ) or typ ==
* POOL
*/
/* must be a wall here */
if (isok(nx + nx - x, ny + ny - y) && typ != POOL &&
ZAP_POS(levl[nx + nx - x][ny + ny - y].typ)) {
crm->typ = DOOR;
goto proceed;
}
if (dy && nx != x) {
nx = x;
ny = y + dy;
continue;
}
if (dx && ny != y) {
ny = y;
nx = x + dx;
dy = 0;
continue;
}
/* I don't like this, but ... */
crm->typ = DOOR;
goto proceed;
}
crm->typ = CORR;
proceed:
if (cansee(nx, ny)) {
mnewsym(nx, ny);
prl(nx, ny);
}
fcp = &(egd->fakecorr[egd->fcend]);
if (egd->fcend++ == FCSIZ)
panic("fakecorr overflow");
fcp->fx = nx;
fcp->fy = ny;
fcp->ftyp = typ;
newpos:
if (egd->gddone)
nx = ny = 0;
guard->mx = nx;
guard->my = ny;
pmon(guard);
restfakecorr();
return (1);
}
void
gddead(void)
{
guard = 0;
}
void
replgd(struct monst *mtmp, struct monst *mtmp2)
{
if (mtmp == guard)
guard = mtmp2;
}
#endif /* QUEST */
Reference in New Issue View Git Blame Copy Permalink