/*
    util.c  -  all sorts of miscellaneous routines

    XRogue: Expeditions into the Dungeons of Doom
    Copyright (C) 1991 Robert Pietkivitch
    All rights reserved.
    
    Based on "Advanced Rogue"
    Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
    All rights reserved.

    Based on "Rogue: Exploring the Dungeons of Doom"
    Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
    All rights reserved.
    
    See the file LICENSE.TXT for full copyright and licensing information.
*/

#include <curses.h>
#include <ctype.h>
#include <string.h>
#include "rogue.h"

/*
 * this routine computes the players current AC without dex bonus's
 */

int 
ac_compute(ignoremetal)
bool ignoremetal;
{
    register int ac;

    ac = pstats.s_arm; /* base armor of "skin" */
    if (cur_armor) {
        if (!ignoremetal || 
             (cur_armor->o_which != LEATHER             && 
              cur_armor->o_which != STUDDED_LEATHER     && 
              cur_armor->o_which != PADDED_ARMOR))
                ac -= (10 - cur_armor->o_ac);
    }
    if (player.t_ctype == C_MONK)
        ac -= pstats.s_lvl * 3 / 5;
    ac -= ring_value(R_PROTECT);
    if (cur_misc[WEAR_BRACERS] != NULL)
        ac -= cur_misc[WEAR_BRACERS]->o_ac;
    if (cur_misc[WEAR_CLOAK] != NULL)
        ac -= cur_misc[WEAR_CLOAK]->o_ac;

    /* If player has the cloak, must be wearing it */
    if (cur_relic[EMORI_CLOAK]) ac -= 15;

    if (ac > 25)
        ac = 25;
    return(ac);
}

/*
 * aggravate:
 *      aggravate all the monsters on this level
 */

aggravate(do_uniques, do_good)
bool do_uniques, do_good;
{
    register struct linked_list *mi;
    register struct thing *thingptr;

    for (mi = mlist; mi != NULL; mi = next(mi)) {
        thingptr = THINGPTR(mi);
        if (do_good == FALSE && off(*thingptr, ISMEAN)) continue;
        if (do_uniques || off(*thingptr, ISUNIQUE)) runto(thingptr, &hero);
    }
}

/*
 * cansee:
 *      returns true if the hero can see a certain coordinate.
 */

cansee(y, x)
register int y, x;
{
    register struct room *rer;
    register int radius;
    coord tp;

    if (on(player, ISBLIND))
        return FALSE;

    tp.y = y;
    tp.x = x;
    rer = roomin(&tp);

    /* How far can we see? */
    if (levtype == OUTSIDE) {
        if (daytime) radius = 36;
        else if (lit_room(rer)) radius = 9;
        else radius = 3;
    }
    else radius = 3;

    /*
     * We can only see if the hero in the same room as
     * the coordinate and the room is lit or if it is close.
     */
    return ((rer != NULL && 
             levtype != OUTSIDE &&
             (levtype != MAZELEV ||     /* Maze level needs direct line */
              maze_view(tp.y, tp.x)) &&
             rer == roomin(&hero) &&
             lit_room(rer)) ||
            DISTANCE(y, x, hero.y, hero.x) < radius);
}

/*
 * check_level:
 *      Check to see if the guy has gone up a level.
 *
 *      Return points needed to obtain next level.
 *
 * These are certain beginning experience levels for all players.
 * All further experience levels are computed by muliplying by 2
 * up through MAXDOUBLE. Then the cap is added in to compute
 * further levels
 */

long
check_level()
{
    register int i, j, add = 0;
    register unsigned long exp;
    long retval;        /* Return value */
    int nsides;

    pstats.s_lvl -= pstats.s_lvladj; /* correct for level adjustment */
    /* See if we are past the doubling stage */
    exp = char_class[player.t_ctype].cap;
    if (pstats.s_exp >= exp) {
        i = pstats.s_exp/exp;   /* First get amount above doubling area */
        retval = exp + i * exp; /* Compute next higher boundary */
        i += MAXDOUBLE; /* Add in the previous doubled levels */
    }
    else {
        i = 0;
        exp = char_class[player.t_ctype].start_exp;
        while (exp <= pstats.s_exp) {
            i++;
            exp <<= 1;
        }
        retval = exp;
    }
    if (++i > pstats.s_lvl) {
        nsides = char_class[player.t_ctype].hit_pts;
        for (j=0; j<(i-pstats.s_lvl); j++) /* Take care of multi-level jumps */
            add += max(1, roll(1,nsides) + const_bonus());
        max_stats.s_hpt += add;
        if ((pstats.s_hpt += add) > max_stats.s_hpt)
            pstats.s_hpt = max_stats.s_hpt;
        msg("Welcome, %s, to level %d",
            cnames[player.t_ctype][min(i-1, NUM_CNAMES-1)], i);
    }
    pstats.s_lvl = i;
    pstats.s_lvl += pstats.s_lvladj; /* correct for level adjustment */
    return(retval);
}

/*
 * Used to modify the players strength
 * it keeps track of the highest it has been, just in case
 */

