/*
    fight.c - All the fighting gets done here
 
    UltraRogue: The Ultimate Adventure in the Dungeons of Doom
    Copyright (C) 1985, 1986, 1992, 1993, 1995 Herb Chong
    All rights reserved.

    Based on "Advanced Rogue"
    Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka
    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 <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "rogue.h"

/*
 * This are the beginning experience levels for all players all further
 * experience levels are computed by multiplying by 2
 */

static long e_levels[10] =
{
    143L,           /* Fighter     */
    182L,           /* Paladin     */
    169L,           /* Ranger      */
    127L,           /* Cleric      */
    154L,           /* Druid       */
    185L,           /* Magician    */
    169L,           /* Illusionist */
    112L,           /* Thief       */
    126L,           /* Assasin     */
    319L            /* Ninja       */
};

static struct matrix att_mat[11] =
{
    /* Base, Max_lvl, Factor, Offset, Range */

    {  10,     17,      2,      1,      2     },  /* fi */
    {  10,     17,      2,      1,      2     },  /* pa */
    {  10,     17,      2,      1,      2     },  /* ra */
    {  10,     19,      2,      1,      3     },  /* cl */
    {  10,     19,      2,      1,      3     },  /* dr */
    {   9,     21,      2,      1,      5     },  /* mu */
    {   9,     21,      2,      1,      5     },  /* il */
    {  10,     21,      2,      1,      4     },  /* th */
    {  10,     21,      2,      1,      4     },  /* as */
    {  10,     21,      2,      1,      4     },  /* nj */
    {   7,     25,      1,      0,      2     }   /* mn */
};

void
do_fight(coord dir, int tothedeath)
{
    int x,y;

    x = dir.x;
    y = dir.y;

    if (!tothedeath && pstats.s_hpt < max_stats.s_hpt / 3)
    {
        msg("That's not wise.");

        after = fighting = FALSE;
        return;
    }

    if (isalpha(CCHAR(winat(hero.y + y, hero.x + x))))
    {
        after = fighting = TRUE;
        do_move(y, x);
    }
    else
    {
        if (fighting == FALSE)
            msg("Nothing there.");

        after = fighting = FALSE;
    }

    return;
}

/*
    fight()
        The player attacks the monster.
*/

int
fight(coord *mp, struct object *weap, int thrown)
{
    struct thing    *tp;
    struct linked_list  *item;
    int    did_hit = TRUE;
    char    *mname;

    /* Find the monster we want to fight */

    if ((item = find_mons(mp->y, mp->x)) == NULL)
    {
        debug("Fight what @ %d,%d", mp->y, mp->x);
        return 0;
    }

    tp = THINGPTR(item);

    mname = (on(player, ISBLIND)) ? "it" : monsters[tp->t_index].m_name;

    /* Since we are fighting, things are not quiet so no healing takes place */

    player.t_rest_hpt = player.t_rest_pow = 0;
    tp->t_rest_hpt = tp->t_rest_pow = 0;

    /*  Let him know it was really a mimic (if it was one). */

    if (off(player, ISBLIND))
    {
        if (on(*tp, ISDISGUISE) && (tp->t_type != tp->t_disguise))
        {
            msg("Wait! That's a %s!", mname);
            turn_off(*tp, ISDISGUISE);
            did_hit = thrown;
        }

        if (on(*tp, CANSURPRISE))
        {
            turn_off(*tp, CANSURPRISE);
            if ((player.t_ctype == C_RANGER && rnd(6) != 0) ||
                (player.t_ctype == C_NINJA && rnd(pstats.s_lvl / 2)
                 != 0))
                msg("You notice a %s trying to hide!", mname);
            else
            {
                msg("Wait! There's a %s!", mname);
                did_hit = thrown;
            }
        }
    }

    /* Protection from Normal Missiles */

    if (thrown && on(*tp, HASMSHIELD))
    {
        msg("The %s slows as it approaches %s.",
            weaps[weap->o_which].w_name, mname);

        did_hit = FALSE;
    }

    if (did_hit)
    {
        did_hit = FALSE;

        if (!can_blink(tp) &&
            (off(*tp, MAGICHIT) || (weap != NULL &&
                   (weap->o_hplus > 0 || weap->o_dplus > 0))) &&
            (off(*tp, BMAGICHIT) || (weap != NULL &&
                   (weap->o_hplus > 2 || weap->o_dplus > 2))) &&
            roll_em(&player, tp, weap, thrown, cur_weapon))
        {
            did_hit = TRUE;
            tp->t_wasshot = TRUE;

            if (thrown)
            {
                if (weap != NULL && weap->o_type == WEAPON
                    && weap->o_which == GRENADE)
                {
                    hearmsg("BOOOM!");
                    aggravate();
                }

                thunk(weap, mname);
            }
            else
                hit(mname);

            /* hitting a friendly monster is curtains */

            if (on(*tp, ISFRIENDLY))
            {
                turn_off(*tp, ISFRIENDLY);
                turn_on(*tp, ISMEAN);
            }

            /* Charmed monsters become uncharmed */

            if (on(*tp, ISCHARMED))
            {
                turn_off(*tp, ISCHARMED);
                turn_on(*tp, ISMEAN);
            }

            /*
             * If the player hit a rust monster, he better have a
             * + weapon
            */

            if (on(*tp, CANRUST))
            {
                if (!thrown && (weap != NULL) &&
                    (weap->o_flags & ISMETAL) &&
                    !(weap->o_flags & ISPROT) &&
                    !(weap->o_flags & ISSILVER) &&
                (weap->o_hplus < 1) && (weap->o_dplus < 1))
                {
                    if (rnd(100) < 50)
                        weap->o_hplus--;
                    else
                        weap->o_dplus--;

                    msg("Your %s weakens!", weaps[weap->o_which].w_name);
                }
                else if (!thrown && weap != NULL && (weap->o_flags & ISMETAL))
                    msg("The rust vanishes from your %s!",
                        weaps[weap->o_which].w_name);
            }

            /* flammable monsters die from burning weapons */

            if (thrown && on(*tp, CANBBURN) &&
                (weap->o_flags & CANBURN) &&
                !save_throw(VS_WAND, tp))
            {
                msg("The %s vanishes in a ball of flame.",
                    monsters[tp->t_index].m_name);

                tp->t_stats.s_hpt = 0;
            }

            /* spores explode and infest hero  */

            if (on(*tp, CANSPORE))
            {
                msg("The %s explodes in a cloud of dust.",
                    monsters[tp->t_index].m_name);

                if (is_wearing(R_HEALTH) ||
                    player.t_ctype == C_PALADIN ||
                    (player.t_ctype == C_NINJA && pstats.s_lvl
                     > 6) ||
                    thrown && rnd(50) > 0 ||
                    rnd(20) > 0)
                {
                    msg("The dust makes it hard to breath.");
                }
                else
                {
                    msg("You have contracted a parasitic infestation!");

                    infest_dam++;
                    turn_on(player, HASINFEST);
                }

                tp->t_stats.s_hpt = 0;
            }

            /* fireproof monsters laugh at you when burning weapon hits */

            if (thrown && on(*tp, NOFIRE) && (weap->o_flags & CANBURN))
                msg("The %s laughs as the %s bounces.",
                    monsters[tp->t_index].m_name,
                    weaps[weap->o_which].w_name);

            /* sharp weapons have no effect on NOSHARP monsters */

            if (on(*tp, NOSHARP) && (weap != NULL) &&
                (weap->o_flags & ISSHARP))
            {
                msg("The %s has no effect on the %s!",
                    weaps[weap->o_which].w_name,
                    monsters[tp->t_index].m_name);

                fighting = FALSE;
            }

            /* metal weapons pass through NOMETAL monsters */

            if (on(*tp, NOMETAL) && (weap != NULL) &&
                (weap->o_flags & ISMETAL))
            {
                msg("The %s passes through the %s!",
                    weaps[weap->o_which].w_name,
                    monsters[tp->t_index].m_name);

                fighting = FALSE;
            }

            /*
             * If the player hit something that shrieks, wake the
             * dungeon
             */

            if (on(*tp, CANSHRIEK))
            {
                turn_off(*tp, CANSHRIEK);

                if (on(player, CANHEAR))
                {
                    msg("You are stunned by the %s's shriek.", mname);
                    no_command += 4 + rnd(8);
                }
                else if (off(player, ISDEAF))
                    msg("The %s emits a piercing shriek.", mname);
                else
                    msg("The %s seems to be trying to make some noise.", mname);

                aggravate();

                if (rnd(wizard ? 3 : 39) == 0 && cur_armor
                    != NULL
                    && cur_armor->o_which == CRYSTAL_ARMOR)
                {
                    struct linked_list  *itm;
                    struct object   *obj;

                    for (itm = pack; itm != NULL; itm = next(itm))
                    {
                        obj = OBJPTR(itm);

                        if (obj == cur_armor)
                            break;
                    }

                    if (itm == NULL)
                        debug("Can't find crystalline armor being worn.");
                    else
                    {
                        msg("Your armor shatters from the shriek.");
                        cur_armor = NULL;
                        del_pack(itm);
                    }
                }
            }

            /*
             * If the player hit something that can surprise, it
             * can't now
             */

            if (on(*tp, CANSURPRISE))
                turn_off(*tp, CANSURPRISE);

            /*
             * If the player hit something that can summon, it
             * will try to
             */

            summon_help(tp, NOFORCE);

            /* Can the player confuse? */

            if (on(player, CANHUH) && !thrown)
            {
                seemsg("Your hands stop glowing red!");
                seemsg("The %s appears confused.", mname);
                turn_on(*tp, ISHUH);
                turn_off(player, CANHUH);
            }

            /* Merchants just disappear if hit */

            /*
             * increases prices and curses objects from now on
             * though
             */

            if (on(*tp, CANSELL))
            {
                msg("The %s disappears with his wares with a BOOM and a flash.",
                     mname);
                killed(NULL, item, NOMESSAGE, NOPOINTS);
                aggravate();
                luck++;
            }
            else if (tp->t_stats.s_hpt <= 0)
                killed(&player, item, MESSAGE, POINTS);

            /*
             * If the monster is fairly intelligent and about to
             * die, it may turn tail and run.
             */

            else if ((tp->t_stats.s_hpt < max(10, tp->maxstats.s_hpt / 10)) &&
                 (rnd(25) < tp->t_stats.s_intel))
            {
                turn_on(*tp, ISFLEE);

                /* If monster was suffocating, stop it */

                if (on(*tp, DIDSUFFOCATE))
                {
                    turn_off(*tp, DIDSUFFOCATE);
                    extinguish_fuse(FUSE_SUFFOCATE);
                }

                /* If monster held us, stop it */

                if (on(*tp, DIDHOLD) && (--hold_count == 0))
                    turn_off(player, ISHELD);

                turn_off(*tp, DIDHOLD);

                if (on(*tp, CANTELEPORT))
                {
                    int rm;

                    /*
                     * Erase the monster from the old
                     * position
                     */

                    if (isalpha(mvwinch(cw, tp->t_pos.y, tp->t_pos.x)))
                        mvwaddch(cw, tp->t_pos.y, tp->t_pos.x, tp->t_oldch);

                    mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, ' ');

                    /* Get a new position */

                    do
                    {
                        rm = rnd_room();
                        rnd_pos(&rooms[rm], &tp->t_pos);
                    }
                    while (winat(tp->t_pos.y, tp->t_pos.x) != FLOOR);

                    /* Put it there */

                    mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, tp->t_type);
                    tp->t_oldch = CCHAR( mvwinch(cw, tp->t_pos.y, tp->t_pos.x) );
                    seemsg("The %s seems to have disappeared!", mname);
                }
            }
        }
        else if (thrown)
            bounce(weap, mname);
        else
            miss(mname);
    }

    if (curr_mons)
        chase_it(mp,&player);   /* after so that backstabbing can happen */

    count = 0;

    return(did_hit);
}

