/*      $NetBSD: hack.c,v 1.12 2021/05/02 12:50:44 rillig 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.c,v 1.12 2021/05/02 12:50:44 rillig Exp $");
#endif                          /* not lint */

#include "hack.h"
#include "extern.h"

static void movobj(struct obj *, int, int);
static int inv_cnt(void);

/*
 * called on movement: 1. when throwing ball+chain far away 2. when
 * teleporting 3. when walking out of a lit room
 */
void
unsee(void)
{
        int x, y;
        struct rm *lev;

        /*
                if(u.udispl){
                        u.udispl = 0;
                        newsym(u.udisx, u.udisy);
                }
        */
#ifndef QUEST
        if (seehx) {
                seehx = 0;
        } else
#endif  /* QUEST */
                for (x = u.ux - 1; x < u.ux + 2; x++)
                        for (y = u.uy - 1; y < u.uy + 2; y++) {
                                if (!isok(x, y))
                                        continue;
                                lev = &levl[x][y];
                                if (!lev->lit && lev->scrsym == '.') {
                                        lev->scrsym = ' ';
                                        lev->new = 1;
                                        on_scr(x, y);
                                }
                        }
}

/*
 * called: in hack.eat.c: seeoff(0) - blind after eating rotten food in
 * hack.mon.c: seeoff(0) - blinded by a yellow light in hack.mon.c: seeoff(1)
 * - swallowed in hack.do.c:  seeoff(0) - blind after drinking potion in
 * hack.do.c:  seeoff(1) - go up or down the stairs in hack.trap.c:seeoff(1)
 * - fall through trapdoor
 */
/* mode: */
        /* 1 to redo @, 0 to leave them *//* 1 means
         * misc movement, 0 means blindness */
void
seeoff(int mode)
{
        int x, y;
        struct rm *lev;

        if (u.udispl && mode) {
                u.udispl = 0;
                levl[u.udisx][u.udisy].scrsym = news0(u.udisx, u.udisy);
        }
#ifndef QUEST
        if (seehx) {
                seehx = 0;
        } else
#endif  /* QUEST */
        if (!mode) {
                for (x = u.ux - 1; x < u.ux + 2; x++)
                        for (y = u.uy - 1; y < u.uy + 2; y++) {
                                if (!isok(x, y))
                                        continue;
                                lev = &levl[x][y];
                                if (!lev->lit && lev->scrsym == '.')
                                        lev->seen = 0;
                        }
        }
}