chg_str(amt)
register int amt;
{
    register int ring_str;              /* ring strengths */
    register struct stats *ptr;         /* for speed */

    ptr = &pstats;
    ring_str = ring_value(R_ADDSTR);
    ptr->s_str -= ring_str;
    ptr->s_str += amt;
    if (ptr->s_str > MAXATT) ptr->s_str = MAXATT;
    if (ptr->s_str > max_stats.s_str)
        max_stats.s_str = ptr->s_str;
    ptr->s_str += ring_str;
    if (ptr->s_str <= 0) {
    pstats.s_hpt = -1;
        death(D_STRENGTH);
    }
    updpack(TRUE, &player);
}

/*
 * let's confuse the player
 */

confus_player()
{
    if (off(player, ISCLEAR))
    {
        msg("Wait, what's going on here!  Huh? What? Who?");
        if (find_slot(unconfuse))
            lengthen(unconfuse, HUHDURATION);
        else
            fuse(unconfuse, (VOID *)NULL, HUHDURATION, AFTER);
        turn_on(player, ISHUH);
    }
    else msg("You feel dizzy for a moment, but it quickly passes.");
}

/*
 * this routine computes the players current dexterity
 */

dex_compute()
{
    if (cur_misc[WEAR_GAUNTLET] != NULL         &&
        cur_misc[WEAR_GAUNTLET]->o_which == MM_G_DEXTERITY) {
        if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
            return (3);
        else
            return (21);
    }
    else
            return (pstats.s_dext);
}

/*
 * diag_ok:
 *      Check to see if the move is legal if it is diagonal
 */

diag_ok(sp, ep, flgptr)
register coord *sp, *ep;
struct thing *flgptr;
{
    register int numpaths = 0;

    /* Horizontal and vertical moves are always ok */
    if (ep->x == sp->x || ep->y == sp->y)
        return TRUE;

    /* Diagonal moves are not allowed if there is a horizontal or
     * vertical path to the destination
     */
    if (step_ok(ep->y, sp->x, MONSTOK, flgptr)) numpaths++;
    if (step_ok(sp->y, ep->x, MONSTOK, flgptr)) numpaths++;
    return(numpaths != 1);
}

/*
 * pick a random position around the give (y, x) coordinates
 */

coord *
fallpos(pos, be_clear, range)
register coord *pos;
bool be_clear;
int range;
{
        register int tried, i, j;
        register char ch;
        static coord ret;
        static short masks[] = {
                0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100 };

/*
 * Pick a spot at random centered on the position given by 'pos' and
 * up to 'range' squares away from 'pos'
 *
 * If 'be_clear' is TRUE, the spot must be either FLOOR or PASSAGE
 * inorder to be considered valid
 *
 * Generate a number from 0 to 8, representing the position to pick.
 * Note that this DOES include the positon 'pos' itself
 *
 * If this position is not valid, mark it as 'tried', and pick another.
 * Whenever a position is picked that has been tried before,
 * sequentially find the next untried position. This eliminates costly
 * random number generation
 */

        tried = 0;
        while( tried != 0x1ff ) {
                i = rnd(9);
                while( tried & masks[i] )
                        i = (i + 1) % 9;

                tried |= masks[i];

                for( j = 1; j <= range; j++ ) {
                        ret.x = pos->x + j*grid[i].x;
                        ret.y = pos->y + j*grid[i].y;

                        if (ret.x == hero.x && ret.y == hero.y)
                                continue; /* skip the hero */

                        if (ret.x < 0 || ret.x > cols - 1 ||
                            ret.y < 1 || ret.y > lines - 3)
                                continue; /* off the screen? */

                        ch = winat(ret.y, ret.x);

                        /*
                         * Check to make certain the spot is valid
                         */
                        switch( ch ) {
                        case FLOOR:
                        case PASSAGE:
                                return( &ret );
                        case GOLD:
                        case SCROLL:
                        case POTION:
                        case STICK:
                        case RING:
                        case WEAPON:
                        case ARMOR:
                        case MM:
                        case FOOD:
                                if(!be_clear && levtype != POSTLEV)
                                        return( &ret );
                        default:
                                break;
                        }
                }
        }
        return( NULL );
}

/*
 * findmindex:
 *      Find the index into the monster table of a monster given its name.
 */

findmindex(name)
char *name;
{
    int which;

    for (which=1; which<NUMMONST; which++) {
         if (strcmp(name, monsters[which].m_name) == 0)
             break;
    }
    if (which >= NUMMONST) {
         debug("couldn't find monster index");
         which = 1;
    }
    return(which);
}

/*
 * find_mons:
 *      Find the monster from his coordinates
 */

struct linked_list *
find_mons(y, x)
register int y;
register int x;
{
    register struct linked_list *item;
    register struct thing *th;

    for (item = mlist; item != NULL; item = next(item))
    {
        th = THINGPTR(item);
        if (th->t_pos.y == y && th->t_pos.x == x)
            return item;
    }
    return NULL;
}

/*
 * find_obj:
 *      find the unclaimed object at y, x
 */

struct linked_list *
find_obj(y, x)
register int y;
register int x;
{
    register struct linked_list *obj;
    register struct object *op;

    for (obj = lvl_obj; obj != NULL; obj = next(obj))
    {
        op = OBJPTR(obj);
        if (op->o_pos.y == y && op->o_pos.x == x)
                return obj;
    }
    return NULL;
}

/*
 * get coordinates from the player using the cursor keys (or mouse)
 */

coord 
get_coordinates()
{
    register int which;
    coord c;

    c = hero;
    wmove(cw, hero.y, hero.x);
    draw(cw);
    for (;;) {
        which = (wgetch(cw) & 0177);
        switch(which) {