/*
    attack()
        The monster attacks the player
*/

int
attack(struct thing *mp, struct object *weapon, int thrown)
{
    char    *mname;
    int    did_hit = FALSE;

    /* If the monster is in a wall, it cannot attack */

    if (on(*mp, ISINWALL))
        return (FALSE);

    /* If two monsters start to gang up on our hero, stop fight mode */

    if (fighting)
    {
        if (beast == NULL)
            beast = mp;
        else if (beast != mp)
            fighting = FALSE;
    }

    /*
       Since this is an attack, stop running and any healing that was
       going on at the time.
    */

    running = FALSE;
    player.t_rest_hpt = player.t_rest_pow = 0;
    mp->t_rest_hpt = mp->t_rest_pow = 0;

    if (on(*mp, ISDISGUISE) && off(player, ISBLIND))
        turn_off(*mp, ISDISGUISE);
    mname = on(player, ISBLIND) ? "the monster" :
        monsters[mp->t_index].m_name;

    if (roll_em(mp, &player, weapon, thrown, wield_weap(weapon, mp)) &&
        (!thrown || off(player, HASMSHIELD)))
    {
        did_hit = TRUE;

        m_thunk(weapon, mname);

        if (pstats.s_hpt <= 0)
        {
            death(mp->t_index); /* Bye bye life ... */
            return TRUE;
        }

        /* surprising monsters appear after they shoot at you */

        if (thrown && on(*mp, CANSURPRISE))
            turn_off(*mp, CANSURPRISE);
        else if (!thrown)
        {

            /*
               If a vampire hits, it may take half your hit
               points
            */

            if ( on(*mp, CANSUCK) && !save(VS_MAGIC) )
            {
                if (pstats.s_hpt == 1)
                {
                    death(mp->t_index);
                    return TRUE;
                }
                else
                {
                    pstats.s_hpt /= 2;
                    msg("You feel your life force being drawn from you.");
                }
            }

            /*
               strong monsters can shatter or gong crystalline
               armor
            */

            if (cur_armor != NULL && cur_armor->o_which == CRYSTAL_ARMOR)
            {
                if (rnd(mp->t_stats.s_str + (cur_armor->o_ac / 2)) > 20)
                {
                    struct linked_list  *item;
                    struct object   *obj;

                    for (item = pack; item != NULL; item = next(item))
                    {
                        obj = OBJPTR(item);

                        if (obj == cur_armor)
                            break;
                    }

                    if (item == NULL)
                        debug("Can't find crystalline armor being worn.");
                    else
                    {
                        msg("Your armor is shattered by the blow.");
                        cur_armor = NULL;
                        del_pack(item);
                    }
                }
                else if (rnd(mp->t_stats.s_str) > 15)
                {
                    msg("Your armor rings from the blow.");
                    aggravate();
                }
            }

            /* Stinking monsters reduce the player's strength */

            if (on(*mp, CANSTINK))
            {
                turn_off(*mp, CANSTINK);

                if (player.t_ctype != C_PALADIN
                    && !(player.t_ctype == C_NINJA && pstats.s_lvl > 12)
                    && !save(VS_POISON))
                {
                    if (on(player, CANSCENT))
                    {
                        msg("You pass out from the stench of the %s.", mname);
                        no_command += 4 + rnd(8);
                    }
                    else if (off(player, ISUNSMELL))
                        msg("The stench of the %s sickens you.", mname);

                    if (on(player, HASSTINK))
                        lengthen_fuse(FUSE_UNSTINK, STINKTIME);
                    else
                    {
                        turn_on(player, HASSTINK);
                        light_fuse(FUSE_UNSTINK, 0, STINKTIME, AFTER);
                    }
                }
            }

            /* chilling monster reduces strength permanently */

            if (on(*mp, CANCHILL) &&
                (cur_armor == NULL || cur_armor->o_which != CRYSTAL_ARMOR))
            {
                msg("You cringe at the %s's chilling touch.", mname);

                if (!is_wearing(R_SUSABILITY))
                {
                    chg_str(-1, FALSE, TRUE);

                    if (lost_str == 0)
                        light_fuse(FUSE_RES_STRENGTH, 0, CHILLTIME, AFTER);
                    else
                        lengthen_fuse(FUSE_RES_STRENGTH, CHILLTIME);
                }
            }

            /* itching monsters reduce dexterity (temporarily) */

            if (on(*mp, CANITCH) && player.t_ctype != C_PALADIN
                && !(player.t_ctype == C_NINJA && pstats.s_lvl > 12)
                && !save(VS_POISON))
            {
                msg("The claws of the %s scratch you!", mname);

                if (is_wearing(R_SUSABILITY))
                    msg("The scratch has no effect.");
                else
                {
                    msg("You feel a burning itch.");
                    turn_on(player, HASITCH);
                    chg_dext(-1, FALSE, TRUE);
                    light_fuse(FUSE_UNITCH, 0, roll(4, 6), AFTER);
                }
            }

            /* a hugging monster may SQUEEEEEEEZE */

            if (on(*mp, CANHUG) &&
                (cur_armor == NULL || cur_armor->o_which != CRYSTAL_ARMOR))
            {
                if (roll(1, 20) >= 18 || roll(1, 20) >= 18)
                {
                    msg("The %s squeezes you against itself.", mname);

                    if ((pstats.s_hpt -= roll(2, 8)) <= 0)
                    {
                        death(mp->t_index);
                        return TRUE;
                    }
                }
            }

            /* a trampling monster may step on the player */

            if (on(*mp, CANTRAMPLE))
            {
                if (roll(1, 20) >= 16 || roll(1, 20) >= 16)
                {
                    msg("The %s steps on you.", mname);

                    if ((pstats.s_hpt -= roll(3, mp->t_stats.s_lvl)) <= 0)
                    {
                        death(mp->t_index);
                        return TRUE;
                    }
                }
            }

            /* a disease-carrying monster may transmit the disease */

            if (on(*mp, CANDISEASE) &&
                (rnd(pstats.s_const) < mp->t_stats.s_lvl) &&
                off(player, HASDISEASE))
            {

                if (is_wearing(R_HEALTH)
                    || (player.t_ctype == C_PALADIN)
                    || (player.t_ctype == C_NINJA &&
                    pstats.s_lvl > 6))
                    msg("The wound heals quickly.");
                else
                {
                    turn_on(player, HASDISEASE);
                    light_fuse(FUSE_CURE_DISEASE,0,roll(4,4) * SICKTIME, AFTER);
                    msg("You have contracted a disease!");
                }
            }

            /* a rust monster will weaken your armor */

           if (on(*mp, CANRUST))
           {
                if (cur_armor != NULL &&
                    cur_armor->o_which != SOFT_LEATHER &&
                    cur_armor->o_which != HEAVY_LEATHER &&
                    cur_armor->o_which != CUIRBOLILLI &&
                    cur_armor->o_which != PADDED_ARMOR &&
                    cur_armor->o_which != CRYSTAL_ARMOR &&
                    cur_armor->o_which != MITHRIL &&
                    !(cur_armor->o_flags & ISPROT) &&
                    cur_armor->o_ac < pstats.s_arm + 1)
                {
                    msg("Your armor weakens!");
                    cur_armor->o_ac++;
                }
                else if (cur_armor != NULL &&
                     (cur_armor->o_flags & ISPROT) &&
                    cur_armor->o_which != SOFT_LEATHER &&
                     cur_armor->o_which != HEAVY_LEATHER &&
                     cur_armor->o_which != CUIRBOLILLI &&
                    cur_armor->o_which != PADDED_ARMOR &&
                     cur_armor->o_which != CRYSTAL_ARMOR &&
                     cur_armor->o_which != MITHRIL)
                    msg("The rust vanishes instantly!");
            }

            /* If a surprising monster hit you, you can see it now */

            if (on(*mp, CANSURPRISE))
                turn_off(*mp, CANSURPRISE);

            /* an infesting monster will give you a parasite or rot */

            if (on(*mp, CANINFEST) && rnd(pstats.s_const) < mp->t_stats.s_lvl)
            {
                if (is_wearing(R_HEALTH) || (player.t_ctype == C_PALADIN)
                    || (player.t_ctype == C_NINJA && pstats.s_lvl > 6))
                    msg("The wound quickly heals.");
                else
                {
                    turn_off(*mp, CANINFEST);
                    msg("You have contracted a parasitic infestation!");
                    infest_dam++;
                    turn_on(player, HASINFEST);
                }
            }

            /* Some monsters have poisonous bites */

            if (on(*mp, CANPOISON) && !save(VS_POISON))
            {
                if (is_wearing(R_SUSABILITY) || (player.t_ctype == C_PALADIN)
                    || (player.t_ctype == C_NINJA && pstats.s_lvl > 12))
                    msg("The sting has no effect on you!");
                else
                {
                    chg_str(-1, FALSE, FALSE);
                    msg("You feel a sting in your arm and now feel weaker.");
                }
            }

            /* a hideous monster may cause fear by touching */

            if (on(*mp, TOUCHFEAR))
            {
                turn_off(*mp, TOUCHFEAR);

                if (!save(VS_WAND)&&!(on(player,ISFLEE)&&(player.t_chasee==mp)))
                {
                    if (off(player, SUPERHERO)
                         && (player.t_ctype != C_PALADIN))
                    {
                        turn_on(player, ISFLEE);
                        player.t_ischasing = FALSE;
                        player.t_chasee = mp;
                        msg("The %s's touch terrifies you.", mname);
                    }
                    else
                        msg("The %s's touch feels cold and clammy.", mname);
                }
            }

            /* some monsters will suffocate our hero */

            if (on(*mp, CANSUFFOCATE) && (rnd(100) < 15) &&
                (find_slot(FUSE_SUFFOCATE, FUSE) == NULL))
            {
                turn_on(*mp, DIDSUFFOCATE);
                msg("The %s is beginning to suffocate you.",
                    mname);
                light_fuse(FUSE_SUFFOCATE, 0, roll(4, 2), AFTER);
            }

            /* don't look now, you will get turned to stone */

            if (on(*mp, TOUCHSTONE))
            {
                turn_off(*mp, TOUCHSTONE);

                if (on(player, CANINWALL))
                    msg("The %s's touch has no effect.", mname);
                else
                {
                    if (!save(VS_PETRIFICATION) && rnd(100) < 3)
                    {
                        msg("Your body begins to solidify.");
                        msg("You are turned to stone !!! --More--");
                        wait_for(' ');
                        death(D_PETRIFY);
                        return TRUE;
                    }
                    else
                    {
                        msg("The %s's touch stiffens your limbs.", mname);
                        no_command = rnd(STONETIME) + 2;
                    }
                }
            }

            /* Undead might drain energy levels */

            if ((on(*mp, CANDRAIN) || on(*mp, DOUBLEDRAIN)) && rnd(100) < 15)
            {
                if (is_carrying(TR_AMULET))
                   msg("The Amulet protects you from the %s's negative energy!",
                       mname);
                else
                {
                    lower_level(mp->t_index);

                    if (on(*mp, DOUBLEDRAIN))
                        lower_level(mp->t_index);
                }

                turn_on(*mp, DIDDRAIN);
            }

            /* permanently drain a wisdom point */

            if (on(*mp, DRAINWISDOM) && rnd(100) < 15)
            {
                int ring_str;   /* Value of ring strengths */

                /* Undo any ring changes */

                ring_str = ring_value(R_ADDWISDOM) +
                    (on(player, POWERWISDOM) ? 10 : 0);

                pstats.s_wisdom -= ring_str;
				
                msg("You feel slightly less wise now.");
				
                pstats.s_wisdom = max(pstats.s_wisdom - 1, 3);
                max_stats.s_wisdom = pstats.s_wisdom;

                /* Now put back the ring changes */

                pstats.s_wisdom += ring_str;

            }

            /* permanently drain a intelligence point */

            if (on(*mp, DRAINBRAIN) && rnd(100) < 15)
            {
                int ring_str;   /* Value of ring strengths */

                /* Undo any ring changes */

                ring_str = ring_value(R_ADDINTEL) +
                    (on(player, POWERINTEL) ? 10 : 0);

                pstats.s_intel -= ring_str;

                msg("You feel slightly less intelligent now.");
                pstats.s_intel = max(pstats.s_intel - 1, 3);
                max_stats.s_intel = pstats.s_intel;

                /* Now put back the ring changes */

                pstats.s_intel += ring_str;
            }

            /* Violet fungi and others hold the hero */

            if (on(*mp, CANHOLD) && off(*mp, DIDHOLD)
                && !is_wearing(R_FREEDOM))
            {
                turn_on(player, ISHELD);
                turn_on(*mp, DIDHOLD);
                hold_count++;
            }

            /* suckers will suck blood and run away */

            if (on(*mp, CANDRAW))
            {
                turn_off(*mp, CANDRAW);
                turn_on(*mp, ISFLEE);
                msg("The %s sates itself with your blood.", mname);

                if ((pstats.s_hpt -= 12) <= 0)
                {
                    death(mp->t_index);
                    return TRUE;
                }
            }

            /* el stinkos will force a reduction in strength */

            if (on(*mp, CANSMELL))
            {
                turn_off(*mp, CANSMELL);

                if (save(VS_MAGIC) || is_wearing(R_SUSABILITY))
                    msg("You smell an unpleasant odor.");
                else
                {
                    int   odor_str = -(rnd(6) + 1);

                    if (on(player, CANSCENT))
                    {
                        msg("You pass out from a foul odor.");
                        no_command += 4 + rnd(8);
                    }
                    else if (off(player, ISUNSMELL))
                        msg("You are overcome by a foul odor.");

                    if (lost_str == 0)
                    {
                        chg_str(odor_str, FALSE, TRUE);
                        light_fuse(FUSE_RES_STRENGTH, 0, SMELLTIME, AFTER);
                    }
                    else
                        lengthen_fuse(FUSE_RES_STRENGTH, SMELLTIME);
                }
            }

            /* Paralyzation */

            if (on(*mp, CANPARALYZE))
            {
                turn_off(*mp, CANPARALYZE);

                if (!save(VS_PARALYZATION) && no_command == 0)
                {
                    if (on(player, CANINWALL))
                        msg("The %s's touch has no effect.", mname);
                    else
                    {
                        msg("The %s's touch paralyzes you.", mname);
                        no_command = FREEZETIME;
                    }
                }
            }

            /* Rotting */

            if (on(*mp, CANROT))
            {
                turn_off(*mp, CANROT);
                turn_on(*mp, DOROT);
            }

            /* some monsters steal gold */

            if (on(*mp, STEALGOLD))
            {
                long    lastpurse;
                struct linked_list  *item;
                struct object   *obj;

                lastpurse = purse;
                purse = (purse > GOLDCALC) ? purse - GOLDCALC : 0L;

                if (!save(VS_MAGIC))
                    purse = (purse > (4*GOLDCALC)) ? purse-(4*GOLDCALC) : 0L;

                if (purse != lastpurse)
                {
                    msg("Your purse feels lighter.");

                    /* Give the gold to the thief */

                    for (item = mp->t_pack; item != NULL; item = next(item))
                    {
                        obj = OBJPTR(item);

                        if (obj->o_type == GOLD)
                        {
                            obj->o_count += lastpurse - purse;
                            break;
                        }
                    }

                    /* Did we do it? */

                    if (item == NULL)  /* Then make some */
                    {
                        item = new_item(sizeof *obj);
                        obj = OBJPTR(item);
                        obj->o_type = GOLD;
                        obj->o_count = lastpurse - purse;
                        obj->o_hplus = obj->o_dplus = 0;
                        obj->o_damage = obj->o_hurldmg = "0d0";
                        obj->o_ac = 11;
                        obj->o_group = 0;
                        obj->o_flags = 0;
                        obj->o_mark[0] = '\0';
                        obj->o_pos = mp->t_pos;

                        attach(mp->t_pack, item);
                    }
                }

                if (rnd(2))
                    turn_on(*mp, ISFLEE);

                turn_on(*mp, ISINVIS);
            }

            /* other monsters steal magic */

            if (on(*mp, STEALMAGIC))
            {
                struct linked_list  *list, *stealit;
                struct object   *obj;
                int worth = 0;

                stealit = NULL;

                for (list = pack; list != NULL; list = next(list))
                {
                    obj = OBJPTR(list);

                    if (rnd(33) == 0) /* some stuff degrades */
                    {
                        if (obj->o_flags & ISBLESSED)
                            obj->o_flags &= ~ISBLESSED;
                        else
                            obj->o_flags |= ISCURSED;

                        msg("You feel nimble fingers reach into you pack.");
                    }

                    if ((obj != cur_armor &&
                         obj != cur_weapon &&
                         obj != cur_ring[LEFT_1] &&
                         obj != cur_ring[LEFT_2] &&
                         obj != cur_ring[LEFT_3] &&
                         obj != cur_ring[LEFT_4] &&
                         obj != cur_ring[LEFT_5] &&
                         obj != cur_ring[RIGHT_1] &&
                         obj != cur_ring[RIGHT_2] &&
                         obj != cur_ring[RIGHT_3] &&
                         obj != cur_ring[RIGHT_4] &&
                         obj != cur_ring[RIGHT_5] &&
                         !(obj->o_flags & ISPROT) &&
                         is_magic(obj)
                         || level > 45)
                        && get_worth(obj) > worth)
                    {
                        stealit = list;
                        worth = get_worth(obj);
                    }
                }

                if (stealit != NULL)
                {
                    struct object   *newobj;

                    newobj = OBJPTR(stealit);

                    if (newobj->o_count > 1 && newobj->o_group == 0)
                    {
                        int oc;
                        struct linked_list  *nitem;
                        struct object   *op;

                        oc = --(newobj->o_count);
                        newobj->o_count = 1;
                        nitem = new_item(sizeof *newobj);
                        op = OBJPTR(nitem);
                        *op = *newobj;

                       msg("The %s stole %s!",mname,inv_name(newobj,LOWERCASE));
                        newobj->o_count = oc;
                        attach(mp->t_pack, nitem);
                    }
                    else
                    {
                       msg("The %s stole %s!",mname,inv_name(newobj,LOWERCASE));
                        newobj->o_flags &= ~ISCURSED;
                        dropcheck(newobj);
                        rem_pack(newobj);
                        attach(mp->t_pack, stealit);

                        if (newobj->o_type == ARTIFACT)
                            has_artifact &= ~(1 << newobj->o_which);
                    }

                    if (newobj->o_flags & ISOWNED)
                    {
                        turn_on(*mp, NOMOVE);
                        msg("The %s is transfixed by your ownership spell.",
                            mname);
                    }

                    if (rnd(2))
                        turn_on(*mp, ISFLEE);

                    turn_on(*mp, ISINVIS);
                    updpack();
                }
            }
        }
    }
    else /* missed */
    {
        /* If the thing was trying to surprise, no good */

        if (on(*mp, CANSURPRISE))
            turn_off(*mp, CANSURPRISE);

        m_bounce(weapon, mname);
    }

    count = 0;

    status(FALSE);

    return(did_hit);
}