void
domove(void)
{
        xchar           oldx, oldy;
        struct monst *mtmp = NULL;
        struct rm *tmpr, *ust;
        struct trap    *trap = NULL;
        struct obj *otmp = NULL;

        u_wipe_engr(rnd(5));

        if (inv_weight() > 0) {
                pline("You collapse under your load.");
                nomul(0);
                return;
        }
        if (u.uswallow) {
                u.dx = u.dy = 0;
                u.ux = u.ustuck->mx;
                u.uy = u.ustuck->my;
        } else {
                if (Confusion) {
                        do {
                                confdir();
                        } while (!isok(u.ux + u.dx, u.uy + u.dy) ||
                               IS_ROCK(levl[u.ux + u.dx][u.uy + u.dy].typ));
                }
                if (!isok(u.ux + u.dx, u.uy + u.dy)) {
                        nomul(0);
                        return;
                }
        }

        ust = &levl[u.ux][u.uy];
        oldx = u.ux;
        oldy = u.uy;
        if (!u.uswallow && (trap = t_at(u.ux + u.dx, u.uy + u.dy)) && trap->tseen)
                nomul(0);
        if (u.ustuck && !u.uswallow && (u.ux + u.dx != u.ustuck->mx ||
                                        u.uy + u.dy != u.ustuck->my)) {
                if (dist(u.ustuck->mx, u.ustuck->my) > 2) {
                        /* perhaps it fled (or was teleported or ... ) */
                        u.ustuck = 0;
                } else {
                        if (Blind)
                                pline("You cannot escape from it!");
                        else
                                pline("You cannot escape from %s!",
                                      monnam(u.ustuck));
                        nomul(0);
                        return;
                }
        }
        if (u.uswallow || (mtmp = m_at(u.ux + u.dx, u.uy + u.dy))) {
                /* attack monster */

                nomul(0);
                gethungry();
                if (multi < 0)
                        return; /* we just fainted */

                /* try to attack; note that it might evade */
                if (attack(u.uswallow ? u.ustuck : mtmp))
                        return;
        }
        /* not attacking an animal, so we try to move */
        if (u.utrap) {
                if (u.utraptype == TT_PIT) {
                        pline("You are still in a pit.");
                        u.utrap--;
                } else {
                        pline("You are caught in a beartrap.");
                        if ((u.dx && u.dy) || !rn2(5))
                                u.utrap--;
                }
                return;
        }
        tmpr = &levl[u.ux + u.dx][u.uy + u.dy];
        if (IS_ROCK(tmpr->typ) ||
            (u.dx && u.dy && (tmpr->typ == DOOR || ust->typ == DOOR))) {
                flags.move = 0;
                nomul(0);
                return;
        }
        while ((otmp = sobj_at(ENORMOUS_ROCK, u.ux + u.dx, u.uy + u.dy)) != NULL){
                xchar  rx = u.ux + 2 * u.dx, ry = u.uy + 2 * u.dy;
                struct trap *ttmp;
                nomul(0);
                if (isok(rx, ry) && !IS_ROCK(levl[rx][ry].typ) &&
                    (levl[rx][ry].typ != DOOR || !(u.dx && u.dy)) &&
                    !sobj_at(ENORMOUS_ROCK, rx, ry)) {
                        if (m_at(rx, ry)) {
                                pline("You hear a monster behind the rock.");
                                pline("Perhaps that's why you cannot move it.");
                                goto cannot_push;
                        }
                        if ((ttmp = t_at(rx, ry)) != NULL)
                                switch (ttmp->ttyp) {
                                case PIT:
                                        pline("You push the rock into a pit!");
                                        deltrap(ttmp);
                                        delobj(otmp);
                                        pline("It completely fills the pit!");
                                        continue;
                                case TELEP_TRAP:
                                        pline("You push the rock and suddenly it disappears!");
                                        delobj(otmp);
                                        continue;
                                }
                        if (levl[rx][ry].typ == POOL) {
                                levl[rx][ry].typ = ROOM;
                                mnewsym(rx, ry);
                                prl(rx, ry);
                                pline("You push the rock into the water.");
                                pline("Now you can cross the water!");
                                delobj(otmp);
                                continue;
                        }
                        otmp->ox = rx;
                        otmp->oy = ry;
                        /* pobj(otmp); */
                        if (cansee(rx, ry))
                                atl(rx, ry, otmp->olet);
                        if (Invisible)
                                newsym(u.ux + u.dx, u.uy + u.dy);

                        {
                                static long     lastmovetime;
                                /*
                                 * note: this var contains garbage initially
                                 * and after a restore
                                 */
                                if (moves > lastmovetime + 2 || moves < lastmovetime)
                                        pline("With great effort you move the enormous rock.");
                                lastmovetime = moves;
                        }
                } else {
                        pline("You try to move the enormous rock, but in vain.");
        cannot_push:
                        if ((!invent || inv_weight() + 90 <= 0) &&
                            (!u.dx || !u.dy || (IS_ROCK(levl[u.ux][u.uy + u.dy].typ)
                                && IS_ROCK(levl[u.ux + u.dx][u.uy].typ)))) {
                                pline("However, you can squeeze yourself into a small opening.");
                                break;
                        } else
                                return;
                }
        }
        if (u.dx && u.dy && IS_ROCK(levl[u.ux][u.uy + u.dy].typ) &&
            IS_ROCK(levl[u.ux + u.dx][u.uy].typ) &&
            invent && inv_weight() + 40 > 0) {
                pline("You are carrying too much to get through.");
                nomul(0);
                return;
        }
        if (Punished &&
            DIST(u.ux + u.dx, u.uy + u.dy, uchain->ox, uchain->oy) > 2) {
                if (carried(uball)) {
                        movobj(uchain, u.ux, u.uy);
                        goto nodrag;
                }
                if (DIST(u.ux + u.dx, u.uy + u.dy, uball->ox, uball->oy) < 3) {
                        /* leave ball, move chain under/over ball */
                        movobj(uchain, uball->ox, uball->oy);
                        goto nodrag;
                }
                if (inv_weight() + (int) uball->owt / 2 > 0) {
                        pline("You cannot %sdrag the heavy iron ball.",
                              invent ? "carry all that and also " : "");
                        nomul(0);
                        return;
                }
                movobj(uball, uchain->ox, uchain->oy);
                unpobj(uball);  /* BAH %% */
                uchain->ox = u.ux;
                uchain->oy = u.uy;
                nomul(-2);
                nomovemsg = "";
nodrag: ;
        }
        u.ux += u.dx;
        u.uy += u.dy;
        if (flags.run) {
                if (tmpr->typ == DOOR ||
                    (xupstair == u.ux && yupstair == u.uy) ||
                    (xdnstair == u.ux && ydnstair == u.uy))
                        nomul(0);
        }
        if (tmpr->typ == POOL && !Levitation)
                drown();        /* not necessarily fatal */

        /*
                if(u.udispl) {
                        u.udispl = 0;
                        newsym(oldx,oldy);
                }
        */
        if (!Blind) {
#ifdef QUEST
                setsee();
#else
                if (ust->lit) {
                        if (tmpr->lit) {
                                if (tmpr->typ == DOOR)
                                        prl1(u.ux + u.dx, u.uy + u.dy);
                                else if (ust->typ == DOOR)
                                        nose1(oldx - u.dx, oldy - u.dy);
                        } else {
                                unsee();
                                prl1(u.ux + u.dx, u.uy + u.dy);
                        }
                } else {
                        if (tmpr->lit)
                                setsee();
                        else {
                                prl1(u.ux + u.dx, u.uy + u.dy);
                                if (tmpr->typ == DOOR) {
                                        if (u.dy) {
                                                prl(u.ux - 1, u.uy);
                                                prl(u.ux + 1, u.uy);
                                        } else {
                                                prl(u.ux, u.uy - 1);
                                                prl(u.ux, u.uy + 1);
                                        }
                                }
                        }
                        nose1(oldx - u.dx, oldy - u.dy);
                }
#endif  /* QUEST */
        } else {
                pru();
        }
        if (!flags.nopick)
                pickup(1);
        if (trap)
                dotrap(trap);   /* fall into pit, arrow trap, etc. */
        (void) inshop();
        if (!Blind)
                read_engr_at(u.ux, u.uy);
}

