/*
    scrolls.c - Functions for dealing with scrolls
  
    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"

/*
    read_scroll - read a scroll (or effect a scroll-like spell)
        reader:  who does it
        which:   which S_SCROLL (-1 means ask from pack)
        flags:   ISBLESSED, ISCURSED
*/

void
read_scroll(struct thing *reader, int which, int flags)
{
    struct object   *obj;
    struct linked_list  *item, *nitem;
    int i, j, charm_power;
    char    ch, nch;
    int     blessed = flags & ISBLESSED;
    int     cursed = flags & ISCURSED;
    int     is_scroll = (which < 0 ? TRUE : FALSE);
    char    buf[2 * LINELEN];

    if (reader != &player)
    {
        monread(reader, which, flags);
        return;
    }

    if (is_scroll)      /* A regular scroll */
    {
        if ((item = get_item("read", SCROLL)) == NULL)
            return;

        obj = OBJPTR(item);

        if (obj->o_type != SCROLL)
        {
            msg("It says 'Made in Yugoslavia'!");
            return;
        }

        if (on(player, ISBLIND))
        {
            msg("You can't see to read anything.");
            return;
        }

        /* Calculate its effect */

        cursed = obj->o_flags & ISCURSED;
        blessed = obj->o_flags & ISBLESSED;
        flags = obj->o_flags;
        which = obj->o_which;

        /* remove it from the pack */

        rem_pack(obj);
        discard(item);
        updpack();
    }

    switch (which)
    {
        case S_CONFUSE:  /* Touch causes monster confusion.  */
            if (cursed)
                quaff(reader, P_CLEAR, ISCURSED);
            else
            {
                msg("Your hands begin to glow red.");
                turn_on(player, CANHUH);
                /* if blessed... */
            }
            break;

        case  S_CURING:   /* A cure disease spell */
            if (on(player, HASINFEST) || on(player, HASDISEASE))
            {
                if (!cursed && on(player, HASDISEASE))
                {
                    extinguish_fuse(FUSE_CURE_DISEASE);
                    cure_disease(NULL);
                }

                if (on(player, HASINFEST))
                {
                    msg("You begin to feel yourself improving again.");
                    turn_off(player, HASINFEST);
                    infest_dam = 0;
                }

                if (is_scroll)
                    know_items[TYP_SCROLL][S_CURING] = TRUE;
            }
            else
                nothing_message(flags);
            break;

        case S_LIGHT:
            if (blue_light(flags) && is_scroll)
                know_items[TYP_SCROLL][S_LIGHT] = TRUE;
            break;

        case S_HOLD:
            if (cursed)
            {
                /*
                 * This scroll aggravates all the monsters on the
                 * current level and sets them running towards the
                 * hero
                 */
                aggravate();
                hearmsg("You hear a high pitched humming noise.");
            }
            else if (blessed)   /* Hold all monsters on level */
            {
                if (mlist == NULL)
                    nothing_message(flags);
                else
                {
                    struct linked_list  *mon;
                    struct thing    *th;

                    for (mon = mlist; mon != NULL; mon = next(mon))
                    {
                        th = THINGPTR(mon);
                        turn_off(*th, ISRUN);
                        turn_on(*th, ISHELD);
                    }
                    msg("A sudden peace comes over the dungeon.");
                }
            }
            else
            {
                /*
                 * Hold monster scroll.  Stop all monsters within two
                 * spaces from chasing after the hero.
                 */
                int x, y;
                struct linked_list  *mon;
                int gotone = FALSE;

                for (x = hero.x - 2; x <= hero.x + 2; x++)
                {
                    for (y = hero.y - 2; y <= hero.y + 2; y++)
                    {
                        if (y > 0 && x > 0 && isalpha(mvwinch(mw, y, x)))
                        {
                            if ((mon = find_mons(y, x)) != NULL)
                            {
                                struct thing    *th;

                                gotone = TRUE;
                                th = THINGPTR(mon);
                                turn_off(*th, ISRUN);
                                turn_on(*th, ISHELD);
                            }
                        }
                    }
                }

                if (gotone)
                    msg("A sudden peace surrounds you.");
                else
                    nothing_message(flags);
            }
            break;

        case S_SLEEP:

            /* if cursed, you fall asleep */

            if (cursed)
            {
                if (is_wearing(R_ALERT))
                    msg("You feel drowsy for a moment.");
                else
                {
                    msg("You fall asleep.");
                    no_command += 4 + rnd(SLEEPTIME);
                }
            }
            else
            {
                /*
                 * sleep monster scroll.  puts all monsters within 2
                 * spaces asleep
                 */
                int x, y;
                struct linked_list  *mon;
                int gotone = FALSE;

                for (x = hero.x - 2; x <= hero.x + 2; x++)
                {
                    for (y = hero.y - 2; y <= hero.y + 2; y++)
                    {
                        if (y > 0 && x > 0 && isalpha(mvwinch(mw, y, x)))
                        {
                            if ((mon = find_mons(y, x)) != NULL)
                            {
                                struct thing    *th;
                                th = THINGPTR(mon);

                                if (on(*th, ISUNDEAD))
                                    continue;

                                gotone = TRUE;
                                th->t_no_move += SLEEPTIME;
                            }
                        }
                    }
                }

                if (gotone)
                    msg("The monster(s) around you seem to have fallen asleep.");
                else
                    nothing_message(flags);
            }
            break;

        case S_CREATE:
        {
            /*
             * Create a monster. First look in a circle around
             * him, next try his room otherwise give up
             */

            struct thing    *tp;
            struct linked_list  *ip;

            if (blessed)
                summon_monster((short) 0, NOFAMILIAR, MESSAGE);
            else if (cursed)
            {
                i = rnd(4) + 3;
                for (j = 0; j < i; j++)
                {
                    if ((ip = creat_mons(&player, (short) 0, MESSAGE)) != NULL)
                    {
                        tp = THINGPTR(ip);
                        turn_off(*tp, ISFRIENDLY);
                    }
                }
            }
            else if ((ip = creat_mons(&player, (short) 0, MESSAGE)) != NULL)
            {
                tp = THINGPTR(ip);
                turn_off(*tp, ISFRIENDLY);
            }
        }
        break;

        case S_IDENTIFY:
            if (cursed)
                msg("You identify this scroll as an identify scroll");
            else if (blessed)   /* identify everything in the pack */
            {
                msg("You feel more Knowledgeable!");
                idenpack();
            }
            else
            {
                /* Identify, let the rogue figure something out  */

                if (is_scroll && know_items[TYP_SCROLL][S_IDENTIFY] != TRUE)
                {
                    msg("This scroll is an identify scroll.");
                    know_items[TYP_SCROLL][S_IDENTIFY] = TRUE;
                }
                whatis(NULL);
            }
            break;

        case S_MAP:

            /* Scroll of magic mapping. */

            if (cursed)
            {
                msg("Your mind goes blank for a moment.");
                wclear(cw);
                light(&hero);
                status(TRUE);
                break;
            }

            if (is_scroll && know_items[TYP_SCROLL][S_MAP] != TRUE)
            {
                msg("Oh! This scroll has a map on it!!");
                know_items[TYP_SCROLL][S_MAP] = TRUE;
            }

            if (blessed)
                turn_on(player, BLESSMAP);

            overwrite(stdscr, hw);

            /* Take all the things we want to keep hidden out of the window */

            for (i = 0; i < LINES; i++)
                for (j = 0; j < COLS; j++)
                {
                    switch (nch = ch = CCHAR(mvwinch(hw, i, j)))
                    {
                        case SECRETDOOR:
                            nch = DOOR;
                            mvaddch(i, j, nch);
                            break;

                        case '-':
                        case '|':
                        case DOOR:
                        case PASSAGE:
                        case ' ':
                        case STAIRS:
                            if (mvwinch(mw, i, j) != ' ')
                            {
                                struct thing    *it;
                                struct linked_list  *lit;

                                lit = find_mons(i, j);

				if (lit) {
				    it = THINGPTR(lit);

				    if (it && it->t_oldch == ' ')
					it->t_oldch = nch;
				}
                            }
                            break;

                        default:
                            if (!blessed || !isatrap(ch))
                                nch = ' ';
                            else
                            {
                                struct trap *tp;
                                struct room *rp;

                                tp = trap_at(i, j);
                                rp = roomin(hero);

                                if (tp->tr_type == FIRETRAP && rp != NULL)
                                {
                                    rp->r_flags &= ~ISDARK;
                                    light(&hero);
                                }

                                tp->tr_flags |= ISFOUND;
                            }
                    }
                    if (nch != ch)
                        waddch(hw, nch);
                }

            /* Copy in what he has discovered */
            overlay(cw, hw);

            /* And set up for display */
            overwrite(hw, cw);

            break;

        case S_GFIND:
            /* Scroll of gold detection */

            if (cursed)
            {
                int n = roll(3, 6);
                int k;
                struct room *rp;
                coord   pos;

                msg("You begin to feel greedy and you sense gold.");
                wclear(hw);

                for (k = 1; k < n; k++)
                {
                    rp = &rooms[rnd_room()];
                    rnd_pos(rp, &pos);
                    mvwaddch(hw, pos.y, pos.x, GOLD);
                }
                overlay(hw, cw);

                break;
            }

            if (blessed)
                turn_on(player, BLESSGOLD);

            if (gsense() && is_scroll)
                know_items[TYP_SCROLL][S_GFIND] = TRUE;

            break;

        case S_SELFTELEP:

            /* Scroll of teleportation: Make him disappear and reappear */

            if (cursed)
            {
                level += 5 + rnd(5);
                new_level(NORMLEV,0);
                mpos = 0;
                msg("You are banished to the lower regions.");
            }
            else if (blessed)
            {
                level -= rnd(3) + 1;

                if (level < 1)
                    level = 1;

                mpos = 0;
                new_level(NORMLEV,0); /* change levels */
                status(TRUE);
                msg("You are whisked away to another region.");
            }
            else
            {
                teleport();

                if (is_scroll)
                    know_items[TYP_SCROLL][S_SELFTELEP] = TRUE;
            }

            if (off(player, ISCLEAR))
            {
                if (on(player, ISHUH))
                    lengthen_fuse(FUSE_UNCONFUSE, rnd(4) + 4);
                else
                {
                    light_fuse(FUSE_UNCONFUSE, 0, rnd(4) + 4, AFTER);
                    turn_on(player, ISHUH);
                }
            }
            else
                msg("You feel dizzy for a moment, but it quickly passes.");

            break;

        case S_SCARE:

            /*
             * A blessed scroll of scare monster automatically transports
             * itself to the hero's feet
             *
             */

            if (blessed)
            {
                ch = CCHAR( mvwinch(stdscr, hero.y, hero.x) );

                if (ch != FLOOR && ch != PASSAGE)
                {
                    msg("Your feet tickle for a moment");
                    return;
                }

                item = spec_item(SCROLL, S_SCARE, 0, 0);

                obj = OBJPTR(item);
                obj->o_flags = ISCURSED;
                obj->o_pos = hero;
                add_obj(item, hero.y, hero.x);
                msg("A wave of terror sweeps throughout the room");
            }
            else
            {
                /*
                 * A monster will refuse to step on a scare monster
                 * scroll if it is dropped.  Thus reading it is a
                 * mistake and produces laughter at the poor rogue's
                 * boo boo.
                 */

                msg("You hear maniacal laughter in the distance.");

                if (cursed) /* If cursed, monsters get mad */
                    aggravate();
            }
            break;

        case S_REMOVECURSE:
            if (cursed)     /* curse a player's possession */
            {
                for (nitem = pack; nitem != NULL; nitem = next(nitem))
                {
                    obj = OBJPTR(nitem);

                    if (rnd(5) == 0)
                        if (obj->o_flags & ISBLESSED)
                            obj->o_flags &= ~ISBLESSED;
                        else
                            obj->o_flags |= ISCURSED;
                }
                msg("The smell of fire and brimstone comes from your pack.");
            }
            else if (blessed)
            {
                for (nitem = pack; nitem != NULL; nitem = next(nitem))
                    (OBJPTR(nitem))->o_flags &= ~ISCURSED;

                msg("Your pack glistens brightly.");
            }
            else
            {
                if ((nitem = get_item("remove the curse on", 0)) != NULL)
                {
                    obj = OBJPTR(nitem);
                    msg("Removed the curse from %s.", inv_name(obj, LOWERCASE));
                    obj->o_flags &= ~ISCURSED;

                    if (is_scroll)
                        know_items[TYP_SCROLL][S_REMOVECURSE] = TRUE;
                }
            }
            break;

        case S_PETRIFY:
            switch(CCHAR(mvinch(hero.y, hero.x)))
            {
                case TRAPDOOR:
                case DARTTRAP:
                case TELTRAP:
                case ARROWTRAP:
                case SLEEPTRAP:
                case BEARTRAP:
                case FIRETRAP:
                {
                    int n;

                    /* Find the right trap */
                    for (n = 0; n < ntraps && !ce(traps[n].tr_pos, hero); n++)
                        ;

                    ntraps--;

                    if (!ce(traps[n].tr_pos, hero))
                        msg("What a strange trap!");
                    else
                    {
                        while (n < ntraps)
                        {
                            traps[n] = traps[n + 1];
                            n++;
                        }
                    }

                    msg("The dungeon begins to rumble and shake!");
                    addch(WALL);

                    if (on(player, CANINWALL))
                    {
                        extinguish_fuse(FUSE_UNPHASE);
                        turn_off(player, CANINWALL);
                        msg("Your dizzy feeling leaves you.");
                    }

                    turn_on(player, ISINWALL);
                }
                break;

                case DOOR:
                case SECRETDOOR:
                {
                    struct room *rp = roomin(hero);
                    short   n;

                    /* Find the right door */

                    for (n=0; n<rp->r_nexits && !ce(rp->r_exit[n], hero); n++)
                        /* do nothing */ ;

                    rp->r_nexits--;

                    if (!ce(rp->r_exit[n], hero))
                        msg("What a strange door!");
                    else
                    {
                        while (n < rp->r_nexits)
                        {
                            rp->r_exit[n] = rp->r_exit[n + 1];
                            n++;
                        }
                    }
                    /* No break - fall through */
                }
                case FLOOR:
                case PASSAGE:
                    msg("The dungeon begins to rumble and shake!");
                    addch(WALL);

                    if (on(player, CANINWALL))
                    {
                        extinguish_fuse(FUSE_UNPHASE);
                        turn_off(player, CANINWALL);
                        msg("Your dizzy feeling leaves you.");
                    }

                    turn_on(player, ISINWALL);
                    break;

                default:
                    nothing_message(flags);
                    break;
            }
            break;

        case  S_GENOCIDE:
            msg("You have been granted the boon of genocide!--More--");

            wait_for(' ');
            msg("");

            genocide(flags);

            if (is_scroll)
                know_items[TYP_SCROLL][S_GENOCIDE] = TRUE;

            break;

        case S_PROTECT:
            if (is_scroll && know_items[TYP_SCROLL][S_PROTECT] == FALSE)
            {
                msg("You can protect something from rusting or theft.");
                know_items[TYP_SCROLL][S_PROTECT] = TRUE;
            }

            if ((item = get_item("protect", 0)) != NULL)
            {
                struct object   *lb = OBJPTR(item);

                if (cursed)
                {
                    lb->o_flags &= ~ISPROT;
                    mpos = 0;
                    msg("Unprotected %s.", inv_name(lb, LOWERCASE));
                }
                else
                {
                    lb->o_flags |= ISPROT;
                    mpos = 0;
                    msg("Protected %s.", inv_name(lb, LOWERCASE));
                }
            }
            break;

        case S_MAKEITEMEM:
            if (!is_scroll || rnd(luck))
                feel_message();
            else
            {
                char itemtype;

                if (is_scroll)
                    know_items[TYP_SCROLL][S_MAKEITEMEM] = TRUE;

                msg("You have been endowed with the power of creation.");

                if (blessed)
                    itemtype = '\0';
                else
                    switch (rnd(6))
                    {
                        case 0: itemtype = RING;    break;
                        case 1: itemtype = POTION;  break;
                        case 2: itemtype = SCROLL;  break;
                        case 3: itemtype = ARMOR;   break;
                        case 4: itemtype = WEAPON;  break;
                        case 5: itemtype = STICK;   break;
                    }

                flags |= SCR_MAGIC;
                buy_it(itemtype, flags);
            }
            break;

        case S_ENCHANT:
        {
            struct linked_list  *ll;
            struct object   *lb;
            int howmuch, flg=0;

            if (is_scroll && know_items[TYP_SCROLL][S_ENCHANT] == FALSE)
            {
                msg("You are granted the power of enchantment.");
                msg("You may enchant anything(weapon,ring,armor,scroll,potion)");
                know_items[TYP_SCROLL][S_ENCHANT] = TRUE;
            }

            if ((ll = get_item("enchant", 0)) != NULL)
            {
                lb = OBJPTR(ll);
                lb->o_flags &= ~ISCURSED;

                if (blessed)
                    howmuch = 2;
                else if (cursed)
                    howmuch = -1;
                else
                {
                    howmuch = 1;
                    flg |= ISBLESSED;
                }

                switch (lb->o_type)
                {
                    case RING:
                        lb->o_ac += howmuch;

                        if (lb->o_ac > 5 && rnd(5) == 0)
                        {
                            msg("Your ring explodes in a cloud of smoke.");
                            lb->o_flags &= ~ISCURSED;
                            dropcheck(lb);

                            switch (lb->o_which)
                            {
                                case R_ADDSTR:
                                    chg_str(-2, TRUE, FALSE);
                                    break;
                                case R_ADDHIT:
                                    chg_dext(-2, TRUE, FALSE);
                                    break;
                                case R_ADDINTEL:
                                    pstats.s_intel -= 2;
                                    max_stats.s_intel -= 2;
                                    break;
                                case R_ADDWISDOM:
                                    pstats.s_wisdom -= 2;
                                    max_stats.s_wisdom -= 2;
                                    break;
                            }

                            del_pack(ll);
                            lb = NULL;
                        }
                        else if (is_r_on(lb))
                            switch (lb->o_which)
                            {
                                case R_ADDSTR:
                                    pstats.s_str += howmuch;
                                    break;
                                case R_ADDHIT:
                                    pstats.s_dext += howmuch;
                                    break;
                                case R_ADDINTEL:
                                    pstats.s_intel += howmuch;
                                    break;
                                case R_ADDWISDOM:
                                    pstats.s_wisdom += howmuch;
                                    break;
                                case R_CARRYING:
                                    updpack();
                                    break;
                            }

                        break;

                    case ARMOR:
                        lb->o_ac -= howmuch;

                        if (armors[lb->o_which].a_class - lb->o_ac > 5 && rnd(5) == 0)
                        {
                            msg("Your %s explodes in a cloud of dust.",
                                inv_name(lb, LOWERCASE));

                            lb->o_flags &= ~ISCURSED;

                            if (lb == cur_armor)
                                pstats.s_hpt /= 2;

                            dropcheck(lb);
                            del_pack(ll);
                            lb = NULL;
                        }
                        break;

                    case STICK:
                        if (wizard || howmuch != 1 && rnd(5) == 0)
                            lb->o_flags |= flg;

                        lb->o_charges += howmuch + 10;

                        if (lb->o_charges < 0)
                            lb->o_charges = 0;

                        if (lb->o_charges > 50 && rnd(5) == 0)
                        {
                            msg("Your %s explodes into splinters.",
                                inv_name(lb, LOWERCASE));

                            lb->o_flags &= ~ISCURSED;
                            dropcheck(lb);
                            del_pack(ll);
                            lb = NULL;
                        }
                        break;

                    case WEAPON:
                        if (rnd(100) < 50)
                            lb->o_hplus += howmuch;
                        else
                            lb->o_dplus += howmuch;

                        if (lb->o_hplus + lb->o_dplus > 10 && rnd(5) == 0)
                        {
                            msg("Your %s explodes in a cloud of shrapnel",
                                inv_name(lb, LOWERCASE));

                            lb->o_flags &= ~ISCURSED;

                            if (lb == cur_weapon)
                                chg_dext(-2, FALSE, TRUE);

                            dropcheck(lb);
                            del_pack(ll);
                            lb = NULL;

                        }
                        break;

                    case POTION:
                    case SCROLL:
                    default:
                        lb->o_flags |= flg;
                        break;
                }

                mpos = 0;

                if (lb != NULL)
                    msg("Enchanted %s.", inv_name(lb, LOWERCASE));
            }
        }
        break;

        case S_NOTHING:
            nothing_message(flags);
            break;

        case S_SILVER:
        {
            struct object   *lb;

            if (is_scroll && know_items[TYP_SCROLL][S_SILVER] == FALSE)
            {
                msg("You are granted the power of magic hitting.");
                know_items[TYP_SCROLL][S_SILVER] = TRUE;
            }

            if ((item = get_item("annoint", WEAPON)) != NULL)
            {
                lb = OBJPTR(item);

                if (blessed && !(lb->o_flags & ISSILVER))
                {
                    lb->o_hplus += rnd(3) + 1;
                    lb->o_flags |= ISSILVER;
                    lb->o_flags |= ISMETAL;
                    msg("Your weapon has turned to silver!");
                }
                else if (cursed && (lb->o_flags & ISSILVER))
                {
                    lb->o_hplus -= (rnd(3) + 1);
                    lb->o_flags &= ~ISSILVER;
                    msg("Your silver weapon has turned to steel.");
                }
                else if (lb->o_flags & ISSILVER)
                {
                    msg("Your silver weapon glitters briefly.");
                    lb->o_hplus += rnd(2);
                }
                else
                {
                    lb->o_hplus += rnd(3);
                    lb->o_flags |= ISSILVER;
                    lb->o_flags |= ISMETAL;
                    msg("Your weapon has turned to silver.");
                }
            }
        }
        break;
        case S_OWNERSHIP:
        {
            struct linked_list  *ll;
            struct object   *lb;

            if (is_scroll && know_items[TYP_SCROLL][S_OWNERSHIP] == FALSE)
            {
                msg("You are granted the power of ownership.");
                know_items[TYP_SCROLL][S_OWNERSHIP] = TRUE;
            }

            if ((ll = get_item("claim", 0)) != NULL)
            {
                lb = OBJPTR(ll);

                if (cursed && lb->o_flags & (ISOWNED | CANRETURN))
                {
                    lb->o_flags &= ~(ISOWNED | CANRETURN);
                    msg("The gods seem to have forgotten you.");
                }
                else if (cursed && !(lb->o_flags & ISLOST))
                {
                    lb->o_flags |= ISLOST;
                    msg("The gods look the other way.");
                }
                else if (blessed && lb->o_flags & ISLOST)
                {
                    lb->o_flags |= CANRETURN;
                    msg("The gods seem to have remembered you.");
                }
                else if (blessed && !(lb->o_flags & ISOWNED))
                {
                    lb->o_flags |= (ISOWNED | CANRETURN);
                    msg("The gods smile upon you.");
                }
                else if (blessed | cursed)
                {
                    nothing_message(flags);
                }
                else
                {
                    lb->o_flags |= CANRETURN;
                    msg("The gods look upon you.");
                }
            }
        }
        break;

        case S_FOODDET:

            /* Scroll of food detection */

            if (cursed)
            {
                int n = roll(3, 6);
                int k;
                struct room *rp;
                coord   pos;

                msg("You begin to feel hungry and you smell food.");
                wclear(hw);

                for (k = 1; k < n; k++)
                {
                    rp = &rooms[rnd_room()];
                    rnd_pos(rp, &pos);
                    mvwaddch(hw, pos.y, pos.x, FOOD);
                }

                overlay(hw, cw);

                if (is_scroll)
                    know_items[TYP_SCROLL][S_FOODDET] = TRUE;

                break;
            }

            if (blessed)
                turn_on(player, BLESSFOOD);

            if (off(player, ISUNSMELL) && lvl_obj != NULL)
            {
                struct linked_list  *itm;
                struct object   *cur;
                struct thing    *th;
                int fcount = 0;
                int  same_room = FALSE;
                struct room *rp = roomin(hero);

                wclear(hw);

                for (itm = lvl_obj; itm != NULL; itm = next(itm))
                {
                    cur = OBJPTR(itm);

                    if (cur->o_type == FOOD)
                    {
                        fcount += cur->o_count;
                        mvwaddch(hw, cur->o_pos.y, cur->o_pos.x, FOOD);

                        if (roomin(cur->o_pos) == rp)
                            same_room = TRUE;
                    }
                }

                for (itm = mlist; itm != NULL; itm = next(itm))
                {
                    struct linked_list  *pitem;

                    th = THINGPTR(itm);

                    for (pitem = th->t_pack; pitem != NULL; pitem = next(pitem))
                    {
                        cur = OBJPTR(pitem);

                        if (cur->o_type == FOOD)
                        {
                            fcount += cur->o_count;
                            mvwaddch(hw, th->t_pos.y, th->t_pos.x, FOOD);

                            if (roomin(th->t_pos) == rp)
                                same_room = TRUE;
                        }
                    }
                }

                if (fcount)
                {
                    if (is_scroll)
                        know_items[TYP_SCROLL][S_FOODDET] = TRUE;

                    if (same_room)
                        msg("FOOOOD!!");
                    else
                        msg("You begin to feel hungry and you smell food.");

                    overlay(hw, cw);
                    break;
                }
            }

            if (off(player, ISUNSMELL))
                msg("You can't smell anything.");
            else
                nothing_message(flags);

            break;

        case S_ELECTRIFY:
            if (on(player, ISELECTRIC))
            {
                msg("Your violet glow brightens for an instant.");
                lengthen_fuse(FUSE_UNELECTRIFY, 4 + rnd(8));
            }
            else
            {
                msg("Your body begins to glow violet and shoot sparks.");
                turn_on(player, ISELECTRIC);
                light_fuse(FUSE_UNELECTRIFY,0,(blessed?3:1)*WANDERTIME, AFTER);
                light(&hero);
            }

            if (is_scroll)
                know_items[TYP_SCROLL][S_ELECTRIFY] = TRUE;

            break;

        case S_CHARM:

            /*
             * Beauty, brains and experience make a person charming.
             * Unique monsters can never be charmed.
             */

            charm_power = pstats.s_charisma / 2 + pstats.s_lvl / 3 + max(0, pstats.s_intel - 15);

            if (cursed)
            {
                msg("You hear harsh, dissonant twanging throughout the dungeon.");
                aggravate();
            }
            else if (blessed)  /* Charm entire level */
            {
                struct linked_list  *mon;

                msg("You hear ringingly meliflous music all around you.");

                for (mon = mlist; mon != NULL; mon = next(mon))
                {
                    struct thing    *th = THINGPTR(mon);

                    if (th->t_stats.s_intel < charm_power && off(*th, ISUNIQUE))
                    {
                        turn_on(*th, ISCHARMED);
                        chase_it(&th->t_pos, &player);
                    }
                }
            }
            else        /* Charm all monsters within two spaces of the hero */
            {
                int x, y;
                struct linked_list  *mon;

                msg("You hear soft, lyrical music all around you.");

                for (x = hero.x - 2; x <= hero.x + 2; x++)
                    for (y = hero.y - 2; y <= hero.y + 2; y++)
                        if (y > 0 && x > 0 && isalpha(mvwinch(mw, y, x)))
                        {
                            if ((mon = find_mons(y, x)) != NULL)
                            {
                                struct thing    *th;

                                th = THINGPTR(mon);

                                if (th->t_stats.s_intel < charm_power && off(*th, ISUNIQUE))
                                {
                                    turn_on(*th, ISCHARMED);
                                    chase_it(&th->t_pos, &player);
                                }
                            }
                        }
            }
            break;

        case S_SUMMON:
        {
            struct linked_list  *llp;
            struct thing    *tp;
            int mon_type;

            if (on(player, HASSUMMONED))
            {
                nothing_message(flags);
                break;
            }

            if (cursed)
            {
                creat_mons(&player, (short) 0, MESSAGE);
                break;
            }

            if (blessed)    /* Summon a possibly very high monster */
            {
                int nsides = max(2, max(pstats.s_lvl, 12) - luck);

                mon_type = roll(nsides, rnd(pstats.s_charisma + 15) + 8);
                mon_type = min(mon_type, nummonst);
            }
            else
                mon_type = 0;

	    llp = summon_monster((short) mon_type, NOFAMILIAR, NOMESSAGE);

            if (llp)
            {
                tp = THINGPTR(llp);
                turn_on(*tp, WASSUMMONED);
                turn_on(player, HASSUMMONED);
                msg("You have summoned a %s.", monsters[tp->t_index].m_name);
                light_fuse(FUSE_UNSUMMON, llp, WANDERTIME + rnd(pstats.s_lvl), AFTER);
            }
        }
        break;

        case S_REFLECT:
            if (on(player, CANREFLECT))
            {
                msg("The sparkling around you brightens momentarily.");
                lengthen_fuse(FUSE_UNGAZE, 5 + rnd(10));
            }
            else
            {
                msg("Shiny particles sparkle all around you.");
                turn_on(player, CANREFLECT);
                light_fuse(FUSE_UNGAZE, 0, (blessed ? 3 : 1) * WANDERTIME, AFTER);
            }
            break;

        case S_SUMFAMILIAR:
        {
            int type = 0;

            if (on(player, HASFAMILIAR))
            {
                msg("But you already have a familiar - somewhere...");
                return;
            }

            if (wizard)
                type = get_monster_number("be your familiar");
            else if (blessed)  /* Summon a possibly very high monster */
            {
                int nsides = max(2, max(pstats.s_lvl, 12) - luck);

                type = roll(nsides, rnd(pstats.s_charisma + 15) + 8);
                type = min(type, nummonst);
            }
            else if (cursed)    /* Summon a bat, maggot, eye, etc */
            {
                type = rnd(20) + 1; 
				
                if (summon_monster(type, FAMILIAR, MESSAGE))
                    turn_on(player, HASFAMILIAR);
            }
        }
        break;

        case S_FEAR:

            /* if cursed, you get frightened */

            if (cursed)
            {
                if (off(player, SUPERHERO) && (player.t_ctype != C_PALADIN) && !save(VS_DEATH))
                    msg("A momentary wave of panic sweeps over you.");
                else
                {
                    msg("Panicstricken, you fall into a coma.");
                    no_command += roll(2, SLEEPTIME);
                }
            }
            else
            {
                /*
                 * terrify monster scroll.  frightens all monsters
                 * within 2 spaces
                 */
                int x, y;
                struct linked_list  *mon;
                int  gotone = FALSE;

                for (x = hero.x - 2; x <= hero.x + 2; x++)
                {
                    for (y = hero.y - 2; y <= hero.y + 2; y++)
                    {
                        if (y > 0 && x > 0 && isalpha(mvwinch(mw, y, x)))
                        {
                            if ((mon = find_mons(y, x)) != NULL)
                            {
                                struct thing    *th;

                                th = THINGPTR(mon);

                                if (on(*th, ISUNDEAD) || on(*th, ISUNIQUE))
                                    continue;

                                gotone = TRUE;
                                turn_on(*th, ISFLEE);
                                th->t_chasee = &player;
                                th->t_ischasing = FALSE;
                                th->t_horde = NULL;
                            }
                        }
                    }
                }

                if (gotone)
                    seemsg("The monster(s) around you recoil in horror.");
                else
                    nothing_message(flags);
            }
            break;

        case  S_MSHIELD:  /* deal with blessed/cursed later */
            if (on(player, HASMSHIELD))
            {
                seemsg("The fog around you thickens.");
                lengthen_fuse(FUSE_UNMSHIELD, (blessed ? 3 : 1) * HEROTIME);
            }
            else
            {
                seemsg("A fog forms around you.");
                turn_on(player, HASMSHIELD);
                light_fuse(FUSE_UNMSHIELD, 0, (blessed ? 3 : 1) * HEROTIME, AFTER);
            }

            if (is_scroll)
                know_items[TYP_SCROLL][S_MSHIELD] = TRUE;

            break;

        default:
            msg("What a puzzling scroll!");
            return;
    }

    look(TRUE);     /* put the result of the scroll on the screen */
    status(FALSE);

    if (is_scroll)
    {
        if (know_items[TYP_SCROLL][which] && guess_items[TYP_SCROLL][which])
        {
            ur_free(guess_items[TYP_SCROLL][which]);
            guess_items[TYP_SCROLL][which] = NULL;
        }
        else if (askme && !know_items[TYP_SCROLL][which] && guess_items[TYP_SCROLL][which] == NULL)
        {
            msg("What do you want to call it? ");

            if (get_string(buf, cw) == NORM)
            {
                guess_items[TYP_SCROLL][which] = new_alloc(strlen(buf) + 1);
                strcpy(guess_items[TYP_SCROLL][which], buf);
            }
        }
    }
}