/*
    mon_mon_attack()
        A monster attacks another monster
*/

int
mon_mon_attack(struct thing *attacker, struct linked_list *mon, struct object *weapon, int thrown)
{
    struct thing *attackee = THINGPTR(mon);
    int           did_hit  = FALSE;
    int           ee_visible = cansee(attackee->t_pos.y, attackee->t_pos.x);
    int           er_visible = cansee(attacker->t_pos.y, attacker->t_pos.x);
    char         *mname1   = monsters[attacker->t_index].m_name;
    char         *mname2   = monsters[attackee->t_index].m_name;

    /* Similar monsters don't hit each other */

    if (attacker->t_index == attackee->t_index)
    {
        if (fam_ptr && attacker == THINGPTR(fam_ptr) && er_visible)
            msg("Master, I cannot hit one of my brethren.");
        if (!thrown && rnd(100) - attacker->t_stats.s_charisma + luck < 0) 
		{
            if (er_visible)
                msg("Your %s has made a new ally.", mname1);
				
            turn_on(*attackee, ISCHARMED);
		}

        return(FALSE);
    }

    /* stop running and any healing */

    attackee->t_rest_hpt = attackee->t_rest_pow = 0;
    attacker->t_rest_hpt = attacker->t_rest_pow = 0;

    if (roll_em(attacker, attackee, weapon, thrown,
        wield_weap(weapon, attacker)))
    {
        did_hit = TRUE;

        if (ee_visible && on(*attackee, CANSURPRISE))
            turn_off(*attackee, CANSURPRISE);

        if (ee_visible && er_visible && weapon != NULL)
            msg("The %s's %s hits the %s.", mname1,
                weaps[weapon->o_which].w_name, mname2);
        else if (ee_visible && er_visible)
            msg("The %s hits the %s.", mname1, mname2);

        if (attackee->t_stats.s_hpt <= 0)
        {
            killed(attacker, mon, MESSAGE,
                 on(*attacker, ISFAMILIAR) ? POINTS : NOPOINTS);
            return(TRUE);
        }
    } 
    else  /* missed */
	{
	    did_hit = FALSE;
		
		if (ee_visible && er_visible && weapon != NULL)
            msg("The %s's %s misses the %s.", mname1,
                weaps[weapon->o_which].w_name, mname2);
        else if (ee_visible && er_visible)
            msg("The %s misses the %s.", mname1, mname2);
	}
	
	if (er_visible && !ee_visible)
        msg("The %s struggles with something.",mname1);

    if (off(*attackee, ISMEAN) && off(*attackee, ISFAMILIAR))
        turn_on(*attackee, ISRUN);

    count = 0;

    status(FALSE);

    return(did_hit);
}