static void
movobj(struct obj *obj, int ox, int oy)
{
        /* Some dirty programming to get display right */
        freeobj(obj);
        unpobj(obj);
        obj->nobj = fobj;
        fobj = obj;
        obj->ox = ox;
        obj->oy = oy;
}

int
dopickup(void)
{
        if (!g_at(u.ux, u.uy) && !o_at(u.ux, u.uy)) {
                pline("There is nothing here to pick up.");
                return (0);
        }
        if (Levitation) {
                pline("You cannot reach the floor.");
                return (1);
        }
        pickup(0);
        return (1);
}

void
pickup(int all)
{
        struct gold *gold;
        struct obj *obj, *obj2;
        int    wt;

        if (Levitation)
                return;
        while ((gold = g_at(u.ux, u.uy)) != NULL) {
                pline("%ld gold piece%s.", gold->amount, plur(gold->amount));
                u.ugold += gold->amount;
                flags.botl = 1;
                freegold(gold);
                if (flags.run)
                        nomul(0);
                if (Invisible)
                        newsym(u.ux, u.uy);
        }

        /* check for more than one object */
        if (!all) {
                int    ct = 0;

                for (obj = fobj; obj; obj = obj->nobj)
                        if (obj->ox == u.ux && obj->oy == u.uy)
                                if (!Punished || obj != uchain)
                                        ct++;
                if (ct < 2)
                        all++;
                else
                        pline("There are several objects here.");
        }
        for (obj = fobj; obj; obj = obj2) {
                obj2 = obj->nobj;       /* perhaps obj will be picked up */
                if (obj->ox == u.ux && obj->oy == u.uy) {
                        if (flags.run)
                                nomul(0);

                        /* do not pick up uchain */
                        if (Punished && obj == uchain)
                                continue;

                        if (!all) {
                                char            c;

                                pline("Pick up %s ? [ynaq]", doname(obj));
                                while (!strchr("ynaq ", (c = readchar())))
                                        sound_bell();
                                if (c == 'q')
                                        return;
                                if (c == 'n')
                                        continue;
                                if (c == 'a')
                                        all = 1;
                        }
                        if (obj->otyp == DEAD_COCKATRICE && !uarmg) {
                                pline("Touching the dead cockatrice is a fatal mistake.");
                                pline("You turn to stone.");
                                killer = "cockatrice cadaver";
                                done("died");
                        }
                        if (obj->otyp == SCR_SCARE_MONSTER) {
                                if (!obj->spe)
                                        obj->spe = 1;
                                else {
                                        /*
                                         * Note: perhaps the 1st pickup
                                         * failed: you cannot carry anymore,
                                         * and so we never dropped it - let's
                                         * assume that treading on it twice
                                         * also destroys the scroll
                                         */
                                        pline("The scroll turns to dust as you pick it up.");
                                        delobj(obj);
                                        continue;
                                }
                        }
                        wt = inv_weight() + obj->owt;
                        if (wt > 0) {
                                if (obj->quan > 1) {
                                        /* see how many we can lift */
                                        int             savequan = obj->quan;
                                        int             iw = inv_weight();
                                        int             qq;
                                        for (qq = 1; qq < savequan; qq++) {
                                                obj->quan = qq;
                                                if (iw + weight(obj) > 0)
                                                        break;
                                        }
                                        obj->quan = savequan;
                                        qq--;
                                        /* we can carry qq of them */
                                        if (!qq)
                                                goto too_heavy;
                                        pline("You can only carry %s of the %s lying here.",
                                              (qq == 1) ? "one" : "some",
                                              doname(obj));
                                        (void) splitobj(obj, qq);
                                        /*
                                         * note: obj2 is set already, so
                                         * we'll never encounter the other
                                         * half; if it should be otherwise
                                         * then write obj2 =
                                         * splitobj(obj,qq);
                                         */
                                        goto lift_some;
                                }
                too_heavy:
                                pline("There %s %s here, but %s.",
                                      (obj->quan == 1) ? "is" : "are",
                                      doname(obj),
                                 !invent ? "it is too heavy for you to lift"
                                      : "you cannot carry anymore");
                                break;
                        }
        lift_some:
                        if (inv_cnt() >= 52) {
                                pline("Your knapsack cannot accommodate anymore items.");
                                break;
                        }
                        if (wt > -5)
                                pline("You have a little trouble lifting");
                        freeobj(obj);
                        if (Invisible)
                                newsym(u.ux, u.uy);
                        addtobill(obj); /* sets obj->unpaid if necessary */
                        {
                                int             pickquan = obj->quan;
                                int             mergquan;
                                if (!Blind)
                                        obj->dknown = 1;        /* this is done by
                                                                 * prinv(), but addinv()
                                                                 * needs it already for
                                                                 * merging */
                                obj = addinv(obj);      /* might merge it with
                                                         * other objects */
                                mergquan = obj->quan;
                                obj->quan = pickquan;   /* to fool prinv() */
                                prinv(obj);
                                obj->quan = mergquan;
                        }
                }
        }
}