/*
    creat_mons()
        creates the specified monster -- any if 0
*/

struct linked_list  *
creat_mons(struct thing *person, int monster, int message)
{
    coord   mp;

    /* Search for an open place */

    debug("Creator @(%d, %d) ", person->t_pos.y, person->t_pos.x);

    if ((place_mons(person->t_pos.y, person->t_pos.x, &mp)) != FALSE)
    {
        struct linked_list *nitem;

        nitem = new_item(sizeof(struct thing));
        new_monster(nitem, monster == 0 ? randmonster(NOWANDER, NOGRAB)
                : monster, &mp, MAXSTATS);
        chase_it(&mp, &player);

        /* If the monster is on a trap, trap it */

        if (isatrap(mvinch(mp.y, mp.x)))
        {
            debug("Monster trapped during creat_mons.");
            be_trapped(THINGPTR(nitem), mp);
        }

        light(&hero);
        return(nitem);
    }

    if (message)
        hearmsg("You hear a faint cry of anguish in the distance.");

    return(NULL);
}

/*
    place_mons()
        finds a place to put the monster
*/

int
place_mons(int y, int x, coord *pos)
{
    int distance, xx, yy, appears;

    for (distance = 1; distance <= 10; distance++)
    {
        appears = 0;

        for (yy = y - distance; yy <= y + distance; yy++)
            for (xx = x - distance; xx <= x + distance; xx++)
            {
                /* Don't put a monster in top of the creator or player */

                if (xx < 0 || yy < 0)
                    continue;

                if (yy == y && xx == x)
                    continue;

                if (yy == hero.y && xx == hero.x)
                    continue;

                /* Or anything else nasty */

                if (step_ok(yy, xx, NOMONST, FALSE))
                {
                    if (rnd(max(1, (10 * distance - ++appears))) == 0)
                    {
                        pos->y = yy;
                        pos->x = xx;
                        debug("Make monster dist %d appear %d @(%d, %d) ",
                              distance, appears, pos->y, pos->x);
                        return(TRUE);
                    }
                }
            }
    }
    return(FALSE);
}