/*
    swing()
        returns true if the swing hits
*/

int
swing(int class, int at_lvl, int op_arm, int wplus)
{
    int res = rnd(20) + 1;
    int need;

    need = att_mat[class].base -
        att_mat[class].factor *
        ((min(at_lvl, att_mat[class].max_lvl) -
          att_mat[class].offset) / att_mat[class].range) +
        (10 - op_arm);

    if (need > 20 && need <= 25)
        need = 20;

    return(res + wplus >= need);
}

/*
    init_exp()
        set up initial experience level change threshold
*/

void
init_exp(void)
{
    max_stats.s_exp = e_levels[player.t_ctype];
}

/*
    next_exp_level()
        Do the next level arithmetic Returns number of levels to jump
*/

int
next_exp_level(int print_message)
{
    int level_jump = 0;

    while (pstats.s_exp >= max_stats.s_exp)
    {
        pstats.s_exp -= max_stats.s_exp;    /* excess experience points */
        level_jump++;

        if (max_stats.s_exp < 0x3fffffffL)  /* 2^30 - 1 */
            max_stats.s_exp *= 2L;  /* twice as many for next */
    }

    if (print_message)
        msg("You need %d more points to attain the %stitle of %s.",
            max_stats.s_exp - pstats.s_exp,
            (pstats.s_lvl > 14 ? "next " : ""),
            cnames[player.t_ctype][min(pstats.s_lvl, 14)]);

    return(level_jump);
}