/* stop running if we see something interesting */
/* turn around a corner if that is the only way we can proceed */
/* do not turn left or right twice */
void
lookaround(void)
{
        int    x, y, i, x0 = 0, y0 = 0, m0 = 0, i0 = 9;
        int    corrct = 0, noturn = 0;
        struct monst *mtmp;
        if (Blind || flags.run == 0)
                return;
        if (flags.run == 1 && levl[u.ux][u.uy].typ == ROOM)
                return;
#ifdef QUEST
        if (u.ux0 == u.ux + u.dx && u.uy0 == u.uy + u.dy)
                goto stop;
#endif  /* QUEST */
        for (x = u.ux - 1; x <= u.ux + 1; x++)
                for (y = u.uy - 1; y <= u.uy + 1; y++) {
                        if (x == u.ux && y == u.uy)
                                continue;
                        if (!levl[x][y].typ)
                                continue;
                        if ((mtmp = m_at(x, y)) && !mtmp->mimic &&
                            (!mtmp->minvis || See_invisible)) {
                                if (!mtmp->mtame || (x == u.ux + u.dx && y == u.uy + u.dy))
                                        goto stop;
                        } else
                                mtmp = 0;       /* invisible M cannot
                                                 * influence us */
                        if (x == u.ux - u.dx && y == u.uy - u.dy)
                                continue;
                        switch (levl[x][y].scrsym) {
                        case '|':
                        case '-':
                        case '.':
                        case ' ':
                                break;
                        case '+':
                                if (x != u.ux && y != u.uy)
                                        break;
                                if (flags.run != 1)
                                        goto stop;
                                /* FALLTHROUGH */
                        case CORR_SYM:
                corr:
                                if (flags.run == 1 || flags.run == 3) {
                                        i = DIST(x, y, u.ux + u.dx, u.uy + u.dy);
                                        if (i > 2)
                                                break;
                                        if (corrct == 1 && DIST(x, y, x0, y0) != 1)
                                                noturn = 1;
                                        if (i < i0) {
                                                i0 = i;
                                                x0 = x;
                                                y0 = y;
                                                m0 = mtmp ? 1 : 0;
                                        }
                                }
                                corrct++;
                                break;
                        case '^':
                                if (flags.run == 1)
                                        goto corr;      /* if you must */
                                if (x == u.ux + u.dx && y == u.uy + u.dy)
                                        goto stop;
                                break;
                        default:        /* e.g. objects or trap or stairs */
                                if (flags.run == 1)
                                        goto corr;
                                if (mtmp)
                                        break;  /* d */
                stop:
                                nomul(0);
                                return;
                        }
                }
#ifdef QUEST
        if (corrct > 0 && (flags.run == 4 || flags.run == 5))
                goto stop;
#endif  /* QUEST */
        if (corrct > 1 && flags.run == 2)
                goto stop;
        if ((flags.run == 1 || flags.run == 3) && !noturn && !m0 && i0 &&
            (corrct == 1 || (corrct == 2 && i0 == 1))) {
                /* make sure that we do not turn too far */
                if (i0 == 2) {
                        if (u.dx == y0 - u.uy && u.dy == u.ux - x0)
                                i = 2;  /* straight turn right */
                        else
                                i = -2; /* straight turn left */
                } else if (u.dx && u.dy) {
                        if ((u.dx == u.dy && y0 == u.uy) ||
                            (u.dx != u.dy && y0 != u.uy))
                                i = -1; /* half turn left */
                        else
                                i = 1;  /* half turn right */
                } else {
                        if ((x0 - u.ux == y0 - u.uy && !u.dy) ||
                            (x0 - u.ux != y0 - u.uy && u.dy))
                                i = 1;  /* half turn right */
                        else
                                i = -1; /* half turn left */
                }
                i += u.last_str_turn;
                if (i <= 2 && i >= -2) {
                        u.last_str_turn = i;
                        u.dx = x0 - u.ux, u.dy = y0 - u.uy;
                }
        }
}

