/* "Chained" explosions, used by skilled wand users
FIXME: make skilled casting of fireball/cone of cold use this */
void
chain_explode(int x, int y, int type,
int dam, char olet, int expltype,
const char *descr, int raylevel, int amount)
{
int ex = x;
int ey = y;
while (amount--) {
ex = x + rnd(3) - 2;
ey = y + rnd(3) - 2;
if (!isok(ex, ey) || IS_STWALL(level->locations[ex][ey].typ)) {
ex = x;
ey = y;
}
explode(ex, ey, type, dam, olet, expltype, descr, raylevel);
}
}
/* Choose location where spell takes effect. */
static int
throwspell(schar *dx, schar *dy, const struct nh_cmd_arg *arg)
{
coord cc;
if (u.uinwater) {
pline("You're joking! In this weather?");
return 0;
} else if (Is_waterlevel(&u.uz)) {
pline("You had better wait for the sun to come out.");
return 0;
}
pline("Where do you want to cast the spell?");
cc.x = u.ux;
cc.y = u.uy;
if (getargpos(arg, &cc, FALSE, "the desired position") == NHCR_CLIENT_CANCEL)
return 0; /* user pressed ESC */
/* The number of moves from hero to where the spell drops. */
if (distmin(u.ux, u.uy, cc.x, cc.y) > 10) {
pline("The spell dissipates over the distance!");
return 0;
} else if (Engulfed) {
pline("The spell is cut short!");
exercise(A_WIS, FALSE); /* What were you THINKING! */
*dx = 0;
*dy = 0;
return 1;
} else
if ((!cansee(cc.x, cc.y) &&
(!MON_AT(level, cc.x, cc.y) ||
!canspotmon(m_at(level, cc.x, cc.y)))) ||
IS_STWALL(level->locations[cc.x][cc.y].typ)) {
pline("Your mind fails to lock onto that location!");
return 0;
} else {
*dx = cc.x;
*dy = cc.y;
return 1;
}
}
/*
* Is (x,y) a good position of mtmp? If mtmp is NULL, then is (x,y) good
* for an object?
*
* This function will only look at mtmp->mdat, so makemon, mplayer, etc can
* call it to generate new monster positions with fake monster structures.
*
* This function might be called during level generation, so should return
* deterministic results.
*/
boolean
goodpos(struct level *lev, int x, int y, struct monst *mtmp, unsigned gpflags)
{
const struct permonst *mdat = NULL;
boolean ignorewater = ((gpflags & MM_IGNOREWATER) != 0);
if (!isok(x, y))
return FALSE;
/* in many cases, we're trying to create a new monster, which can't go on
top of the player or any existing monster. however, occasionally we are
relocating engravings or objects, which could be co-located and thus get
restricted a bit too much. oh well. */
if (mtmp != &youmonst && x == u.ux && y == u.uy &&
(!u.usteed || mtmp != u.usteed) && !(gpflags & MM_IGNOREMONST))
return FALSE;
if (mtmp) {
struct monst *mtmp2 = (gpflags & MM_IGNOREMONST) ?
NULL : m_at(lev, x, y);
/* Be careful with long worms. A monster may be placed back in its own
location. Normally, if m_at() returns the same monster that we're
trying to place, the monster is being placed in its own location.
However, that is not correct for worm segments, because all the
segments of the worm return the same m_at(). Actually we overdo the
check a little bit--a worm can't be placed in its own location,
period. If we just checked for mtmp->mx != x || mtmp->my != y, we'd
miss the case where we're called to place the worm segment and the
worm's head is at x,y. */
if (mtmp2 && (mtmp2 != mtmp || mtmp->wormno))
return FALSE;
mdat = mtmp->data;
if (is_pool(lev, x, y) && !ignorewater) {
if (mtmp == &youmonst)
return !!(HLevitation || Flying || Wwalking || Swimming ||
Amphibious);
else
return (is_flyer(mdat) || is_swimmer(mdat) || is_clinger(mdat));
} else if (mdat->mlet == S_EEL && !ignorewater) {
return FALSE;
} else if (is_lava(lev, x, y)) {
if (mtmp == &youmonst)
return ! !HLevitation;
else
return is_flyer(mdat) || likes_lava(mdat);
}
if (IS_STWALL(lev->locations[x][y].typ)) {
if (passes_walls(mdat) && may_passwall(lev, x, y))
return TRUE;
if (gpflags & MM_CHEWROCK && may_dig(lev, x, y))
return TRUE;
}
}
if (!ACCESSIBLE(lev->locations[x][y].typ)) {
if (!(is_pool(lev, x, y) && ignorewater))
return FALSE;
}
if (!(gpflags & MM_IGNOREDOORS) && closed_door(lev, x, y) &&
(!mdat || !amorphous(mdat)))
return FALSE;
if (!(gpflags & MM_IGNOREDOORS) && sobj_at(BOULDER, lev, x, y) &&
(!mdat || !throws_rocks(mdat)))
return FALSE;
return TRUE;
}
/* return TRUE if out of bounds, wall or rock */
STATIC_OVL boolean
is_solid(int x, int y)
{
return (!isok(x,y) || IS_STWALL(levl[x][y].typ));
}
int
spelleffects(int spell, boolean atme, const struct nh_cmd_arg *arg)
{
int energy, damage, chance, n, intell;
int skill, role_skill;
boolean confused = (Confusion != 0);
struct obj *pseudo;
boolean dummy;
coord cc;
schar dx = 0, dy = 0, dz = 0;
if (!SPELL_IS_FROM_SPELLBOOK(spell)) {
/* At the moment, we implement this via calling the code for the
shortcut command. Eventually, it would make sense to invert this
(and make the shortcut commands wrappers for spelleffects). */
switch (spellid(spell)) {
case SPID_PRAY:
return dopray(arg);
case SPID_TURN:
return doturn(arg);
case SPID_RLOC:
return dotele(arg);
case SPID_JUMP:
return dojump(arg);
case SPID_MONS:
return domonability(arg);
default:
impossible("Unknown spell number %d?", spellid(spell));
return 0;
}
}
/*
* Find the skill the hero has in a spell type category.
* See spell_skilltype for categories.
*/
skill = spell_skilltype(spellid(spell));
role_skill = P_SKILL(skill);
/* Get the direction or target, if applicable.
We want to do this *before* determining spell success, both for interface
consistency and to cut down on needless mksobj calls. */
switch (spellid(spell)) {
/* These spells ask the user to target a specific space. */
case SPE_CONE_OF_COLD:
case SPE_FIREBALL:
/* If Skilled or better, get a specific space. */
if (role_skill >= P_SKILLED) {
if (throwspell(&dx, &dy, arg)) {
dz = 0;
break;
}
else {
/* Decided not to target anything. Abort the spell. */
pline("Spell canceled.");
return 0;
}
}
/* If not Skilled, fall through. */
/* These spells ask the user to target a direction. */
case SPE_FORCE_BOLT:
case SPE_SLEEP:
case SPE_MAGIC_MISSILE:
case SPE_KNOCK:
case SPE_SLOW_MONSTER:
case SPE_WIZARD_LOCK:
case SPE_DIG:
case SPE_TURN_UNDEAD:
case SPE_POLYMORPH:
case SPE_TELEPORT_AWAY:
case SPE_CANCELLATION:
case SPE_FINGER_OF_DEATH:
case SPE_HEALING:
case SPE_EXTRA_HEALING:
case SPE_DRAIN_LIFE:
case SPE_STONE_TO_FLESH:
if (atme)
dx = dy = dz = 0;
else if (!getargdir(arg, NULL, &dx, &dy, &dz)) {
/* getdir cancelled, abort */
pline("Spell canceled.");
return 0;
}
break;
case SPE_JUMPING:
if(!get_jump_coords(arg, &cc, max(role_skill, 1))) {
/* No jumping after all, I guess. */
pline("Spell canceled.");
return 0;
}
break;
/* The rest of the spells don't have targeting. */
default:
break;
}
/* Spell casting no longer affects knowledge of the spell. A decrement of
spell knowledge is done every turn. */
if (spellknow(spell) <= 0) {
pline("Your knowledge of this spell is twisted.");
pline("It invokes nightmarish images in your mind...");
spell_backfire(spell);
return 0;
} else if (spellknow(spell) <= 200) { /* 1% */
pline("You strain to recall the spell.");
} else if (spellknow(spell) <= 1000) { /* 5% */
pline("Your knowledge of this spell is growing faint.");
}
energy = (spellev(spell) * 5); /* 5 <= energy <= 35 */
if (u.uhunger <= 10 && spellid(spell) != SPE_DETECT_FOOD) {
pline("You are too hungry to cast that spell.");
return 0;
} else if (ACURR(A_STR) < 4) {
pline("You lack the strength to cast spells.");
return 0;
} else
if (check_capacity
("Your concentration falters while carrying so much stuff.")) {
return 1;
} else if (!freehand()) {
pline("Your arms are not free to cast!");
return 0;
}
if (Uhave_amulet) {
pline("You feel the amulet draining your energy away.");
energy += rnd(2 * energy);
}
if (energy > u.uen) {
pline("You don't have enough energy to cast that spell.");
return 0;
} else {
if (spellid(spell) != SPE_DETECT_FOOD) {
int hungr = energy * 2;
/*
* If hero is a wizard, their current intelligence
* (bonuses + temporary + current)
* affects hunger reduction in casting a spell.
* 1. int = 17-18 no reduction
* 2. int = 16 1/4 hungr
* 3. int = 15 1/2 hungr
* 4. int = 1-14 normal reduction
* The reason for this is:
* a) Intelligence affects the amount of exertion
* in thinking.
* b) Wizards have spent their life at magic and
* understand quite well how to cast spells.
*/
intell = acurr(A_INT);
if (!Role_if(PM_WIZARD))
intell = 10;
if (intell >= 17)
hungr = 0;
else if (intell == 16)
hungr /= 4;
else if (intell == 15)
hungr /= 2;
/* don't put player (quite) into fainting from casting a spell,
particularly since they might not even be hungry at the
beginning; however, this is low enough that they must eat before
casting anything else except detect food */
if (hungr > u.uhunger - 3)
hungr = u.uhunger - 3;
morehungry(hungr);
}
}
chance = percent_success(spell);
if (confused || (rnd(100) > chance)) {
pline("You fail to cast the spell correctly.");
u.uen -= energy / 2;
return 1;
}
u.uen -= energy;
/* pseudo is a temporary "false" object containing the spell stats */
pseudo = mktemp_sobj(level, spellid(spell));
pseudo->blessed = pseudo->cursed = 0;
pseudo->quan = 20L; /* do not let useup get it */
switch (pseudo->otyp) {
/*
* At first spells act as expected. As the hero increases in skill
* with the appropriate spell type, some spells increase in their
* effects, e.g. more damage, further distance, and so on, without
* additional cost to the spellcaster.
*/
case SPE_CONE_OF_COLD:
case SPE_FIREBALL:
if (role_skill >= P_SKILLED) {
cc.x = dx;
cc.y = dy;
n = rnd(8) + 1;
while (n--) {
if (!dx && !dy && !dz) {
if ((damage = zapyourself(pseudo, TRUE)) != 0)
losehp(damage, msgprintf(
"zapped %sself with an exploding spell",
uhim()));
} else {
explode(dx, dy, pseudo->otyp - SPE_MAGIC_MISSILE + 10,
u.ulevel / 2 + 1 + spell_damage_bonus(), 0,
(pseudo->otyp ==
SPE_CONE_OF_COLD) ? EXPL_FROSTY : EXPL_FIERY,
NULL, 0);
}
dx = cc.x + rnd(3) - 2;
dy = cc.y + rnd(3) - 2;
if (!isok(dx, dy) || !cansee(dx, dy) ||
IS_STWALL(level->locations[dx][dy].typ) || Engulfed) {
/* Spell is reflected back to center */
dx = cc.x;
dy = cc.y;
}
}
break;
}
/* else fall through... */
/* these spells are all duplicates of wand effects */
case SPE_FORCE_BOLT:
case SPE_SLEEP:
case SPE_MAGIC_MISSILE:
case SPE_KNOCK:
case SPE_SLOW_MONSTER:
case SPE_WIZARD_LOCK:
case SPE_DIG:
case SPE_TURN_UNDEAD:
case SPE_POLYMORPH:
case SPE_TELEPORT_AWAY:
case SPE_CANCELLATION:
case SPE_FINGER_OF_DEATH:
case SPE_LIGHT:
case SPE_DETECT_UNSEEN:
case SPE_HEALING:
case SPE_EXTRA_HEALING:
case SPE_DRAIN_LIFE:
case SPE_STONE_TO_FLESH:
if (objects[pseudo->otyp].oc_dir != NODIR) {
if (!dx && !dy && !dz) {
if ((damage = zapyourself(pseudo, TRUE)) != 0) {
losehp(damage, msgprintf("zapped %sself with a spell",
uhim()));
}
} else
weffects(pseudo, dx, dy, dz);
} else
weffects(pseudo, 0, 0, 0);
update_inventory(); /* spell may modify inventory */
break;
/* these are all duplicates of scroll effects */
case SPE_REMOVE_CURSE:
case SPE_CONFUSE_MONSTER:
case SPE_DETECT_FOOD:
case SPE_CAUSE_FEAR:
/* high skill yields effect equivalent to blessed scroll */
if (role_skill >= P_SKILLED)
pseudo->blessed = 1;
/* fall through */
case SPE_CHARM_MONSTER:
case SPE_MAGIC_MAPPING:
case SPE_CREATE_MONSTER:
case SPE_IDENTIFY:
seffects(pseudo, &dummy);
break;
/* these are all duplicates of potion effects */
case SPE_HASTE_SELF:
case SPE_DETECT_TREASURE:
case SPE_DETECT_MONSTERS:
case SPE_LEVITATION:
case SPE_RESTORE_ABILITY:
/* high skill yields effect equivalent to blessed potion */
if (role_skill >= P_SKILLED)
pseudo->blessed = 1;
/* fall through */
case SPE_INVISIBILITY:
peffects(pseudo);
break;
case SPE_CURE_BLINDNESS:
healup(0, 0, FALSE, TRUE);
break;
case SPE_CURE_SICKNESS:
if (Sick)
pline("You are no longer ill.");
if (Slimed) {
pline("The slime disappears!");
Slimed = 0;
}
healup(0, 0, TRUE, FALSE);
break;
case SPE_CREATE_FAMILIAR:
make_familiar(NULL, u.ux, u.uy, FALSE);
break;
case SPE_CLAIRVOYANCE:
if (!BClairvoyant)
do_vicinity_map();
/* at present, only one thing blocks clairvoyance */
else if (uarmh && uarmh->otyp == CORNUTHAUM)
pline("You sense a pointy hat on top of your %s.", body_part(HEAD));
break;
case SPE_PROTECTION:
cast_protection();
break;
case SPE_JUMPING:
jump_to_coords(&cc);
break;
default:
impossible("Unknown spell %d attempted.", spell);
obfree(pseudo, NULL);
return 0;
}
/* gain skill for successful cast */
use_skill(skill, spellev(spell));
obfree(pseudo, NULL); /* now, get rid of it */
return 1;
}
static void
cast_protection(void)
{
int loglev = 0;
int l = u.ulevel;
int natac = get_player_ac() + u.uspellprot;
int gain;
/* loglev=log2(u.ulevel)+1 (1..5) */
while (l) {
loglev++;
l /= 2;
}
/*
* The more u.uspellprot you already have, the less you get,
* and the better your natural ac, the less you get.
*
* LEVEL AC SPELLPROT from sucessive SPE_PROTECTION casts
* 1 10 0, 1, 2, 3, 4
* 1 0 0, 1, 2, 3
* 1 -10 0, 1, 2
* 2-3 10 0, 2, 4, 5, 6, 7, 8
* 2-3 0 0, 2, 4, 5, 6
* 2-3 -10 0, 2, 3, 4
* 4-7 10 0, 3, 6, 8, 9, 10, 11, 12
* 4-7 0 0, 3, 5, 7, 8, 9
* 4-7 -10 0, 3, 5, 6
* 7-15 -10 0, 3, 5, 6
* 8-15 10 0, 4, 7, 10, 12, 13, 14, 15, 16
* 8-15 0 0, 4, 7, 9, 10, 11, 12
* 8-15 -10 0, 4, 6, 7, 8
* 16-30 10 0, 5, 9, 12, 14, 16, 17, 18, 19, 20
* 16-30 0 0, 5, 9, 11, 13, 14, 15
* 16-30 -10 0, 5, 8, 9, 10
*/
gain = loglev - (int)u.uspellprot / (4 - min(3, (10 - natac) / 10));
if (gain > 0) {
if (!Blind) {
const char *hgolden = hcolor("golden");
if (u.uspellprot)
pline("The %s haze around you becomes more dense.", hgolden);
else
pline("The %s around you begins to shimmer with %s haze.",
(Underwater || Is_waterlevel(&u.uz)) ? "water" :
Engulfed ? mbodypart(u.ustuck, STOMACH) :
IS_STWALL(level->locations[u.ux][u.uy].typ) ? "stone" :
"air",
an(hgolden));
}
u.uspellprot += gain;
u.uspmtime =
P_SKILL(spell_skilltype(SPE_PROTECTION)) == P_EXPERT ? 20 : 10;
if (!u.usptime)
u.usptime = u.uspmtime;
} else {
pline("Your %s feels warm for a moment.", body_part(SKIN));
}
}
/*
* Make the mail daemon run through the dungeon. The daemon will run over
* any monsters that are in its path, but will replace them later. Return
* FALSE if the md gets stuck in a position where there is a monster. Return
* TRUE otherwise.
*/
STATIC_OVL boolean
md_rush(struct monst *md, register int tx, register int ty)
/* destination of mail daemon */
{
struct monst *mon; /* displaced monster */
register int dx, dy; /* direction counters */
int fx = md->mx, fy = md->my; /* current location */
int nfx = fx, nfy = fy, /* new location */
d1, d2; /* shortest distances */
/*
* It is possible that the monster at (fx,fy) is not the md when:
* the md rushed the hero and failed, and is now starting back.
*/
if (m_at(fx, fy) == md) {
remove_monster(fx, fy); /* pick up from orig position */
newsym(fx, fy);
}
/*
* At the beginning and exit of this loop, md is not placed in the
* dungeon.
*/
while (1) {
/* Find a good location next to (fx,fy) closest to (tx,ty). */
d1 = dist2(fx,fy,tx,ty);
for (dx = -1; dx <= 1; dx++) for(dy = -1; dy <= 1; dy++)
if ((dx || dy) && isok(fx+dx,fy+dy) &&
!IS_STWALL(levl[fx+dx][fy+dy].typ)) {
d2 = dist2(fx+dx,fy+dy,tx,ty);
if (d2 < d1) {
d1 = d2;
nfx = fx+dx;
nfy = fy+dy;
}
}
/* Break if the md couldn't find a new position. */
if (nfx == fx && nfy == fy) break;
fx = nfx; /* this is our new position */
fy = nfy;
/* Break if the md reaches its destination. */
if (fx == tx && fy == ty) break;
if ((mon = m_at(fx,fy)) != 0) /* save monster at this position */
verbalize("%s", md_exclamations());
else if (fx == u.ux && fy == u.uy)
verbalize("Excuse me.");
place_monster(md,fx,fy); /* put md down */
newsym(fx,fy); /* see it */
flush_screen(0); /* make sure md shows up */
delay_output(); /* wait a little bit */
/* Remove md from the dungeon. Restore original mon, if necessary. */
if (mon) {
if ((mon->mx != fx) || (mon->my != fy))
place_worm_seg(mon, fx, fy);
else
place_monster(mon, fx, fy);
} else
remove_monster(fx, fy);
newsym(fx,fy);
}
/*
* Check for a monster at our stopping position (this is possible, but
* very unlikely). If one exists, then have the md leave in disgust.
*/
if ((mon = m_at(fx, fy)) != 0) {
place_monster(md, fx, fy); /* display md with text below */
newsym(fx, fy);
verbalize("This place's too crowded. I'm outta here.");
if ((mon->mx != fx) || (mon->my != fy)) /* put mon back */
place_worm_seg(mon, fx, fy);
else
place_monster(mon, fx, fy);
newsym(fx, fy);
return FALSE;
}
place_monster(md, fx, fy); /* place at final spot */
newsym(fx, fy);
flush_screen(0);
delay_output(); /* wait a little bit */
return TRUE;
}
/*
* return 1: guard moved, 0: guard didn't, -1: let m_move do it, -2: died
*/
int gd_move(struct monst *grd) {
int x, y, nx, ny, m, n;
int dx, dy, gx, gy, fci;
unsigned char typ;
struct fakecorridor *fcp;
struct egd *egrd = EGD(grd);
struct rm *crm;
bool goldincorridor = false, u_in_vault = vault_occupied(u.urooms) ? true : false, grd_in_vault = *in_rooms(grd->mx, grd->my, VAULT) ?
true :
false;
bool disappear_msg_seen = false, semi_dead = (grd->mhp <= 0);
bool u_carry_gold = ((u.ugold + hidden_gold()) > 0L);
bool see_guard;
if (!on_level(&(egrd->gdlevel), &u.uz))
return (-1);
nx = ny = m = n = 0;
if (!u_in_vault && !grd_in_vault)
wallify_vault(grd);
if (!grd->mpeaceful) {
if (semi_dead) {
egrd->gddone = 1;
goto newpos;
}
if (!u_in_vault && (grd_in_vault || (in_fcorridor(grd, grd->mx, grd->my) && !in_fcorridor(grd, u.ux, u.uy)))) {
(void)rloc(grd, false);
wallify_vault(grd);
(void)clear_fcorr(grd, true);
goto letknow;
}
if (!in_fcorridor(grd, grd->mx, grd->my))
(void)clear_fcorr(grd, true);
return (-1);
}
if (abs(egrd->ogx - grd->mx) > 1 || abs(egrd->ogy - grd->my) > 1)
return (-1); /* teleported guard - treat as monster */
if (egrd->fcend == 1) {
if (u_in_vault && (u_carry_gold || um_dist(grd->mx, grd->my, 1))) {
if (egrd->warncnt == 3)
verbalize("I repeat, %sfollow me!", u_carry_gold ? (!u.ugold ? "drop that hidden gold and " : "drop that gold and ") : "");
if (egrd->warncnt == 7) {
m = grd->mx;
n = grd->my;
verbalize("You've been warned, knave!");
mnexto(grd);
levl[m][n].typ = egrd->fakecorr[0].ftyp;
newsym(m, n);
grd->mpeaceful = 0;
return (-1);
}
/* not fair to get mad when (s)he's fainted or paralyzed */
if (!is_fainted() && multi >= 0)
egrd->warncnt++;
return (0);
}
if (!u_in_vault) {
if (u_carry_gold) { /* player teleported */
m = grd->mx;
n = grd->my;
(void)rloc(grd, false);
levl[m][n].typ = egrd->fakecorr[0].ftyp;
newsym(m, n);
grd->mpeaceful = 0;
letknow: if (!cansee(grd->mx, grd->my) || !mon_visible(grd)) {
You_hear("the shrill sound of a guard's whistle.");
} else {
const char * fmt = um_dist(grd->mx, grd->my, 2) ? "see an angry %s approaching." : "are confronted by an angry %s.";
char name[BUFSZ];
g_monnam(name, BUFSZ, grd);
You(fmt, name);
}
return (-1);
} else {
verbalize("Well, begone.");
wallify_vault(grd);
egrd->gddone = 1;
goto cleanup;
}
}
}
if (egrd->fcend > 1) {
if (egrd->fcend > 2 && in_fcorridor(grd, grd->mx, grd->my) && !egrd->gddone && !in_fcorridor(grd, u.ux, u.uy) &&
levl[egrd->fakecorr[0].fx][egrd->fakecorr[0].fy].typ == egrd->fakecorr[0].ftyp) {
char name[BUFSZ];
g_monnam(name, BUFSZ, grd);
pline_The("%s, confused, disappears.", name);
disappear_msg_seen = true;
goto cleanup;
}
if (u_carry_gold && (in_fcorridor(grd, u.ux, u.uy) ||
/* cover a 'blind' spot */
(egrd->fcend > 1 && u_in_vault))) {
if (!grd->mx) {
restfakecorr(grd);
return (-2);
}
if (egrd->warncnt < 6) {
egrd->warncnt = 6;
verbalize("Drop all your gold, scoundrel!");
return (0);
} else {
verbalize("So be it, rogue!");
grd->mpeaceful = 0;
return (-1);
}
}
}
for (fci = egrd->fcbeg; fci < egrd->fcend; fci++)
if (g_at(egrd->fakecorr[fci].fx, egrd->fakecorr[fci].fy)) {
m = egrd->fakecorr[fci].fx;
n = egrd->fakecorr[fci].fy;
goldincorridor = true;
}
if (goldincorridor && !egrd->gddone) {
x = grd->mx;
y = grd->my;
if (m == u.ux && n == u.uy) {
struct obj *gold = g_at(m, n);
/* Grab the gold from between the hero's feet. */
grd->mgold += gold->quan;
delobj(gold);
newsym(m, n);
} else if (m == x && n == y) {
mpickgold(grd); /* does a newsym */
} else {
/* just for insurance... */
if (MON_AT(m, n) && m != grd->mx && n != grd->my) {
verbalize("Out of my way, scum!");
(void)rloc(m_at(m, n), false);
}
remove_monster(grd->mx, grd->my);
newsym(grd->mx, grd->my);
place_monster(grd, m, n);
mpickgold(grd); /* does a newsym */
}
if (cansee(m, n)) {
char name[BUFSZ];
Monnam(name, BUFSZ, grd);
pline("%s%s picks up the gold.", name, grd->mpeaceful ? " calms down and" : "");
}
if (x != grd->mx || y != grd->my) {
remove_monster(grd->mx, grd->my);
newsym(grd->mx, grd->my);
place_monster(grd, x, y);
newsym(x, y);
}
if (!grd->mpeaceful)
return (-1);
else {
egrd->warncnt = 5;
return (0);
}
}
if (um_dist(grd->mx, grd->my, 1) || egrd->gddone) {
if (!egrd->gddone && !rn2(10))
verbalize("Move along!");
restfakecorr(grd);
return (0); /* didn't move */
}
x = grd->mx;
y = grd->my;
if (u_in_vault)
goto nextpos;
/* 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) && (nx != x || ny != y) && isok(nx, ny)) {
typ = (crm = &levl[nx][ny])->typ;
if (!IS_STWALL(typ) && !IS_POOL(typ)) {
if (in_fcorridor(grd, nx, ny))
goto nextnxy;
if (*in_rooms(nx, ny, VAULT))
continue;
/* seems we found a good place to leave him alone */
egrd->gddone = 1;
if (ACCESSIBLE(typ))
goto newpos;
crm->typ = (typ == SCORR) ? CORR : DOOR;
if (crm->typ == DOOR)
crm->flags = D_NODOOR;
goto proceed;
}
}
nextnxy: ;
}
}
nextpos: nx = x;
ny = y;
gx = egrd->gdx;
gy = egrd->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) && !IS_POOL(typ) && IS_ROOM(levl[nx+nx-x][ny+ny-y].typ)) {
crm->typ = DOOR;
crm->flags = D_NODOOR;
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 ... */
if (IS_ROOM(typ)) {
crm->typ = DOOR;
crm->flags = D_NODOOR;
goto proceed;
}
break;
}
crm->typ = CORR;
proceed: unblock_point(nx, ny); /* doesn't block light */
if (cansee(nx, ny))
newsym(nx, ny);
fcp = &(egrd->fakecorr[egrd->fcend]);
if (egrd->fcend++ == FCSIZ)
impossible("fakecorr overflow");
fcp->fx = nx;
fcp->fy = ny;
fcp->ftyp = typ;
newpos: if (egrd->gddone) {
/* The following is a kludge. We need to keep */
/* the guard around in order to be able to make */
/* the fake corridor disappear as the player */
/* moves out of it, but we also need the guard */
/* out of the way. We send the guard to never- */
/* never land. We set ogx ogy to mx my in order */
/* to avoid a check at the top of this function. */
/* At the end of the process, the guard is killed */
/* in restfakecorr(). */
cleanup: x = grd->mx;
y = grd->my;
see_guard = canspotmon(grd);
wallify_vault(grd);
remove_monster(grd->mx, grd->my);
newsym(grd->mx, grd->my);
place_monster(grd, 0, 0);
egrd->ogx = grd->mx;
egrd->ogy = grd->my;
restfakecorr(grd);
if (!semi_dead && (in_fcorridor(grd, u.ux, u.uy) || cansee(x, y))) {
if (!disappear_msg_seen && see_guard) {
char name[BUFSZ];
g_monnam(name, BUFSZ, grd);
pline("Suddenly, the %s disappears.", name);
}
return (1);
}
return (-2);
}
egrd->ogx = grd->mx; /* update old positions */
egrd->ogy = grd->my;
remove_monster(grd->mx, grd->my);
place_monster(grd, nx, ny);
newsym(grd->mx, grd->my);
restfakecorr(grd);
return (1);
}
/*
* return 1: guard moved, 0: guard didn't, -1: let m_move do it, -2: died
*/
int
gd_move(struct monst *grd)
{
int x, y, nx, ny, m, n;
int dx, dy, gx = 0, gy = 0, fci;
uchar typ;
struct fakecorridor *fcp;
struct egd *egrd = EGD(grd);
struct rm *crm;
boolean goldincorridor = FALSE, u_in_vault =
vault_occupied(u.urooms) ? TRUE : FALSE, grd_in_vault =
*in_rooms(level, grd->mx, grd->my, VAULT) ? TRUE : FALSE;
boolean disappear_msg_seen = FALSE, semi_dead = (grd->mhp <= 0);
long umoney = money_cnt(invent);
boolean u_carry_gold = ((umoney + hidden_gold()) > 0L);
boolean see_guard;
if (!on_level(&(egrd->gdlevel), &u.uz))
return -1;
nx = ny = m = n = 0;
if (!u_in_vault && !grd_in_vault)
wallify_vault(grd);
if (!grd->mpeaceful) {
if (semi_dead) {
egrd->gddone = 1;
goto newpos;
}
if (!u_in_vault &&
(grd_in_vault ||
(in_fcorridor(grd, grd->mx, grd->my) &&
!in_fcorridor(grd, u.ux, u.uy)))) {
rloc(grd, FALSE);
wallify_vault(grd);
clear_fcorr(grd, TRUE);
goto letknow;
}
if (!in_fcorridor(grd, grd->mx, grd->my))
clear_fcorr(grd, TRUE);
return -1;
}
if (abs(egrd->ogx - grd->mx) > 1 || abs(egrd->ogy - grd->my) > 1)
return -1; /* teleported guard - treat as monster */
if (egrd->fcend == 1) {
if (u_in_vault && (u_carry_gold || um_dist(grd->mx, grd->my, 1))) {
if (egrd->warncnt == 3)
verbalize("I repeat, %sfollow me!",
u_carry_gold ? (!umoney ?
"drop that hidden money and " :
"drop that money and ") : "");
if (egrd->warncnt == 7) {
m = grd->mx;
n = grd->my;
verbalize("You've been warned, knave!");
mnexto(grd);
level->locations[m][n].typ = egrd->fakecorr[0].ftyp;
newsym(m, n);
msethostility(grd, TRUE, FALSE);
return -1;
}
/* not fair to get mad when (s)he's fainted or paralyzed */
if (!u_helpless(hm_all))
egrd->warncnt++;
return 0;
}
if (!u_in_vault) {
if (u_carry_gold) { /* player teleported */
m = grd->mx;
n = grd->my;
rloc(grd, FALSE);
level->locations[m][n].typ = egrd->fakecorr[0].ftyp;
newsym(m, n);
msethostility(grd, TRUE, FALSE);
letknow:
if (!cansee(grd->mx, grd->my) || !mon_visible(grd))
You_hear("the shrill sound of a guard's whistle.");
else
pline(um_dist(grd->mx, grd->my, 2) ?
"You see an angry guard approaching." :
"You are confronted by an angry guard.");
return -1;
} else {
verbalize("Well, begone.");
wallify_vault(grd);
egrd->gddone = 1;
goto cleanup;
}
}
}
if (egrd->fcend > 1) {
if (egrd->fcend > 2 && in_fcorridor(grd, grd->mx, grd->my) &&
!egrd->gddone && !in_fcorridor(grd, u.ux, u.uy) &&
level->locations[egrd->fakecorr[0].fx][egrd->fakecorr[0].fy].typ ==
egrd->fakecorr[0].ftyp) {
if (canseemon(grd)) {
pline("%s, confused, disappears.", Monnam(grd));
disappear_msg_seen = TRUE;
}
goto cleanup;
}
if (u_carry_gold && (in_fcorridor(grd, u.ux, u.uy) ||
/* cover a 'blind' spot */
(egrd->fcend > 1 && u_in_vault))) {
if (!grd->mx) {
restfakecorr(grd);
return -2;
}
if (egrd->warncnt < 6) {
egrd->warncnt = 6;
verbalize("Drop all your gold, scoundrel!");
return 0;
} else {
verbalize("So be it, rogue!");
msethostility(grd, TRUE, FALSE);
return -1;
}
}
}
for (fci = egrd->fcbeg; fci < egrd->fcend; fci++)
if (gold_at(level, egrd->fakecorr[fci].fx, egrd->fakecorr[fci].fy)) {
m = egrd->fakecorr[fci].fx;
n = egrd->fakecorr[fci].fy;
goldincorridor = TRUE;
}
if (goldincorridor && !egrd->gddone) {
boolean yours = FALSE;
x = grd->mx;
y = grd->my;
if (m == u.ux && n == u.uy) {
struct obj *gold = gold_at(level, m, n);
yours = TRUE;
/* Grab the gold from between the hero's feet. */
obj_extract_self(gold);
add_to_minv(grd, gold);
newsym(m, n);
} else if (m == x && n == y) {
mpickgold(grd); /* does a newsym */
} else {
/* just for insurance... */
if (MON_AT(level, m, n) && m != grd->mx && n != grd->my) {
verbalize("Out of my way, scum!");
rloc(m_at(level, m, n), FALSE);
}
remove_monster(level, grd->mx, grd->my);
newsym(grd->mx, grd->my);
place_monster(grd, m, n);
mpickgold(grd); /* does a newsym */
}
if (cansee(m, n)) {
if (yours) {
pline("%s%s picks up the gold.", Monnam(grd),
grd->mpeaceful ? " calms down and" : "");
} else {
pline("%s picks up some gold.", Monnam(grd));
}
}
if (x != grd->mx || y != grd->my) {
remove_monster(level, grd->mx, grd->my);
newsym(grd->mx, grd->my);
place_monster(grd, x, y);
newsym(x, y);
}
if (!grd->mpeaceful)
return -1;
else {
egrd->warncnt = 5;
return 0;
}
}
if (um_dist(grd->mx, grd->my, 1) || egrd->gddone) {
if (!egrd->gddone && !rn2(10))
verbalize("Move along!");
restfakecorr(grd);
return 0; /* didn't move */
}
x = grd->mx;
y = grd->my;
if (u_in_vault)
goto nextpos;
/* 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) && (nx != x || ny != y) && isok(nx, ny)) {
typ = (crm = &level->locations[nx][ny])->typ;
if (!IS_STWALL(typ) && !IS_POOL(typ)) {
if (in_fcorridor(grd, nx, ny))
goto nextnxy;
if (*in_rooms(level, nx, ny, VAULT))
continue;
/* seems we found a good place to leave him alone */
egrd->gddone = 1;
if (ACCESSIBLE(typ))
goto newpos;
crm->typ = (typ == SCORR) ? CORR : DOOR;
if (crm->typ == DOOR)
crm->doormask = D_NODOOR;
goto proceed;
}
}
nextnxy:;
}
nextpos:
nx = x;
ny = y;
gx = egrd->gdx;
gy = egrd->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 = &level->locations[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) && !IS_POOL(typ) &&
IS_ROOM(level->locations[nx + nx - x][ny + ny - y].typ)) {
crm->typ = DOOR;
crm->doormask = D_NODOOR;
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 ... */
if (IS_ROOM(typ)) {
crm->typ = DOOR;
crm->doormask = D_NODOOR;
goto proceed;
}
break;
}
crm->typ = CORR;
proceed:
unblock_point(nx, ny); /* doesn't block light */
if (cansee(nx, ny))
newsym(nx, ny);
if ((nx != gx || ny != gy) || (grd->mx != gx || grd->my != gy)) {
fcp = &(egrd->fakecorr[egrd->fcend]);
if (egrd->fcend++ == FCSIZ)
panic("fakecorr overflow");
fcp->fx = nx;
fcp->fy = ny;
fcp->ftyp = typ;
} else if (!egrd->gddone) {
/* We're stuck, so try to find a new destination. */
if (!find_guard_dest(grd, &egrd->gdx, &egrd->gdy) ||
(egrd->gdx == gx && egrd->gdy == gy)) {
pline("%s, confused, disappears.", Monnam(grd));
disappear_msg_seen = TRUE;
goto cleanup;
} else
goto nextpos;
}
newpos:
if (egrd->gddone) {
/* The following is a kludge. We need to keep the guard around in order
to be able to make the fake corridor disappear as the player moves
out of it, but we also need the guard out of the way. We send the
guard to never-never land. We set ogx ogy to mx my in order to avoid
a check at the top of this function. At the end of the process, the
guard is killed in restfakecorr(). */
cleanup:
x = grd->mx;
y = grd->my;
see_guard = canspotmon(grd);
wallify_vault(grd);
remove_monster(level, grd->mx, grd->my);
newsym(grd->mx, grd->my);
grd->mx = COLNO;
grd->my = ROWNO;
egrd->ogx = grd->mx;
egrd->ogy = grd->my;
restfakecorr(grd);
if (!semi_dead && (in_fcorridor(grd, u.ux, u.uy) || cansee(x, y))) {
if (!disappear_msg_seen && see_guard)
pline("Suddenly, %s disappears.", noit_mon_nam(grd));
return 1;
}
return -2;
}
egrd->ogx = grd->mx; /* update old positions */
egrd->ogy = grd->my;
remove_monster(level, grd->mx, grd->my);
place_monster(grd, nx, ny);
newsym(grd->mx, grd->my);
restfakecorr(grd);
return 1;
}