/*
    check_level()
        Check to see if the guy has gone up a level.
*/

void
check_level(void)
{
    int num_jumped, j, add;
    int nsides;

    if ((num_jumped = next_exp_level(NOMESSAGE)) <= 0)
        return;

    pstats.s_lvl += num_jumped; /* new experience level */

    switch (player.t_ctype)
    {
        case C_MAGICIAN:
        case C_ILLUSION: nsides = 4;
                         break;
        case C_THIEF:
        case C_ASSASIN:
        case C_NINJA:
        case C_MONSTER:
        default:         nsides = 6;
                         break;
        case C_CLERIC:
        case C_DRUID:    nsides = 8;
                         break;

        case C_FIGHTER:
        case C_PALADIN:
        case C_RANGER:
                         nsides = 12;
                         break;
    }

    /* Take care of multi-level jumps */

    for (add = 0, j = 0; j < num_jumped; j++)
    {
        int increase = roll(1, nsides) + const_bonus();

        add += max(1, increase);
    }

    max_stats.s_hpt += add;
    pstats.s_hpt += add;

    msg("Welcome, %s, to level %d.",
        cnames[player.t_ctype][min(pstats.s_lvl - 1, 14)], pstats.s_lvl);

    next_exp_level(MESSAGE);

    /* Now add new spell points and learn new spells */

    nsides = 16 - nsides;

    for (add = 0, j = 0; j < num_jumped; j++)
    {
        int increase = roll(1, nsides) + int_wis_bonus();

        add += max(1, increase);
    }

    max_stats.s_power += add;
    pstats.s_power += add;

    learn_new_spells();

    /* Create a more powerful familiar (if player has one) */

    if (on(player, HASFAMILIAR) && on(player, CANSUMMON))
        summon_monster((short) 0, FAMILIAR, NOMESSAGE);
}