/* something like lookaround, but we are not running */
/* react only to monsters that might hit us */
int
monster_nearby(void)
{
        int    x, y;
        struct monst *mtmp;
        if (!Blind)
                for (x = u.ux - 1; x <= u.ux + 1; x++)
                        for (y = u.uy - 1; y <= u.uy + 1; y++) {
                                if (x == u.ux && y == u.uy)
                                        continue;
                                if ((mtmp = m_at(x, y)) && !mtmp->mimic && !mtmp->mtame &&
                                    !mtmp->mpeaceful && !strchr("Ea", mtmp->data->mlet) &&
                                    !mtmp->mfroz && !mtmp->msleep &&    /* aplvax!jcn */
                                    (!mtmp->minvis || See_invisible))
                                        return (1);
                        }
        return (0);
}

#ifdef QUEST
int
cansee(xchar x, xchar y)
{
        int    dx, dy, adx, ady, sdx, sdy, dmax, d;
        if (Blind)
                return (0);
        if (!isok(x, y))
                return (0);
        d = dist(x, y);
        if (d < 3)
                return (1);
        if (d > u.uhorizon * u.uhorizon)
                return (0);
        if (!levl[x][y].lit)
                return (0);
        dx = x - u.ux;
        adx = abs(dx);
        sdx = sgn(dx);
        dy = y - u.uy;
        ady = abs(dy);
        sdy = sgn(dy);
        if (dx == 0 || dy == 0 || adx == ady) {
                dmax = (dx == 0) ? ady : adx;
                for (d = 1; d <= dmax; d++)
                        if (!rroom(sdx * d, sdy * d))
                                return (0);
                return (1);
        } else if (ady > adx) {
                for (d = 1; d <= ady; d++) {
                        if (!rroom(sdx * ((d * adx) / ady), sdy * d) ||
                            !rroom(sdx * ((d * adx - 1) / ady + 1), sdy * d))
                                return (0);
                }
                return (1);
        } else {
                for (d = 1; d <= adx; d++) {
                        if (!rroom(sdx * d, sdy * ((d * ady) / adx)) ||
                            !rroom(sdx * d, sdy * ((d * ady - 1) / adx + 1)))
                                return (0);
                }
                return (1);
        }
}