/*
    is_t_on()
        This subroutine determines if an object that is a ring is being
        worn by the hero  by Bruce Dautrich 4/3/84
 */

int
is_r_on(struct object *obj)
{
    if (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])
    {
        return(TRUE);
    }

    return(FALSE);
}

/*
    monread()
        monster gets the effect
*/

void
monread(struct thing *reader, int which, int flags)
{
    struct stats    *curp = &(reader->t_stats);
    struct stats    *maxp = &(reader->maxstats);
    int blessed = flags & ISBLESSED;
    int cursed = flags & ISCURSED;

    switch (which)
    {
        case S_SELFTELEP:
            /* If monster was suffocating, stop it */
            if (on(*reader, DIDSUFFOCATE))
            {
                turn_off(*reader, DIDSUFFOCATE);
                extinguish_fuse(FUSE_SUFFOCATE);
            }

            /* If monster held us, stop it */

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

            turn_off(*reader, DIDHOLD);

            if (cursed)
                reader->t_no_move++;
            else
            {
                int rm;

                if (blessed)    /* Give him his hit points */
                    curp->s_hpt = maxp->s_hpt;

                /* Erase the monster from the old position */

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

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

                /* Get a new position */

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

                /* Put it there */

                mvwaddch(mw, reader->t_pos.y, reader->t_pos.x, reader->t_type);
                reader->t_oldch = CCHAR( mvwinch(cw, reader->t_pos.y, reader->t_pos.x) );
            }
            break;

        default:
            debug("'%s' is a strange scroll for a monster to read!",
                  r_magic[which].mi_name);
            break;
    }
}