/*
    roll_em()
        Roll several attacks
*/

int
roll_em(struct thing *att_er, struct thing *def_er, struct object *weap, int thrown, struct object *my_weapon)
{
    struct stats *att = &att_er->t_stats;
    struct stats *def = &def_er->t_stats;
    int ndice, nsides, nplus, def_arm;
    char *cp;
    int prop_hplus = 0, prop_dplus = 0;
    int is_player = (att_er == &player);
    int did_hit = FALSE;

    if (weap == NULL)
        cp = att->s_dmg;
    else if (!thrown)
        cp = weap->o_damage;
    else if ((weap->o_flags & ISMISL) && my_weapon != NULL &&
         my_weapon->o_which == weap->o_launch)
    {
        cp = weap->o_hurldmg;
        prop_hplus = my_weapon->o_hplus;
        prop_dplus = my_weapon->o_dplus;
    }
    else
        cp = (weap->o_flags & ISMISL ? weap->o_damage :
            weap->o_hurldmg);

    for (;;)
    {
        int damage;
        int hplus = prop_hplus + (weap == NULL ? 0 : weap->o_hplus);
        int dplus = prop_dplus + (weap == NULL ? 0 : weap->o_dplus);

        /* Is attacker weak? */

        if (on(*att_er, HASSTINK))
            hplus -= 2;

        if (is_player)
        {
            hplus += hitweight();   /* adjust for encumberence */
            dplus += hung_dam();    /* adjust damage for hungry player */
            dplus += ring_value(R_ADDDAM);
        }

        ndice = atoi(cp);

        if (cp == NULL || (cp = strchr(cp, 'd')) == NULL)
            break;

        nsides = atoi(++cp);

        if (cp != NULL && (cp = strchr(cp, '+')) != NULL)
            nplus = atoi(++cp);
        else
            nplus = 0;

        if (def == &pstats)
        {
            if (on(*att_er, NOMETAL) && cur_armor != NULL &&
                (cur_armor->o_which == RING_MAIL ||
                 cur_armor->o_which == SCALE_MAIL ||
                 cur_armor->o_which == CHAIN_MAIL ||
                 cur_armor->o_which == SPLINT_MAIL ||
                 cur_armor->o_which == BANDED_MAIL ||
                 cur_armor->o_which == GOOD_CHAIN ||
                 cur_armor->o_which == PLATE_MAIL ||
                 cur_armor->o_which == PLATE_ARMOR))
                def_arm = def->s_arm;
            else if (cur_armor != NULL)
                def_arm = cur_armor->o_ac - 10 + pstats.s_arm;
            else
                def_arm = def->s_arm;
            def_arm -= ring_value(R_PROTECT);
        }
        else
            def_arm = def->s_arm;

        if ((weap != NULL && weap->o_type == WEAPON &&
             (weap->o_flags & ISSILVER) &&
            !save_throw(VS_MAGIC, def_er)) ||
            swing(att_er->t_ctype, att->s_lvl,
            def_arm - dext_prot(def->s_dext),
           hplus + str_plus(att->s_str) + dext_plus(att->s_dext)))
        {
            damage = roll(ndice, nsides) + dplus + nplus +
                add_dam(att->s_str);

            /* Rangers do +1/lvl vs. ISLARGE */

            if (att_er->t_ctype == C_RANGER && on(*def_er, ISLARGE))
                damage += pstats.s_lvl;

            /* Ninja do +1 per lvl/2 */

            if (att_er->t_ctype == C_NINJA)
                damage += pstats.s_lvl / 2;

            /* Check for half damage monsters */

            if (on(*def_er, HALFDAMAGE) && (weap != NULL) &&
                !((weap->o_flags & CANBURN) &&
                on(*def_er, CANBBURN)))
                damage /= 2;

            /* undead get twice damage from silver weapons */

            if (on(*def_er, ISUNDEAD) &&
                (weap != NULL) && (weap->o_flags & ISSILVER))
                damage *= 2;

            /* Check for fireproof monsters */

            if (on(*def_er, NOFIRE) && (weap != NULL) &&
                (weap->o_flags & CANBURN))
                damage = 0;

            /* Check for metal proof monsters */

            if (on(*def_er, NOMETAL) && (weap != NULL) &&
                (weap->o_flags & ISMETAL))
                damage = 0;

            /* Check for monsters that ignore sharp weapons  */

            if (on(*def_er, NOSHARP) && (weap != NULL) &&
                (weap->o_flags & ISSHARP))
                damage = 0;

            /* Check for poisoned weapons */

            if ((weap != NULL) && (weap->o_flags & ISPOISON)
                && off(*def_er, ISUNDEAD)
                && !save_throw(VS_POISON, def_er))
                damage = max(damage, (def->s_hpt / 2) + 5);

            /* Check for no-damage and division */

            if (on(*def_er, BLOWDIVIDE) && rnd(3) == 0 &&
                !((weap != NULL) && (weap->o_flags & CANBURN)))
            {
                damage = 0;
                creat_mons(def_er, def_er->t_index, NOMESSAGE);
            }

            damage = max(0, damage);

            /*
             * sleeping monsters are backstabbed by certain
             * player classes, but only when they can see
             */

            if (is_player && !thrown && damage > 0 &&
                (off(*def_er, ISRUN) || def_er->t_no_move > 0) &&
                (player.t_ctype == C_THIEF ||
                 player.t_ctype == C_NINJA ||
                 player.t_ctype == C_ASSASIN) &&
				 off(player,ISBLIND)
                && (wield_ok(&player, my_weapon, NOMESSAGE))
                && (wear_ok(&player, cur_armor, NOMESSAGE)))
            {
                damage *= (pstats.s_lvl / 4 + 2);

                msg("You backstabbed the %s %d times!",
                    monsters[def_er->t_index].m_name,
                    (pstats.s_lvl / 4) + 2);

                if (player.t_ctype == C_NINJA ||
                    player.t_ctype == C_ASSASIN)
                    pstats.s_exp += def_er->t_stats.s_exp
                        / 2;
            }

            def->s_hpt -= damage;   /* Do the damage */

            debug("Hit %s for %d (%d) ",
                  monsters[def_er->t_index].m_name, damage,
                  def_er->t_stats.s_hpt);

            if (is_player && is_wearing(R_VREGEN))
            {
                damage = (ring_value(R_VREGEN) * damage) / 3;
                pstats.s_hpt = min(max_stats.s_hpt,
                    pstats.s_hpt + damage);
            }

            /* stun monsters when taking more than 1/3 their max hpts */

            if (is_player && !thrown && !did_hit &&
                (player.t_ctype == C_FIGHTER) &&
                (damage > def_er->maxstats.s_hpt / 3) )
            {
                if (def->s_hpt > 0)
                {
                    msg("The %s has been stunned!",
                      monsters[def_er->t_index].m_name);
                    def_er->t_no_move += rnd(4) + 1;
                }
                pstats.s_exp += def_er->t_stats.s_exp / 4;
            }

            did_hit = TRUE;
        }

        if (cp == NULL || (cp = strchr(cp, '/')) == NULL)
            break;

        cp++;
    }

    return(did_hit);
}