int
rroom(int x, int y)
{
        return (IS_ROOM(levl[u.ux + x][u.uy + y].typ));
}

#else

int
cansee(xchar x, xchar y)
{
        if (Blind || u.uswallow)
                return (0);
        if (dist(x, y) < 3)
                return (1);
        if (levl[x][y].lit && seelx <= x && x <= seehx && seely <= y &&
            y <= seehy)
                return (1);
        return (0);
}
#endif  /* QUEST */

int
sgn(int a)
{
        return ((a > 0) ? 1 : (a == 0) ? 0 : -1);
}

#ifdef QUEST
void
setsee(void)
{
        int     x, y;

        if (Blind) {
                pru();
                return;
        }
        for (y = u.uy - u.uhorizon; y <= u.uy + u.uhorizon; y++)
                for (x = u.ux - u.uhorizon; x <= u.ux + u.uhorizon; x++) {
                        if (cansee(x, y))
                                prl(x, y);
                }
}

#else

void
setsee(void)
{
        int x, y;

        if (Blind) {
                pru();
                return;
        }
        if (!levl[u.ux][u.uy].lit) {
                seelx = u.ux - 1;
                seehx = u.ux + 1;
                seely = u.uy - 1;
                seehy = u.uy + 1;
        } else {
                for (seelx = u.ux; levl[seelx - 1][u.uy].lit; seelx--);
                for (seehx = u.ux; levl[seehx + 1][u.uy].lit; seehx++);
                for (seely = u.uy; levl[u.ux][seely - 1].lit; seely--);
                for (seehy = u.uy; levl[u.ux][seehy + 1].lit; seehy++);
        }
        for (y = seely; y <= seehy; y++)
                for (x = seelx; x <= seehx; x++) {
                        prl(x, y);
                }
        if (!levl[u.ux][u.uy].lit)
                seehx = 0;      /* seems necessary elsewhere */
        else {
                if (seely == u.uy)
                        for (x = u.ux - 1; x <= u.ux + 1; x++)
                                prl(x, seely - 1);
                if (seehy == u.uy)
                        for (x = u.ux - 1; x <= u.ux + 1; x++)
                                prl(x, seehy + 1);
                if (seelx == u.ux)
                        for (y = u.uy - 1; y <= u.uy + 1; y++)
                                prl(seelx - 1, y);
                if (seehx == u.ux)
                        for (y = u.uy - 1; y <= u.uy + 1; y++)
                                prl(seehx + 1, y);
        }
}
#endif  /* QUEST */

