magic.c

Go to the documentation of this file.

/***************************************************************************
 *  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
 *  Michael Seifert, Hans Henrik Strfeldt, Tom Madsen, and Katja Nyboe.    *
 *                                                                         *
 *  Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael          *
 *  Chastain, Michael Quan, and Mitchell Tse.                              *
 *                                                                         *
 *  In order to use any part of this Merc Diku Mud, you must comply with   *
 *  both the original Diku license in 'license.doc' as well the Merc       *
 *  license in 'license.txt'.  In particular, you may not remove either of *
 *  these copyright notices.                                               *
 *                                                                         *
 *  Much time and thought has gone into this software and you are          *
 *  benefitting.  We hope that you share your changes too.  What goes      *
 *  around, comes around.                                                  *
 ***************************************************************************/

/***************************************************************************
 *  ROM 2.4 is copyright 1993-1998 Russ Taylor                             *
 *  ROM has been brought to you by the ROM consortium                      *
 *      Russ Taylor (rtaylor@hypercube.org)                                *
 *      Gabrielle Taylor (gtaylor@hypercube.org)                           *
 *      Brian Moore (zump@rom.org)                                         *
 *  By using this code, you have agreed to follow the terms of the         *
 *  ROM license, in the file Rom24/doc/rom.license                         *
 ***************************************************************************/


#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "merc.h"
#include "interp.h"
#include "magic.h"
#include "recycle.h"

/*
 * Local functions.
 */
void say_spell args ((CHAR_DATA * ch, int sn));

/* imported functions */
bool remove_obj args ((CHAR_DATA * ch, int iWear, bool fReplace));
void wear_obj args ((CHAR_DATA * ch, OBJ_DATA * obj, bool fReplace));



/*
 * Lookup a skill by name.
 */
int skill_lookup (const char *name)
{
    int sn;

    for (sn = 0; sn < MAX_SKILL; sn++)
    {
        if (skill_table[sn].name == NULL)
            break;
        if (LOWER (name[0]) == LOWER (skill_table[sn].name[0])
            && !str_prefix (name, skill_table[sn].name))
            return sn;
    }

    return -1;
}

int find_spell (CHAR_DATA * ch, const char *name)
{
    /* finds a spell the character can cast if possible */
    int sn, found = -1;

    if (IS_NPC (ch))
        return skill_lookup (name);

    for (sn = 0; sn < MAX_SKILL; sn++)
    {
        if (skill_table[sn].name == NULL)
            break;
        if (LOWER (name[0]) == LOWER (skill_table[sn].name[0])
            && !str_prefix (name, skill_table[sn].name))
        {
            if (found == -1)
                found = sn;
            if (ch->level >= skill_table[sn].skill_level[ch->class]
                && ch->pcdata->learned[sn] > 0)
                return sn;
        }
    }
    return found;
}



/*
 * Lookup a skill by slot number.
 * Used for object loading.
 */
int slot_lookup (int slot)
{
    extern bool fBootDb;
    int sn;

    if (slot <= 0)
        return -1;

    for (sn = 0; sn < MAX_SKILL; sn++)
    {
        if (slot == skill_table[sn].slot)
            return sn;
    }

    if (fBootDb)
    {
        bug ("Slot_lookup: bad slot %d.", slot);
        abort ();
    }

    return -1;
}



/*
 * Utter mystical words for an sn.
 */
void say_spell (CHAR_DATA * ch, int sn)
{
    char buf[MAX_STRING_LENGTH];
    char buf2[MAX_STRING_LENGTH];
    CHAR_DATA *rch;
    char *pName;
    int iSyl;
    int length;

    struct syl_type {
        char *old;
        char *new;
    };

    static const struct syl_type syl_table[] = {
        {" ", " "},
        {"ar", "abra"},
        {"au", "kada"},
        {"bless", "fido"},
        {"blind", "nose"},
        {"bur", "mosa"},
        {"cu", "judi"},
        {"de", "oculo"},
        {"en", "unso"},
        {"light", "dies"},
        {"lo", "hi"},
        {"mor", "zak"},
        {"move", "sido"},
        {"ness", "lacri"},
        {"ning", "illa"},
        {"per", "duda"},
        {"ra", "gru"},
        {"fresh", "ima"},
        {"re", "candus"},
        {"son", "sabru"},
        {"tect", "infra"},
        {"tri", "cula"},
        {"ven", "nofo"},
        {"a", "a"}, {"b", "b"}, {"c", "q"}, {"d", "e"},
        {"e", "z"}, {"f", "y"}, {"g", "o"}, {"h", "p"},
        {"i", "u"}, {"j", "y"}, {"k", "t"}, {"l", "r"},
        {"m", "w"}, {"n", "i"}, {"o", "a"}, {"p", "s"},
        {"q", "d"}, {"r", "f"}, {"s", "g"}, {"t", "h"},
        {"u", "j"}, {"v", "z"}, {"w", "x"}, {"x", "n"},
        {"y", "l"}, {"z", "k"},
        {"", ""}
    };

    buf[0] = '\0';
    for (pName = skill_table[sn].name; *pName != '\0'; pName += length)
    {
        for (iSyl = 0; (length = strlen (syl_table[iSyl].old)) != 0; iSyl++)
        {
            if (!str_prefix (syl_table[iSyl].old, pName))
            {
                strcat (buf, syl_table[iSyl].new);
                break;
            }
        }

        if (length == 0)
            length = 1;
    }

    sprintf (buf2, "$n utters the words, '%s'.", buf);
    sprintf (buf, "$n utters the words, '%s'.", skill_table[sn].name);

    for (rch = ch->in_room->people; rch; rch = rch->next_in_room)
    {
        if (rch != ch)
            act ((!IS_NPC (rch) && ch->class == rch->class) ? buf : buf2,
                 ch, NULL, rch, TO_VICT);
    }

    return;
}