/*
    prname()
        Figure out the monsters name
*/

const char *
prname(char *who)
{
    if (on(player, ISBLIND))
        return(monstern);
    else
        return(who);
}

/*
    hit()
        Print a message to indicate a succesful hit
*/

void
hit(char *ee)
{
    char    *s;

    if (fighting)
        return;

    switch (rnd(15))
    {
        default:  s = "hit";                            break;
        case 1:   s = "score an excellent hit on";      break;
        case 2:   s = "injure";                         break;
        case 3:   s = "swing and hit";                  break;
        case 4:   s = "damage";                         break;
        case 5:   s = "barely nick";                    break;
        case 6:   s = "scratch";                        break;
        case 7:   s = "gouge a chunk out of";           break;
        case 8:   s = "severely wound";                 break;
        case 9:   s = "counted coup on";                break;
        case 10:  s = "drew blood from";                break;
        case 11:  s = "nearly decapitate";              break;
        case 12:  s = "deal a wacking great blow to";   break;
    }

    msg("You %s the %s.", s, prname(ee));
}

/*
    miss()
        Print a message to indicate a poor swing
*/

void
miss(char *ee)
{
    char *s;

    if (fighting)
        return;

    switch (rnd(10))
    {
        default:  s = "miss";                          break;
        case 1:   s = "swing and miss";                break;
        case 2:   s = "barely miss";                   break;
        case 3:   s = "don't hit";                     break;
        case 4:   s = "wildly windmill around";        break;
        case 5:   s = "almost fumble while missing";   break;
    }

    msg("You %s the %s.", s, prname(ee));
}

/*
    save_throw()
        See if a creature save against something
*/

int
save_throw(int which, struct thing *tp)
{
    int need;
    int ring_bonus = 0;
    int armor_bonus = 0;
    int class_bonus = 0;

    if (tp == &player)
    {
        if (player.t_ctype == C_PALADIN)
            class_bonus = 2;

        ring_bonus = ring_value(R_PROTECT);

        if (cur_armor != NULL && (which == VS_WAND ||
            which == VS_MAGIC))
        {
            if (cur_armor->o_which == MITHRIL)
                armor_bonus += 5;
            armor_bonus += (armors[cur_armor->o_which].a_class
                    - cur_armor->o_ac);
        }
    }

    need = 14 + which - tp->t_stats.s_lvl / 2 - ring_bonus -
        armor_bonus - class_bonus;

    /* Roll of 1 always fails; 20 always saves */

    if (need < 1)
        need = 1;
    else if (need > 20)
        need = 20;

    return(roll(1, 20) >= need);
}

/*
    save()
        See if he saves against various nasty things
*/

int
save(int which)
{
    return save_throw(which, &player);
}

/*
    dext_plus()
       compute to-hit bonus for dexterity
*/

int
dext_plus(int dexterity)
{
    return ((dexterity - 10) / 3);
}

/*
 * dext_prot: compute armor class bonus for dexterity
 */

int
dext_prot(int dexterity)
{
    return ((dexterity - 9) / 2);
}

/*
    str_plus()
       compute bonus/penalties for strength on the "to hit" roll
*/

static const int strtohit[] =
{
    0, 0, 0, -3, -2, -2, -1, -1,
    0, 0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 3, 3, 4, 4, 5, 6, 7
};

int
str_plus(int str)
{
    int ret_val = str;

    if (str < 3)
        ret_val = 3;
    else if (str > 25)
        ret_val = 25;

    return(strtohit[ret_val]);
}

/*
    add_dam()
        compute additional damage done for exceptionally high or low strength
*/

static const int str_damage[] =
{
    0, 0, 0, -1, -1, -1, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 2, 7, 8, 9, 10, 11, 12, 14
};

int
add_dam(int str)
{
    int ret_val = str;

    if (str < 3)
        ret_val = 3;
    else if (str > 25)
        ret_val = 25;

    return(str_damage[ret_val]);
}

/*
    hung_dam()
        Calculate damage depending on players hungry state
*/

int
hung_dam(void)
{
    int howmuch = 0;

    switch (hungry_state)
    {
        case F_OK:
        case F_HUNGRY: howmuch =  0; break;
        case F_WEAK:   howmuch = -1; break;
        case F_FAINT:  howmuch = -2; break;
    }

    return(howmuch);
}

/*
    raise_level()
        The guy just magically went up a level.
*/

void
raise_level(void)
{
    pstats.s_exp = max_stats.s_exp;
    check_level();
}

/*
    thunk()
        A missile hits a monster
*/

void
thunk(struct object *weap, char *mname)
{
    if (fighting)
        return;

    if (weap->o_type == WEAPON)
        msg("The %s hits the %s.", weaps[weap->o_which].w_name, prname(mname));
    else
        msg("You hit the %s.", prname(mname));
}

/*
    m_thunk()
        A missile from a monster hits the player
*/

void
m_thunk(struct object *weap, char *mname)
{
    if (fighting)
        return;

    if (weap != NULL && weap->o_type == WEAPON)
        msg("The %s's %s hits you.",prname(mname),weaps[weap->o_which].w_name);
    else
        msg("The %s hits you.", prname(mname));
}

/*
    bounce()
        A missile misses a monster
*/

void
bounce(struct object *weap, char *mname)
{
    if (fighting)
        return;

    if (weap->o_type == WEAPON)
        msg("The %s misses the %s.",weaps[weap->o_which].w_name,prname(mname));
    else
        msg("You missed the %s.", prname(mname));
}

/*
    m_bounce()
        A missile from a monster misses the player
*/

void
m_bounce(struct object *weap, char *mname)
{
    if (fighting)
        return;

    if (weap != NULL && weap->o_type == WEAPON)
        msg("The %s's %s misses you.", prname(mname),
                                       weaps[weap->o_which].w_name);
    else
        msg("The %s misses you.", prname(mname));
}