void
nomul(int nval)
{
        if (multi < 0)
                return;
        multi = nval;
        flags.mv = flags.run = 0;
}

int
abon(void)
{
        if (u.ustr == 3)
                return (-3);
        else if (u.ustr < 6)
                return (-2);
        else if (u.ustr < 8)
                return (-1);
        else if (u.ustr < 17)
                return (0);
        else if (u.ustr < 69)
                return (1);     /* up to 18/50 */
        else if (u.ustr < 118)
                return (2);
        else
                return (3);
}

int
dbon(void)
{
        if (u.ustr < 6)
                return (-1);
        else if (u.ustr < 16)
                return (0);
        else if (u.ustr < 18)
                return (1);
        else if (u.ustr == 18)
                return (2);     /* up to 18 */
        else if (u.ustr < 94)
                return (3);     /* up to 18/75 */
        else if (u.ustr < 109)
                return (4);     /* up to 18/90 */
        else if (u.ustr < 118)
                return (5);     /* up to 18/99 */
        else
                return (6);
}

/* may kill you; cause may be poison or */
/* monster like 'A' */
void
losestr(int num)
{
        u.ustr -= num;
        while (u.ustr < 3) {
                u.ustr++;
                u.uhp -= 6;
                u.uhpmax -= 6;
        }
        flags.botl = 1;
}

void
losehp(int n, const char *knam)
{
        u.uhp -= n;
        if (u.uhp > u.uhpmax)
                u.uhpmax = u.uhp;       /* perhaps n was negative */
        flags.botl = 1;
        if (u.uhp < 1) {
                killer = knam;  /* the thing that killed you */
                done("died");
        }
}

void
losehp_m(int n, struct monst *mtmp)
{
        u.uhp -= n;
        flags.botl = 1;
        if (u.uhp < 1)
                done_in_by(mtmp);
}

void
losexp(void)
{                               /* hit by V or W */
        int num;

        if (u.ulevel > 1)
                pline("Goodbye level %u.", u.ulevel--);
        else
                u.uhp = -1;
        num = rnd(10);
        u.uhp -= num;
        u.uhpmax -= num;
        u.uexp = newuexp();
        flags.botl = 1;
}

int
inv_weight(void)
{
        struct obj *otmp = invent;
        int    wt = (u.ugold + 500) / 1000;
        int    carrcap;
        if (Levitation)         /* pugh@cornell */
                carrcap = MAX_CARR_CAP;
        else {
                carrcap = 5 * (((u.ustr > 18) ? 20 : u.ustr) + u.ulevel);
                if (carrcap > MAX_CARR_CAP)
                        carrcap = MAX_CARR_CAP;
                if (Wounded_legs & LEFT_SIDE)
                        carrcap -= 10;
                if (Wounded_legs & RIGHT_SIDE)
                        carrcap -= 10;
        }
        while (otmp) {
                wt += otmp->owt;
                otmp = otmp->nobj;
        }
        return (wt - carrcap);
}

static int
inv_cnt(void)
{
        struct obj *otmp = invent;
        int    ct = 0;
        while (otmp) {
                ct++;
                otmp = otmp->nobj;
        }
        return (ct);
}

long
newuexp(void)
{
        return (10 * (1L << (u.ulevel - 1)));
}