/*
 * Compute a saving throw.
 * Negative apply's make saving throw better.
 */
bool saves_spell (int level, CHAR_DATA * victim, int dam_type)
{
    int save;

    save = 50 + (victim->level - level) * 5 - victim->saving_throw * 2;
    //if (IS_AFFECTED (victim, AFF_BERSERK))
    //    save += victim->level / 2;

    switch (check_immune (victim, dam_type))
    {
        case IS_IMMUNE:
            return TRUE;
        case IS_RESISTANT:
            save += 2;
            break;
        case IS_VULNERABLE:
            save -= 2;
            break;
    }

    if (!IS_NPC (victim) && class_table[victim->class].fMana)
        save = 9 * save / 10;
    save = URANGE (5, save, 95);
   //char buf[MAX_STRING_LENGTH];
   // sprintf(buf, "%d - saving throw\n\r", save);
   // send_to_char(buf,victim);
    return number_percent () < save;
}

/* RT save for dispels */

bool saves_dispel (int dis_level, int spell_level, int duration)
{
    int save;

    if (duration == -1)
        spell_level += 5;
    /* very hard to dispel permanent effects */

    save = 50 + (spell_level - dis_level) * 5;
    save = URANGE (5, save, 95);
    //rintf_to_char(victim, "%d (dispell) save throw", save);
    
    return number_percent () < save;
}

/* co-routine for dispel magic and cancellation */

bool check_dispel (int dis_level, CHAR_DATA * victim, int sn)
{
    AFFECT_DATA *af;

    if (is_affected (victim, sn))
    {
        for (af = victim->affected; af != NULL; af = af->next)
        {
            if (af->type == sn)
            {
                if (!saves_dispel (dis_level, af->level, af->duration))
                {
                    affect_strip (victim, sn);
                    if (skill_table[sn].msg_off)
                    {
                        send_to_char (skill_table[sn].msg_off, victim);
                        send_to_char ("\n\r", victim);
                    }
                    return TRUE;
                }
                else
                    af->level--;
            }
        }
    }
    return FALSE;
}

/* for finding mana costs -- temporary version */
int mana_cost (CHAR_DATA * ch, int min_mana, int level)
{
    if (ch->level + 2 == level)
        return 1000;
    return UMAX (min_mana, (100 / (2 + ch->level - level)));
}



/*
 * The kludgy global is for spells who want more stuff from command line.
 */
char *target_name;