/*
    remove_monster()
        remove a monster from the screen
*/

void
remove_monster(coord *mp, struct linked_list *item)
{
    struct thing *tp = THINGPTR(item);
    char          ch = tp->t_oldch;

    mvwaddch(mw, mp->y, mp->x, ' ');

    if (ch < 33 || ch == ' ')
        ch = CCHAR( mvwinch(stdscr, mp->y, mp->x) );

    if (cansee(mp->y, mp->x))
        mvwaddch(cw, mp->y, mp->x, ch);

    detach(mlist, item);
    discard(item);
}

/*
    is_magic()
        Returns true if an object radiates magic
*/

int
is_magic(struct object *obj)
{
    switch (obj->o_type)
    {
        case ARMOR:
            return(obj->o_ac != armors[obj->o_which].a_class);

        case WEAPON:
            return(obj->o_hplus != 0 || obj->o_dplus != 0);

        case POTION:
        case SCROLL:
        case STICK:
        case RING:
        case ARTIFACT:
            return(TRUE);
    }

    return(FALSE);
}

/*
    killed()
        Called to put a monster to death
*/

void
killed(struct thing *killer, struct linked_list *item, int print_message,
       int give_points)
{
    struct linked_list *pitem, *nitem;
    struct thing       *tp        = THINGPTR(item);
    int                 visible   = cansee(tp->t_pos.y, tp->t_pos.x);
    int                 is_player = (killer == (&player));

    if (item == curr_mons)
        curr_mons = NULL;
    else if (item == next_mons)
        next_mons = next(next_mons);

    if (on(*tp, WASSUMMONED))
    {
        extinguish_fuse(FUSE_UNSUMMON);
        turn_off(player, HASSUMMONED);
    }

    if (print_message && visible)
    {
        if (is_player)
            addmsg("You have defeated ");
        else
            addmsg("The %s has defeated ",
                monsters[killer->t_index].m_name);

        if (on(player, ISBLIND))
            msg("it.");
        else
            msg("the %s.", monsters[tp->t_index].m_name);
    }
    debug("Removing %s", monsters[tp->t_index].m_name);
    if (killer != NULL && item == fam_ptr)  /* The player's familiar died */
    {
        turn_off(player, HASFAMILIAR);
        fam_ptr = NULL;
        msg("An incredible wave of sadness sweeps over you.");
    }

    check_residue(tp);

    if (is_player)
    {
        fighting = FALSE;

        if (on(*tp, ISFRIENDLY))
        {
            msg("You feel a slight chill run up and down your spine.");
            luck++;
        }
    }

    if (give_points)
    {
        if (killer != NULL)
        {
            killer->t_stats.s_exp += tp->t_stats.s_exp;

            if (on(*killer, ISFAMILIAR))
                pstats.s_exp += tp->t_stats.s_exp;
        }

        if (is_player)
        {
            switch (player.t_ctype)
            {
                case C_CLERIC:
                case C_PALADIN:
                    if (on(*tp, ISUNDEAD) || on(*tp, ISUNIQUE))
                    {
                        pstats.s_exp += tp->t_stats.s_exp / 2;
                        msg("You are to be commended for smiting the ungodly.");
                    }
                    break;

                case C_DRUID:
                case C_RANGER:
                    if (on(*tp, ISLARGE))
                    {
                        pstats.s_exp += tp->t_stats.s_exp / 2;
                        msg("Congratulations on smiting a dangerous monster.");
                    }
                    break;

                case C_MAGICIAN:
                case C_ILLUSION:
                    if (on(*tp, DRAINBRAIN))
                    {
                        pstats.s_exp += tp->t_stats.s_exp / 2;
                        msg("Congratulations on smiting a dangerous monster.");
                    }

            }
        }
        check_level();
    }

    /* Empty the monsters pack */

    for (pitem = tp->t_pack; pitem != NULL; pitem = nitem)
    {
        struct object *obj = OBJPTR(pitem);

        nitem = next(pitem);

        obj->o_pos = tp->t_pos;
        detach(tp->t_pack, pitem);

        if (killer == NULL)
            discard(pitem);
        else
            fall(killer, pitem, FALSE, FALSE);
    }

    remove_monster(&tp->t_pos, item);
}


/*
    wield_weap()
        Returns a pointer to the weapon the monster is wielding corresponding           to the given thrown weapon
*/

struct object *
wield_weap(struct object *weapon, struct thing *mp)
{
    int look_for;
    struct linked_list *pitem;

    if (weapon == NULL)
        return (NULL);

    switch (weapon->o_which)
    {
        case BOLT:
            look_for = CROSSBOW;
            break;

        case ARROW:
            look_for = BOW;
            break;

        case SILVERARROW:
        case FLAMEARROW:
            look_for = BOW;
            break;

        case ROCK:
        case BULLET:
            look_for = SLING;
            break;

        default:
            return(NULL);
    }

    for (pitem = mp->t_pack; pitem; pitem = next(pitem))
        if ((OBJPTR(pitem))->o_which == look_for)
            return(OBJPTR(pitem));

    return (NULL);
}

/*
    summon_help()
        Summon - see whether to summon help Returns TRUE if help comes, FALSE
        otherwise
*/

void
summon_help(struct thing *mons, int force)
{
    char *helpname;
    int   which, i;
    char *mname = monsters[mons->t_index].m_name;

    /* Try to summon if less than 1/3 max hit points */

    if (on(*mons, CANSUMMON) &&
      (force == FORCE ||
      (mons->t_stats.s_hpt < mons->maxstats.s_hpt / 3) &&
      (rnd(40 * 10) < (mons->t_stats.s_lvl * mons->t_stats.s_intel))))
    {
        turn_off(*mons, CANSUMMON);
        msg("The %s summons its attendants!", mname);
        helpname = monsters[mons->t_index].m_typesum;

        for (which = 1; which < nummonst; which++)
        {
            if (strcmp(helpname, monsters[which].m_name) == 0)
                break;
        }

        if (which >= nummonst)
        {
            debug("Couldn't find summoned one.");
            return;
        }

        /* summoned monster was genocided */

        if (!monsters[which].m_normal)
        {
            msg("The %s becomes very annoyed at you!", mname);

            if (on(*mons, ISSLOW))
                turn_off(*mons, ISSLOW);
            else
                turn_on(*mons, ISHASTE);

            return;
        }
        else
            for (i = 0; i < monsters[mons->t_index].m_numsum; i++)
            {
                struct linked_list  *ip;
                struct thing    *tp;

                if ((ip = creat_mons(mons, which, NOMESSAGE)) != NULL)
                {
                    tp = THINGPTR(ip);
                    turn_off(*tp, ISFRIENDLY);
                }
            }
    }

    return;
}

/*
    maxdamage()
        return the max damage a weapon can do
*/

int
maxdamage(char *cp)
{
    int ndice, nsides, nplus;

    ndice = atoi(cp);

    if (cp == NULL || (cp = strchr(cp, 'd')) == NULL)
        return(0);

    nsides = atoi(++cp);

    if (cp != NULL && (cp = strchr(cp, '+')) != NULL)
        nplus = atoi(++cp);
    else
        nplus = 0;

    return(ndice * nsides + nplus);
}