void do_cast (CHAR_DATA * ch, char *argument)
{
    char arg1[MAX_INPUT_LENGTH];
    char arg2[MAX_INPUT_LENGTH];
    CHAR_DATA *victim;
    OBJ_DATA *obj;
    void *vo;
    int mana;
    int sn;
    int target;

    /*
     * Switched NPC's can cast spells, but others can't.
     */
    if (IS_NPC (ch) && ch->desc == NULL)
        return;

    target_name = one_argument (argument, arg1);
    one_argument (target_name, arg2);

    if (arg1[0] == '\0')
    {
        send_to_char ("Cast which what where?\n\r", ch);
        return;
    }

    if ((sn = find_spell (ch, arg1)) < 1
        || skill_table[sn].spell_fun == spell_null || (!IS_NPC (ch)
                                                       && (ch->level <
                                                           skill_table
                                                           [sn].skill_level
                                                           [ch->class]
                                                           || ch->
                                                           pcdata->learned[sn]
                                                           == 0)))
    {
        send_to_char ("You don't know any spells of that name.\n\r", ch);
        return;
    }

    if (ch->position < skill_table[sn].minimum_position)
    {
        send_to_char ("You can't concentrate enough.\n\r", ch);
        return;
    }

    if (ch->level + 2 == skill_table[sn].skill_level[ch->class])
        mana = 50;
    else
        mana = UMAX (skill_table[sn].min_mana,
                     100 / (2 + ch->level -
                            skill_table[sn].skill_level[ch->class]));

    /*
     * Locate targets.
     */
    victim = NULL;
    obj = NULL;
    vo = NULL;
    target = TARGET_NONE;

    switch (skill_table[sn].target)
    {
        default:
            bug ("Do_cast: bad target for sn %d.", sn);
            return;

        case TAR_IGNORE:
            break;

        case TAR_CHAR_OFFENSIVE:
            if (arg2[0] == '\0')
            {
                if ((victim = ch->fighting) == NULL)
                {
                    send_to_char ("Cast the spell on whom?\n\r", ch);
                    return;
                }
            }
            else
            {
          /*     if (!str_cmp(target_name, "all") && ch->level > 52)
        {
            char at_buf[MAX_STRING_LENGTH];
            
            for (d = descriptor_list; d != NULL; d = d->next)
            {
                if (IS_NPC(d->character))
                    continue;
                free_string(at_buf);
                strcat(at_buf, d->character->name);
                strcat(at_buf, " ");
                strcat(at_buf, "c ");
                strcat(at_buf, arg1);
                strcat(at_buf, d->character->name);
                do_function(ch, &do_at,at_buf );
                
            }
        }*/
        if ((victim = get_char_room (ch, target_name)) == NULL)
                {
                    send_to_char ("They aren't here.\n\r", ch);
                    return;
                }
            }
/*
        if ( ch == victim )
        {
            send_to_char( "You can't do that to yourself.\n\r", ch );
            return;
        }
*/

        extern bool global_peace;
        if (global_peace)
        {
            send_to_char("The gods of peace have spoken. There will be no fighting.\n\r",ch);
            return;
        }

            if (!IS_NPC (ch))
            {

                if (is_safe (ch, victim) && victim != ch)
                {
                    send_to_char ("Not on that target.\n\r", ch);
                    return;
                }
                check_killer (ch, victim);
            }
/*
            if (!IS_NPC(victim) && ch->clan == 0 && victim != ch)
        {
            send_to_char("Join a clan if you wish to attack players.\n\r",ch);
            return;
        }
        if (!IS_NPC(victim) && victim->clan == 0 && victim != ch)
        {
            send_to_char("They are not in a clan.\n\r",ch);
            return;
        }
*/
        if (IS_AFFECTED (ch, AFF_CHARM) && ch->master == victim)
            {
                send_to_char ("You can't do that on your own follower.\n\r",
                              ch);
                return;
            }

            vo = (void *) victim;
            target = TARGET_CHAR;
            break;

        case TAR_CHAR_DEFENSIVE:
            if (arg2[0] == '\0')
            {
                victim = ch;
            }
            else
            {
                if ((victim = get_char_room (ch, target_name)) == NULL)
                {
                    send_to_char ("They aren't here.\n\r", ch);
                    return;
                }
            }

            vo = (void *) victim;
            target = TARGET_CHAR;
            break;

        case TAR_CHAR_SELF:
            if (arg2[0] != '\0' && !is_name (target_name, ch->name))
            {
                send_to_char ("You cannot cast this spell on another.\n\r",
                              ch);
                return;
            }

            vo = (void *) ch;
            target = TARGET_CHAR;
            break;

        case TAR_OBJ_INV:
            if (arg2[0] == '\0')
            {
                send_to_char ("What should the spell be cast upon?\n\r", ch);
                return;
            }

            if ((obj = get_obj_carry (ch, target_name, ch)) == NULL)
            {
                send_to_char ("You are not carrying that.\n\r", ch);
                return;
            }

            vo = (void *) obj;
            target = TARGET_OBJ;
            break;

        case TAR_OBJ_CHAR_OFF:
            if (arg2[0] == '\0')
            {
                if ((victim = ch->fighting) == NULL)
                {
                    send_to_char ("Cast the spell on whom or what?\n\r", ch);
                    return;
                }

                target = TARGET_CHAR;
            }
            else if ((victim = get_char_room (ch, target_name)) != NULL)
            {
                target = TARGET_CHAR;
            }

            if (target == TARGET_CHAR)
            {                    /* check the sanity of the attack */
                if ((is_safe_spell (ch, victim, FALSE) && victim != ch))
                {
                    send_to_char ("Not on that target.\n\r", ch);
                    return;
                }
        /*if (!IS_NPC(victim) && ch->clan == 0 &&!IS_NPC(ch) && victim != ch)
        {
            send_to_char("Join a clan if you wish to attack players.\n\r",ch);
            return;
        }
        if (!IS_NPC(victim) && !IS_NPC(ch) && victim->clan == 0 && victim != ch)
        {
            send_to_char("They are not in a clan.\n\r",ch);
            return;
        }*/


                if (IS_AFFECTED (ch, AFF_CHARM) && ch->master == victim)
                {
                    send_to_char
                        ("You can't do that on your own follower.\n\r", ch);
                    return;
                }

                if (!IS_NPC (ch))
                    check_killer (ch, victim);

                vo = (void *) victim;
            }
            else if ((obj = get_obj_here (ch, target_name)) != NULL)
            {
                vo = (void *) obj;
                target = TARGET_OBJ;
            }
            else
            {
                send_to_char ("You don't see that here.\n\r", ch);
                return;
            }
            break;

        case TAR_OBJ_CHAR_DEF:
            if (arg2[0] == '\0')
            {
                vo = (void *) ch;
                target = TARGET_CHAR;
            }
            else if ((victim = get_char_room (ch, target_name)) != NULL)
            {
                vo = (void *) victim;
                target = TARGET_CHAR;
            }
            else if ((obj = get_obj_carry (ch, target_name, ch)) != NULL)
            {
                vo = (void *) obj;
                target = TARGET_OBJ;
            }
            else
            {
                send_to_char ("You don't see that here.\n\r", ch);
                return;
            }
            break;
    }

    if (!IS_NPC (ch) && ch->mana < mana)
    {
        send_to_char ("You don't have enough mana.\n\r", ch);
        return;
    }

    if (str_cmp (skill_table[sn].name, "ventriloquate"))
        say_spell (ch, sn);

   if (ch->level > 51)
   {
   }
   else
   {
       WAIT_STATE (ch, skill_table[sn].beats);
   }
   

    if (number_percent () > get_skill (ch, sn))
    {
        send_to_char ("You lost your concentration.\n\r", ch);
        check_improve (ch, sn, FALSE, 1);
        if (ch->level > 51)
    {
    }
    else{
        
    ch->mana -= mana / 2;
    }
    }
    else
    {
        if (ch->level > 51) {}else {ch->mana -= mana;}
        if (IS_NPC (ch) || class_table[ch->class].fMana)
            /* class has spells */
            (*skill_table[sn].spell_fun) (sn, ch->level, ch, vo, target);
        else
            (*skill_table[sn].spell_fun) (sn, 3 * ch->level / 4, ch, vo, target);
        check_improve (ch, sn, TRUE, 1);
    }

    if ((skill_table[sn].target == TAR_CHAR_OFFENSIVE
         || (skill_table[sn].target == TAR_OBJ_CHAR_OFF
             && target == TARGET_CHAR)) && victim != ch
        && victim->master != ch)
    {
        CHAR_DATA *vch;
        CHAR_DATA *vch_next;

        for (vch = ch->in_room->people; vch; vch = vch_next)
        {
            vch_next = vch->next_in_room;
            if (victim == vch && victim->fighting == NULL)
            {
                check_killer (victim, ch);
                multi_hit (victim, ch, TYPE_UNDEFINED);
                break;
            }
        }
    }

    return;
}



/*
 * Cast spells at targets using a magical object.
 */
void obj_cast_spell (int sn, int level, CHAR_DATA * ch, CHAR_DATA * victim,
                     OBJ_DATA * obj)
{
    void *vo;
    extern bool global_peace;
    int target = TARGET_NONE;

    if (sn <= 0)
        return;

    if (sn >= MAX_SKILL || skill_table[sn].spell_fun == 0)
    {
        bug ("Obj_cast_spell: bad sn %d.", sn);
        return;
    }

    switch (skill_table[sn].target)
    {
        default:
            bug ("Obj_cast_spell: bad target for sn %d.", sn);
            return;

        case TAR_IGNORE:
            vo = NULL;
            break;

        case TAR_CHAR_OFFENSIVE:
            if (victim == NULL)
                victim = ch->fighting;
            if (victim == NULL)
            {
                send_to_char ("You can't do that.\n\r", ch);
                return;
            }
            if (global_peace)
        {
            send_to_char("The gods of peace have spoken. There will be no fighting\n\r",ch);
            return;
        }
        
        if (is_safe (ch, victim) && ch != victim)
            {
                send_to_char ("Something isn't right...\n\r", ch);
                return;
            }
            vo = (void *) victim;
            target = TARGET_CHAR;
            break;

        case TAR_CHAR_DEFENSIVE:
        case TAR_CHAR_SELF:
            if (victim == NULL)
                victim = ch;
            vo = (void *) victim;
            target = TARGET_CHAR;
            break;

        case TAR_OBJ_INV:
            if (obj == NULL)
            {
                send_to_char ("You can't do that.\n\r", ch);
                return;
            }
            vo = (void *) obj;
            target = TARGET_OBJ;
            break;

        case TAR_OBJ_CHAR_OFF:
            if (victim == NULL && obj == NULL)
            {
                if (ch->fighting != NULL)
                    victim = ch->fighting;
                else
                {
                    send_to_char ("You can't do that.\n\r", ch);
                    return;
                }
            }

            if (victim != NULL)
            {
                if (is_safe_spell (ch, victim, FALSE) && ch != victim)
                {
                    send_to_char ("Somehting isn't right...\n\r", ch);
                    return;
                }

                vo = (void *) victim;
                target = TARGET_CHAR;
            }
            else
            {
                vo = (void *) obj;
                target = TARGET_OBJ;
            }
            break;


        case TAR_OBJ_CHAR_DEF:
            if (victim == NULL && obj == NULL)
            {
                vo = (void *) ch;
                target = TARGET_CHAR;
            }
            else if (victim != NULL)
            {
                vo = (void *) victim;
                target = TARGET_CHAR;
            }
            else
            {
                vo = (void *) obj;
                target = TARGET_OBJ;
            }

            break;
    }

    target_name = "";
    (*skill_table[sn].spell_fun) (sn, level, ch, vo, target);



    if ((skill_table[sn].target == TAR_CHAR_OFFENSIVE
         || (skill_table[sn].target == TAR_OBJ_CHAR_OFF
             && target == TARGET_CHAR)) && victim != ch
        && victim->master != ch)
    {
        CHAR_DATA *vch;
        CHAR_DATA *vch_next;

        for (vch = ch->in_room->people; vch; vch = vch_next)
        {
            vch_next = vch->next_in_room;
            if (victim == vch && victim->fighting == NULL)
            {
                check_killer (victim, ch);
                multi_hit (victim, ch, TYPE_UNDEFINED);
                break;
            }
        }
    }

    return;
}



/*
 * Spell functions.
 */
void spell_tribul_kill (int sn, int level, CHAR_DATA *ch, void *vo, int target)
{
    CHAR_DATA *victim = (CHAR_DATA*) vo;
    int dam;
    int i;
    for (i=0;i <10;i++)
    {
    dam = dice(level, 500);
if (saves_spell(level, victim, DAM_ACID))
        dam /=2;
    damage (ch,victim,dam,sn,DAM_ACID, TRUE);
    }
    return;
}

void spell_acid_blast (int sn, int level, CHAR_DATA * ch, void *vo,
                       int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    int dam;

    dam = dice (level, 12);
    if (saves_spell (level, victim, DAM_ACID))
        dam /= 2;
    damage (ch, victim, dam, sn, DAM_ACID, TRUE);
    return;
}



void spell_armor (int sn, int level, CHAR_DATA * ch, void *vo, int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    AFFECT_DATA af;

    if (is_affected (victim, sn))
    {
        if (victim == ch)
            send_to_char ("You are already armored.\n\r", ch);
        else
            act ("$N is already armored.", ch, NULL, victim, TO_CHAR);
        return;
    }
    af.where = TO_AFFECTS;
    af.type = sn;
    af.level = level;
    af.duration = 24;
    af.modifier = -20;
    af.location = APPLY_AC;
    af.bitvector = 0;
    affect_to_char (victim, &af);
    send_to_char ("You feel someone protecting you.\n\r", victim);
    if (ch != victim)
        act ("$N is protected by your magic.", ch, NULL, victim, TO_CHAR);
    return;
}



void spell_bless (int sn, int level, CHAR_DATA * ch, void *vo, int target)
{
    CHAR_DATA *victim;
    OBJ_DATA *obj;
    AFFECT_DATA af;

    /* deal with the object case first */
    if (target == TARGET_OBJ)
    {
        obj = (OBJ_DATA *) vo;
        if (IS_OBJ_STAT (obj, ITEM_BLESS))
        {
            act ("$p is already blessed.", ch, obj, NULL, TO_CHAR);
            return;
        }

        if (IS_OBJ_STAT (obj, ITEM_EVIL))
        {
            AFFECT_DATA *paf;

            paf = affect_find (obj->affected, gsn_curse);
            if (!saves_dispel
                (level, paf != NULL ? paf->level : obj->level, 0))
            {
                if (paf != NULL)
                    affect_remove_obj (obj, paf);
                act ("$p glows a pale blue.", ch, obj, NULL, TO_ALL);
                REMOVE_BIT (obj->extra_flags, ITEM_EVIL);
                return;
            }
            else
            {
                act ("The evil of $p is too powerful for you to overcome.",
                     ch, obj, NULL, TO_CHAR);
                return;
            }
        }

        af.where = TO_OBJECT;
        af.type = sn;
        af.level = level;
        af.duration = 6 + level;
        af.location = APPLY_SAVES;
        af.modifier = -1;
        af.bitvector = ITEM_BLESS;
        affect_to_obj (obj, &af);

        act ("$p glows with a holy aura.", ch, obj, NULL, TO_ALL);

        if (obj->wear_loc != WEAR_NONE)
            ch->saving_throw -= 1;
        return;
    }

    /* character target */
    victim = (CHAR_DATA *) vo;


    if (victim->position == POS_FIGHTING || is_affected (victim, sn))
    {
        if (victim == ch)
            send_to_char ("You are already blessed.\n\r", ch);
        else
            act ("$N already has divine favor.", ch, NULL, victim, TO_CHAR);
        return;
    }

    af.where = TO_AFFECTS;
    af.type = sn;
    af.level = level;
    af.duration = 6 + level;
    af.location = APPLY_HITROLL;
    af.modifier = level / 8;
    af.bitvector = 0;
    affect_to_char (victim, &af);

    af.location = APPLY_SAVING_SPELL;
    af.modifier = 0 - level / 8;
    affect_to_char (victim, &af);
    send_to_char ("You feel righteous.\n\r", victim);
    if (ch != victim)
        act ("You grant $N the favor of your god.", ch, NULL, victim,
             TO_CHAR);
    return;
}



void spell_blindness (int sn, int level, CHAR_DATA * ch, void *vo, int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    AFFECT_DATA af;

    if (IS_AFFECTED (victim, AFF_BLIND))
    {
        send_to_char("They are already blind!\n\r",ch);
        return;
    }
    if (saves_spell (level, victim, DAM_OTHER))
    {
        send_to_char("You failed.\n\r",ch);
        return;
    }
    


    af.where = TO_AFFECTS;
    af.type = sn;
    af.level = level;
    af.location = APPLY_HITROLL;
    af.modifier = -4;
    af.duration = 1 + level;
    af.bitvector = AFF_BLIND;
    affect_to_char (victim, &af);
    send_to_char ("You are blinded!\n\r", victim);
    act ("$n appears to be blinded.", victim, NULL, NULL, TO_ROOM);
    act ("$n appaers to be blinded.", victim, NULL, NULL, TO_CHAR);
    return;
}



void spell_burning_hands (int sn, int level, CHAR_DATA * ch, void *vo,
                          int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    static const sh_int dam_each[] = {
        0,
        0, 0, 0, 0, 14, 17, 20, 23, 26, 29,
        29, 29, 30, 30, 31, 31, 32, 32, 33, 33,
        34, 34, 35, 35, 36, 36, 37, 37, 38, 38,
        39, 39, 40, 40, 41, 41, 42, 42, 43, 43,
        44, 44, 45, 45, 46, 46, 47, 47, 48, 48
    };
    int dam;

    level = UMIN (level, sizeof (dam_each) / sizeof (dam_each[0]) - 1);
    level = UMAX (0, level);
    dam = number_range (dam_each[level] / 2, dam_each[level] * 2);
    if (saves_spell (level, victim, DAM_FIRE))
        dam /= 2;
    damage (ch, victim, dam, sn, DAM_FIRE, TRUE);
    return;
}



void spell_call_lightning (int sn, int level, CHAR_DATA * ch, void *vo,
                           int target)
{
    CHAR_DATA *vch;
    CHAR_DATA *vch_next;
    int dam;

    if (!IS_OUTSIDE (ch))
    {
        send_to_char ("You must be out of doors.\n\r", ch);
        return;
    }

    if (weather_info.sky < SKY_RAINING)
    {
        send_to_char ("You need bad weather.\n\r", ch);
        return;
    }

    dam = dice (level / 2, 8);

    send_to_char ("The Gods of lightning strikes your foes!\n\r", ch);
    act ("$n calls The Gods of lightning to strike $s foes!",
         ch, NULL, NULL, TO_ROOM);

    for (vch = char_list; vch != NULL; vch = vch_next)
    {
        vch_next = vch->next;
        if (vch->in_room == NULL)
            continue;
        if (vch->in_room == ch->in_room)
        {
            if (vch != ch && (IS_NPC (ch) ? !IS_NPC (vch) : IS_NPC (vch)))
                damage (ch, vch, saves_spell (level, vch, DAM_LIGHTNING)
                        ? dam / 2 : dam, sn, DAM_LIGHTNING, TRUE);
            continue;
        }

        if (vch->in_room->area == ch->in_room->area && IS_OUTSIDE (vch)
            && IS_AWAKE (vch))
            send_to_char ("Lightning flashes in the sky.\n\r", vch);
    }

    return;
}

/* RT calm spell stops all fighting in the room */

void spell_calm (int sn, int level, CHAR_DATA * ch, void *vo, int target)
{
    CHAR_DATA *vch;
    int mlevel = 0;
    int count = 0;
    int high_level = 0;
    int chance;
    AFFECT_DATA af;

    /* get sum of all mobile levels in the room */
    for (vch = ch->in_room->people; vch != NULL; vch = vch->next_in_room)
    {
        if (vch->position == POS_FIGHTING)
        {
            count++;
            if (IS_NPC (vch))
                mlevel += vch->level;
            else
                mlevel += vch->level / 2;
            high_level = UMAX (high_level, vch->level);
        }
    }

    /* compute chance of stopping combat */
    chance = 4 * level - high_level + 2 * count;

    if (IS_IMMORTAL (ch))        /* always works */
        mlevel = 0;

    if (number_range (0, chance) >= mlevel)
    {                            /* hard to stop large fights */
        for (vch = ch->in_room->people; vch != NULL; vch = vch->next_in_room)
        {
            if (IS_NPC (vch) && (IS_SET (vch->imm_flags, IMM_MAGIC) ||
                                 IS_SET (vch->act, ACT_UNDEAD)))
                return;

            if (IS_AFFECTED (vch, AFF_CALM) || IS_AFFECTED (vch, AFF_BERSERK)
                || is_affected (vch, skill_lookup ("frenzy")))
                return;

            send_to_char ("A wave of calm passes over you.\n\r", vch);

            if (vch->fighting || vch->position == POS_FIGHTING)
                stop_fighting (vch, FALSE);


            af.where = TO_AFFECTS;
            af.type = sn;
            af.level = level;
            af.duration = level / 4;
            af.location = APPLY_HITROLL;
            if (!IS_NPC (vch))
                af.modifier = -5;
            else
                af.modifier = -2;
            af.bitvector = AFF_CALM;
            affect_to_char (vch, &af);

            af.location = APPLY_DAMROLL;
            affect_to_char (vch, &af);
        }
    }
}

void spell_cancellation (int sn, int level, CHAR_DATA * ch, void *vo,
                         int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    bool found = FALSE;

    level += 2;

    if ((!IS_NPC (ch) && IS_NPC (victim) &&
         !(IS_AFFECTED (ch, AFF_CHARM) && ch->master == victim)) ||
        (IS_NPC (ch) && !IS_NPC (victim)))
    {
        send_to_char ("You failed, try dispel magic.\n\r", ch);
        return;
    }

    /* unlike dispel magic, the victim gets NO save */

    /* begin running through the spells */

    if (check_dispel (level, victim, skill_lookup ("armor")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("bless")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("blindness")))
    {
        found = TRUE;
        act ("$n is no longer blinded.", victim, NULL, NULL, TO_ROOM);
    }

    if (check_dispel (level, victim, skill_lookup ("calm")))
    {
        found = TRUE;
        act ("$n no longer looks so peaceful...", victim, NULL, NULL,
             TO_ROOM);
    }

    if (check_dispel (level, victim, skill_lookup ("change sex")))
    {
        found = TRUE;
        act ("$n looks more like $mself again.", victim, NULL, NULL, TO_ROOM);
    }

    if (check_dispel (level, victim, skill_lookup ("charm person")))
    {
        found = TRUE;
        act ("$n regains $s free will.", victim, NULL, NULL, TO_ROOM);
    }

    if (check_dispel (level, victim, skill_lookup ("chill touch")))
    {
        found = TRUE;
        act ("$n looks warmer.", victim, NULL, NULL, TO_ROOM);
    }

    if (check_dispel (level, victim, skill_lookup ("curse")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("detect evil")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("detect good")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("detect hidden")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("detect invis")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("detect magic")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("faerie fire")))
    {
        act ("$n's outline fades.", victim, NULL, NULL, TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("fly")))
    {
        act ("$n falls to the ground!", victim, NULL, NULL, TO_ROOM);
    victim->position = POS_STANDING;
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("frenzy")))
    {
        act ("$n no longer looks so wild.", victim, NULL, NULL, TO_ROOM);;
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("giant strength")))
    {
        act ("$n no longer looks so mighty.", victim, NULL, NULL, TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("haste")))
    {
        act ("$n is no longer moving so quickly.", victim, NULL, NULL,
             TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("infravision")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("invis")))
    {
        act ("$n fades into existance.", victim, NULL, NULL, TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("mass invis")))
    {
        act ("$n fades into existance.", victim, NULL, NULL, TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("pass door")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("protection evil")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("protection good")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("sanctuary")))
    {
        act ("The white aura around $n's body vanishes.",
             victim, NULL, NULL, TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("shield")))
    {
        act ("The shield protecting $n vanishes.", victim, NULL, NULL,
             TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("sleep")))
        found = TRUE;

    if (check_dispel (level, victim, skill_lookup ("slow")))
    {
        act ("$n is no longer moving so slowly.", victim, NULL, NULL,
             TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("stone skin")))
    {
        act ("$n's skin regains its normal texture.", victim, NULL, NULL,
             TO_ROOM);
        found = TRUE;
    }

    if (check_dispel (level, victim, skill_lookup ("weaken")))
    {
        act ("$n looks stronger.", victim, NULL, NULL, TO_ROOM);
        found = TRUE;
    }

    if (found)
        send_to_char ("Ok.\n\r", ch);
    else
        send_to_char ("Ok.\n\r", ch);
}

void spell_cause_light (int sn, int level, CHAR_DATA * ch, void *vo,
                        int target)
{
    damage (ch, (CHAR_DATA *) vo, dice (1, 8) + level / 3, sn, DAM_HARM,
            TRUE);
    return;
}



void spell_cause_critical (int sn, int level, CHAR_DATA * ch, void *vo,
                           int target)
{
    damage (ch, (CHAR_DATA *) vo, dice (3, 8) + level - 6, sn, DAM_HARM,
            TRUE);
    return;
}



void spell_cause_serious (int sn, int level, CHAR_DATA * ch, void *vo,
                          int target)
{
    damage (ch, (CHAR_DATA *) vo, dice (2, 8) + level / 2, sn, DAM_HARM,
            TRUE);
    return;
}

void spell_chain_lightning (int sn, int level, CHAR_DATA * ch, void *vo,
                            int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    CHAR_DATA *tmp_vict, *last_vict, *next_vict;
    bool found;
    int dam;

    /* first strike */

    act ("A lightning bolt leaps from $n's hand and arcs to $N.",
         ch, NULL, victim, TO_ROOM);
    act ("A lightning bolt leaps from your hand and arcs to $N.",
         ch, NULL, victim, TO_CHAR);
    act ("A lightning bolt leaps from $n's hand and hits you!",
         ch, NULL, victim, TO_VICT);

    dam = dice (level, 6);
    if (saves_spell (level, victim, DAM_LIGHTNING))
        dam /= 3;
    damage (ch, victim, dam, sn, DAM_LIGHTNING, TRUE);
    last_vict = victim;
    level -= 4;                    /* decrement damage */

    /* new targets */
    while (level > 0)
    {
        found = FALSE;
        for (tmp_vict = ch->in_room->people;
             tmp_vict != NULL; tmp_vict = next_vict)
        {
            next_vict = tmp_vict->next_in_room;
            if (!is_safe_spell (ch, tmp_vict, TRUE) && tmp_vict != last_vict)
            {
                found = TRUE;
                last_vict = tmp_vict;
                act ("The bolt arcs to $n!", tmp_vict, NULL, NULL, TO_ROOM);
                act ("The bolt hits you!", tmp_vict, NULL, NULL, TO_CHAR);
                dam = dice (level, 6);
                if (saves_spell (level, tmp_vict, DAM_LIGHTNING))
                    dam /= 3;
                damage (ch, tmp_vict, dam, sn, DAM_LIGHTNING, TRUE);
                level -= 4;        /* decrement damage */
            }
        }                        /* end target searching loop */

        if (!found)
        {                        /* no target found, hit the caster */
            if (ch == NULL)
                return;

            if (last_vict == ch)
            {                    /* no double hits */
                act ("The bolt seems to have fizzled out.", ch, NULL, NULL,
                     TO_ROOM);
                act ("The bolt grounds out through your body.", ch, NULL,
                     NULL, TO_CHAR);
                return;
            }

            last_vict = ch;
            act ("The bolt arcs to $n...whoops!", ch, NULL, NULL, TO_ROOM);
            send_to_char ("You are struck by your own lightning!\n\r", ch);
            dam = dice (level, 6);
            if (saves_spell (level, ch, DAM_LIGHTNING))
                dam /= 3;
            damage (ch, ch, dam, sn, DAM_LIGHTNING, TRUE);
            level -= 4;            /* decrement damage */
            if (ch == NULL)
                return;
        }
        /* now go back and find more targets */
    }
}


void spell_change_sex (int sn, int level, CHAR_DATA * ch, void *vo,
                       int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    AFFECT_DATA af;

    if (is_affected (victim, sn))
    {
        if (victim == ch)
            send_to_char ("You've already been changed.\n\r", ch);
        else
            act ("$N has already had $s(?) sex changed.", ch, NULL, victim,
                 TO_CHAR);
        return;
    }
    if (saves_spell (level, victim, DAM_OTHER))
        return;
    af.where = TO_AFFECTS;
    af.type = sn;
    af.level = level;
    af.duration = 2 * level;
    af.location = APPLY_SEX;
    do
    {
        af.modifier = number_range (0, 2) - victim->sex;
    }
    while (af.modifier == 0);
    af.bitvector = 0;
    affect_to_char (victim, &af);
    send_to_char ("You feel different.\n\r", victim);
    act ("$n doesn't look like $mself anymore...", victim, NULL, NULL,
         TO_ROOM);
    return;
}



void spell_charm_person (int sn, int level, CHAR_DATA * ch, void *vo,
                         int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    AFFECT_DATA af;

    if (is_safe (ch, victim))
        return;

    if (victim == ch)
    {
        send_to_char ("You like yourself even better!\n\r", ch);
        return;
    }

    if (IS_AFFECTED (victim, AFF_CHARM)
        || IS_AFFECTED (ch, AFF_CHARM)
        || level < victim->level || IS_SET (victim->imm_flags, IMM_CHARM)
        || saves_spell (level, victim, DAM_CHARM))
        return;


    if (IS_SET (victim->in_room->room_flags, ROOM_LAW))
    {
        send_to_char
            ("You failed.\n\r", ch);
        return;
    }

    if (victim->master)
        stop_follower (victim);
    add_follower (victim, ch);
    victim->leader = ch;
    af.where = TO_AFFECTS;
    af.type = sn;
    af.level = level;
    af.duration = number_fuzzy (level / 4);
    af.location = 0;
    af.modifier = 0;
    af.bitvector = AFF_CHARM;
    affect_to_char (victim, &af);
    act ("Isn't $n just so nice?", ch, NULL, victim, TO_VICT);
    if (ch != victim)
        act ("$N looks at you with adoring eyes.", ch, NULL, victim, TO_CHAR);
    return;
}



void spell_chill_touch (int sn, int level, CHAR_DATA * ch, void *vo,
                        int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    static const sh_int dam_each[] = {
        0,
        0, 0, 6, 7, 8, 9, 12, 13, 13, 13,
        14, 14, 14, 15, 15, 15, 16, 16, 16, 17,
        17, 17, 18, 18, 18, 19, 19, 19, 20, 20,
        20, 21, 21, 21, 22, 22, 22, 23, 23, 23,
        24, 24, 24, 25, 25, 25, 26, 26, 26, 27
    };
    AFFECT_DATA af;
    int dam;

    level = UMIN (level, sizeof (dam_each) / sizeof (dam_each[0]) - 1);
    level = UMAX (0, level);
    dam = number_range (dam_each[level] / 2, dam_each[level] * 2);
    if (!saves_spell (level, victim, DAM_COLD))
    {
        act ("$n turns blue and shivers.", victim, NULL, NULL, TO_ROOM);
        af.where = TO_AFFECTS;
        af.type = sn;
        af.level = level;
        af.duration = 6;
        af.location = APPLY_STR;
        af.modifier = -1;
        af.bitvector = 0;
        affect_join (victim, &af);
    }
    else
    {
        dam /= 2;
    }

    damage (ch, victim, dam, sn, DAM_COLD, TRUE);
    return;
}



void spell_colour_spray (int sn, int level, CHAR_DATA * ch, void *vo,
                         int target)
{
    CHAR_DATA *victim = (CHAR_DATA *) vo;
    static const sh_int dam_each[] = {
        0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        30, 35, 40, 45, 50, 55, 55, 55, 56, 57,
        58, 58, 59, 60, 61, 61, 62, 63, 64, 64,
        65, 66, 67, 67, 68, 69, 70, 70, 71, 72,
        73, 73, 74, 75, 76, 76, 77, 78, 79, 79
    };
    int dam;

    level = UMIN (level, sizeof (dam_each) / sizeof (dam_each[0]) - 1);
    level = UMAX (0, level);
    dam = number_range (dam_each[level] / 2, dam_each[level] * 2);
    if (saves_spell (level, victim, DAM_LIGHT))
        dam /= 2;
    else
        spell_blindness (skill_lookup ("blindness"),
                         level / 2, ch, (void *) victim, TARGET_CHAR);

    damage (ch, victim, dam, sn, DAM_LIGHT, TRUE);
    return;
}



void spell_continual_light (int sn, int level, CHAR_DATA * ch, void *vo,
                            int target)
{
    OBJ_DATA *light;
    
    if (target_name[0] != '\0')
    {                            /* do a glow on some object */
        light = get_obj_carry (ch, target_name, ch);

        if (light == NULL)
        {
            send_to_char ("You don't see that here.\n\r", ch);
            return;
        }

        if (IS_OBJ_STAT (light, ITEM_GLOW))
        {
            act ("$p is already glowing.", ch, light, NULL, TO_CHAR);
            return;
        }

        SET_BIT (light->extra_flags, ITEM_GLOW);
        act ("$p glows with a white light.", ch, light, NULL, TO_ALL);
        return;
    }

    if ((light = create_object (get_obj_index (OBJ_VNUM_LIGHT_BALL), 0)) == NULL)
    {
        send_to_char("ERROR! Create_object returned NULL, please seek a coder.\n\r",ch);
        return;
    }
    
    obj_to_room (light, ch->in_room);
    

    act ("$n twiddles $s thumbs and $p appears.", ch, light, NULL, TO_ROOM);
    act ("You twiddle your thumbs and $p appears.", ch, light, NULL, TO_CHAR);
    return;
}



void spell_control_weather (int sn, int level, CHAR_DATA * ch, void *vo,
                            int target)
{
    if (!str_cmp (target_name, "better"))
        weather_info.change += dice (level / 3, 4);
    else if (!str_cmp (target_name, "worse"))
        weather_info.change -= dice (level / 3, 4);
    else
        send_to_char ("Do you want it to get better or worse?\n\r", ch);

    send_to_char ("Ok.\n\r", ch);
    return;
}



void spell_create_food (int sn, int level, CHAR_DATA * ch, void *vo,
                        int target)
{
    OBJ_DATA *mushroom;

    if ((mushroom = create_object (get_obj_index (OBJ_VNUM_MUSHROOM), 0)) == NULL)
    {
        send_to_char("ERROR: Object returns NULL, please find a coder.\n\r",ch);
        return;
    }
    mushroom->value[0]