#include "spl-mis.h"

            miscast_effect(SPTYP_RANDOM, 0, 0, 0, "the mischief of Xom");

            MiscastEffect(&you, -GOD_XOM, SPTYP_RANDOM, 0,
                          "the mischief of Xom");

            miscast_effect(SPTYP_RANDOM, 0, 0, random2(2),

            MiscastEffect(&you, -GOD_XOM, SPTYP_RANDOM, random2(2),

            miscast_effect(SPTYP_RANDOM, 0, 0, random2(3),

            MiscastEffect(&you, -GOD_XOM, SPTYP_RANDOM, random2(3),

            god_speaks(GOD_XOM, _get_xom_speech("major miscast effect").c_str());

            god_speaks(GOD_XOM,
                       _get_xom_speech("major miscast effect").c_str());

            miscast_effect(SPTYP_RANDOM, 0, 0, random2(4),
                           "the severe capriciousness of Xom");

            MiscastEffect(&you, -GOD_XOM, SPTYP_RANDOM, random2(4),
                          "the severe capriciousness of Xom");

#include "spl-cast.h"

#include "spl-mis.h"

        miscast_effect( SPTYP_RANDOM, random2(30) + you.your_level,
                        75 + random2(100), 3, "a Zot trap" );

        MiscastEffect( &you, ZOT_TRAP_MISCAST, SPTYP_RANDOM,
                       3, "a Zot trap" );

        marshallShort(th, env.cloud[i].whose);

        marshallByte(th, env.cloud[i].whose);
        marshallByte(th, env.cloud[i].killer);

        env.cloud[i].whose = static_cast<kill_category>(unmarshallShort(th));

        env.cloud[i].whose = static_cast<kill_category>(unmarshallByte(th));
        env.cloud[i].killer = static_cast<killer_type>(unmarshallByte(th));

spschool_flag_type school_by_name(std::string name);

const char* spelltype_long_name( int which_spelltype );

                                   kill_category),

                                   kill_category, killer_type),

                      kill_category kc, int spread_rate = -1);

                      kill_category kc, killer_type killer,
                      int spread_rate = -1);

                                      kill_category),

                                      kill_category, killer_type),

                          cloud_type ctype, kill_category );

                          cloud_type ctype, kill_category, killer_type );

}
spschool_flag_type school_by_name(std::string name)
{
   spschool_flag_type short_match, long_match;
   int                short_matches, long_matches;
   short_match   = long_match   = SPTYP_NONE;
   short_matches = long_matches = 0;
   for (int i = 0; i <= SPTYP_RANDOM; i++)
   {
       spschool_flag_type type = (spschool_flag_type) (1 << i);
       const char* short_name = spelltype_short_name(type);
       const char* long_name  = spelltype_long_name(type);
       if (strcasecmp(short_name, name.c_str()) == 0)
           return type;
       if (strcasecmp(long_name, name.c_str()) == 0)
           return type;
       if (strcasestr(short_name, name.c_str()))
       {
           short_match = type;
           short_matches++;
       }
       if (strcasestr(long_name, name.c_str()))
       {
           long_match = type;
           long_matches++;
       }
   }
   if (short_matches != 1 && long_matches != 1)
       return SPTYP_NONE;
   if (short_matches == 1 && long_matches != 1)
       return short_match;
   if (short_matches != 1 && long_matches == 1)
       return long_match;
   if (short_match == long_match)
       return short_match;
   return SPTYP_NONE;

                                    kill_category),

                                    kill_category, killer_type),

                       kill_category whose, int spread_rate )

                       kill_category whose, killer_type killer,
                       int spread_rate )

                                     ctype, whose))

                                     ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                         ctype, whose))

                                         ctype, whose, killer))

                                     ctype, whose))

                                     ctype, whose, killer))

                                     ctype, whose))

                                     ctype, whose, killer))

                                     ctype, whose))

                                     ctype, whose, killer))

                                     ctype, whose))

                                     ctype, whose, killer))

            apply_area_cloud(func, x + dx, y, pow, spread, ctype, whose,

            apply_area_cloud(func, x + dx, y, pow, spread, ctype, whose, killer,

            apply_area_cloud(func, x - dx, y, pow, spread, ctype, whose,

            apply_area_cloud(func, x - dx, y, pow, spread, ctype, whose, killer,

            apply_area_cloud(func, x, y + dy, pow, spread, ctype, whose,

            apply_area_cloud(func, x, y + dy, pow, spread, ctype, whose, killer,

            apply_area_cloud(func, x, y - dy, pow, spread, ctype, whose,

            apply_area_cloud(func, x, y - dy, pow, spread, ctype, whose, killer,

                             spread_rate);

                             killer, spread_rate);

                             spread_rate);

                             killer, spread_rate);

                             spread_rate);

                             killer, spread_rate);

                             spread_rate);

                             killer, spread_rate);

    case SPTYP_RANDOM:
        return ("Rndm");

const char* spelltype_long_name( int which_spelltype )
{
    switch (which_spelltype)
    {
    case SPTYP_CONJURATION:
        return ("Conjuration");
    case SPTYP_ENCHANTMENT:
        return ("Enchantment");
    case SPTYP_FIRE:
        return ("Fire");
    case SPTYP_ICE:
        return ("Ice");
    case SPTYP_TRANSMIGRATION:
        return ("Transmigration");
    case SPTYP_NECROMANCY:
        return ("Necromancy");
    case SPTYP_HOLY:
        return ("Holy");
    case SPTYP_SUMMONING:
        return ("Summoning");
    case SPTYP_DIVINATION:
        return ("Divination");
    case SPTYP_TRANSLOCATION:
        return ("Translocation");
    case SPTYP_POISON:
        return ("Poison");
    case SPTYP_EARTH:
        return ("Earth");
    case SPTYP_AIR:
        return ("Air");
    case SPTYP_RANDOM:
        return ("Random");
    default:
        return "Bug";
    }
}

                                      kill_category),

                                      kill_category, killer_type),

                          cloud_type ctype, kill_category whose )

                          cloud_type ctype, kill_category whose,
                          killer_type killer )

        func(x, y, pow, spread_rate, ctype, whose);

        func(x, y, pow, spread_rate, ctype, whose, killer);

/*
 *  File:       spl-mis.h
 *  Summary:    Spell miscast class.
 *  Written by: Matthew Cline
 *
 *  Modified for Crawl Reference by $Author$ on $Date: 2008-06-28 22:
16:39 -0700 (Sat, 28 Jun 2008) $
 *
 *  Change History (most recent first):
 *
 *               <1>     -/--/--        LRH             Created
 */
#ifndef SPL_MIS_H
#define SPL_MIS_H
// last updated 23jul2008 {mpc}
/* ***********************************************************************
 * called from: decks - effects - fight - item_use - it_use2 - it_use3 -
 *              item_use - monstuff - religion - spells2 - spells4 -
 *              spl-book - spl-cast - traps - xom
 * *********************************************************************** */
#include "enum.h"
#include "beam.h"
#include "mpr.h"
#include "spl-util.h"
#define ZOT_TRAP_MISCAST     (NON_MONSTER + 1)
#define WIELD_MISCAST        (NON_MONSTER + 2)
#define MELEE_MISCAST        (NON_MONSTER + 3)
#define MISC_KNOWN_MISCAST   (NON_MONSTER + 4)
#define MISC_UNKNOWN_MISCAST (NON_MONSTER + 5)
enum nothing_happens_when_type
{
    NH_DEFAULT,
    NH_NEVER,
    NH_ALWAYS
};
class actor;
class MiscastEffect
{
public:
    MiscastEffect(actor* _target, int _source, spell_type _spell, int _pow,
                  int _fail, std::string _cause = "",
                  nothing_happens_when_type _nothing_happens = NH_DEFAULT);
    MiscastEffect(actor *_target, int _source, spschool_flag_type _school,
                  int _level, std::string _cause,
                  nothing_happens_when_type _nothing_happens = NH_DEFAULT);
    MiscastEffect(actor *_target, int _source, spschool_flag_type _school,
                  int _pow, int _fail, std::string _cause,
                  nothing_happens_when_type _nothing_happens = NH_DEFAULT);
    void do_miscast();
private:
    actor* target;
    int    source;
    std::string cause;
    spell_type         spell;
    spschool_flag_type school;
    int pow;
    int fail;
    int level;
private:
    kill_category kc;
    killer_type   kt;
    monsters* mon_target;
    monsters* mon_source;
    nothing_happens_when_type nothing_happens_when;
    int    kill_source;
    actor* act_source;
    bool source_known;
    bool target_known;
    bolt beam;
    std::string all_msg;
    std::string you_msg;
    std::string mon_msg;
    std::string mon_msg_seen;
    std::string mon_msg_unseen;
    msg_channel_type msg_ch;
private:
    void init();
    std::string get_default_cause();
    bool neither_end_silenced();
    void do_msg(bool suppress_nothing_happens = false);
    void _ouch(int dam, beam_type flavour = BEAM_NONE);
    void _explosion();
    void _potion_effect(int pot_eff, int pow);
    bool _create_monster(monster_type what, int abj_deg, bool alert = false);
    void send_abyss();
    void _conjuration(int severity);
    void _enchantment(int severity);
    void _translocation(int severity);
    void _summoning(int severity);
    void _divination_you(int severity);
    void _divination_mon(int severity);
    void _necromancy(int severity);
    void _transmigration(int severity);
    void _fire(int severity);
    void _ice(int severity);
    void _earth(int severity);
    void _air(int severity);
    void _poison(int severity);
};
#endif

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: acr - decks - fight - it_use2 - it_use3 - item_use - items -
 *              misc - mstuff2 - religion - spell - spl-book - spells4
 * *********************************************************************** */
void miscast_effect(unsigned int sp_type, int mag_pow, int mag_fail,
                    int force_effect, const char *cause = NULL);

#include "spl-mis.h"

            }
            unsigned int sptype = 0;
            do
            {
                sptype = 1 << (random2(SPTYP_LAST_EXPONENT+1));

            while (!spell_typematch(spell, sptype));

            miscast_effect( sptype, spell_mana(spell),
                            spfail_chance - spfl, 100 );

            MiscastEffect( &you, NON_MONSTER, spell, spell_mana(spell),
                           spfail_chance - spfl );

}
MiscastEffect::MiscastEffect(actor* _target, int _source, spell_type _spell,
                             int _pow, int _fail, std::string _cause,
                             nothing_happens_when_type _nothing_happens) :
    target(_target), source(_source), cause(_cause), spell(_spell),
    school(SPTYP_NONE), pow(_pow), fail(_fail), level(-1), kc(KC_NCATEGORIES),
    kt(KILL_NONE), mon_target(NULL), mon_source(NULL),
    nothing_happens_when(_nothing_happens)
{
    ASSERT(is_valid_spell(_spell));
    unsigned int schools = get_spell_disciplines(_spell);
    ASSERT(schools != SPTYP_NONE);
    ASSERT(!(schools & SPTYP_HOLY));
    init();
    do_miscast();
}
MiscastEffect::MiscastEffect(actor *_target, int _source,
                             spschool_flag_type _school, int _level,
                             std::string _cause,
                             nothing_happens_when_type _nothing_happens) :
    target(_target), source(_source), cause(_cause), spell(SPELL_NO_SPELL),
    school(_school), pow(-1), fail(-1), level(_level), kc(KC_NCATEGORIES),
    kt(KILL_NONE), mon_target(NULL), mon_source(NULL),
    nothing_happens_when(_nothing_happens)
{
    ASSERT(!_cause.empty());
    ASSERT(count_bits(_school) == 1);
    ASSERT(_school < SPTYP_HOLY || _school == SPTYP_RANDOM);
    ASSERT(level >= 0 && level <= 3);
    init();
    do_miscast();
}
MiscastEffect::MiscastEffect(actor *_target, int _source,
                             spschool_flag_type _school, int _pow, int _fail,
                             std::string _cause,
                             nothing_happens_when_type _nothing_happens) :
    target(_target), source(_source), cause(_cause), spell(SPELL_NO_SPELL),
    school(_school), pow(_pow), fail(_fail), level(-1), kc(KC_NCATEGORIES),
    kt(KILL_NONE), mon_target(NULL), mon_source(NULL),
    nothing_happens_when(_nothing_happens)
{
    ASSERT(!_cause.empty());
    ASSERT(count_bits(_school) == 1);
    ASSERT(_school < SPTYP_HOLY || _school == SPTYP_RANDOM);
    init();
    do_miscast();
}
void MiscastEffect::init()
{
    ASSERT(spell != SPELL_NO_SPELL && school == SPTYP_NONE
           || spell == SPELL_NO_SPELL && school != SPTYP_NONE);
    ASSERT(pow != -1 && fail != -1 && level == -1
           || pow == -1 && fail == -1 && level >= 0 && level <= 3);
    ASSERT(target != NULL);
    // A dead but not-yet-exploded giant spore or ball lightning *might*
    // be the target of a miscast effect.
    ASSERT(target->alive() || target->id() ==  MONS_GIANT_SPORE
           || target->id() == MONS_BALL_LIGHTNING);
    source_known = target_known = false;
    mon_target = mon_source = NULL;
    act_source = NULL;
    const bool death_curse = (cause.find("death curse") != std::string::npos);
    if (target->atype() == ACT_MONSTER)
    {
        mon_target   = dynamic_cast<monsters*>(target);
        target_known = you.can_see(mon_target);
    }
    else
        target_known = true;
    
    kill_source = source;
    if (source == WIELD_MISCAST || source == MELEE_MISCAST)
    {
        if (target->atype() == ACT_MONSTER)
        {
            mon_source  = dynamic_cast<monsters*>(target);
            kill_source = monster_index(mon_source);
        }
        else
            kill_source  = NON_MONSTER;
    }
    if (kill_source == NON_MONSTER)
    {
        kc           = KC_YOU;
        kt           = KILL_YOU_MISSILE;
        act_source   = dynamic_cast<actor*>(&you);
        source_known = true;
    }
    else if (kill_source >= 0 && kill_source < NON_MONSTER)
    {
        mon_source = &menv[kill_source];
        act_source = dynamic_cast<actor*>(mon_source);
        ASSERT(mon_source->type != -1);
        if (death_curse && target->atype() == ACT_MONSTER
            && mon_target->confused_by_you())
        {
            kt = KILL_YOU_CONF;
        }
        else if (!death_curse && mon_source->confused_by_you()
                 && !mons_friendly(mon_source))
        {
            kt = KILL_YOU_CONF;
        }
        else
            kt = KILL_MON_MISSILE;
        if (mons_friendly(mon_source))
            kc = KC_FRIENDLY;
        else
            kc = KC_OTHER;
        source_known = you.can_see(mon_source);
        if (target_known && death_curse)
            source_known = true;
    }
    else
    {
        ASSERT(source == ZOT_TRAP_MISCAST
               || source == MISC_KNOWN_MISCAST
               || source == MISC_UNKNOWN_MISCAST
               || (source < 0 && -source < NUM_GODS));
        kc = KC_OTHER;
        kt = KILL_MISC;
        if (source == ZOT_TRAP_MISCAST)
        {
            source_known = target_known;
            if (target->atype() == ACT_MONSTER
                && mon_target->confused_by_you())
            {
                kt = KILL_YOU_CONF;
            }
        }
        else if (source == MISC_KNOWN_MISCAST)
            source_known = true;
        else if (source == MISC_UNKNOWN_MISCAST)
            source_known = false;
        else
            source_known = true;
    }
    ASSERT(kc != KC_NCATEGORIES && kt != KILL_NONE);
    if (death_curse && !invalid_monster_index(kill_source))
    {
        if (starts_with(cause, "a "))
            cause.replace(cause.begin(), cause.begin() + 1, "an indirect");
        if (starts_with(cause, "an "))
            cause.replace(cause.begin(), cause.begin() + 2, "an indirect");
        else
            cause = replace_all(cause, "death curse", "indirect death curse");
   }
    // source_known = false for MELEE_MISCAST so that melee miscasts
    // won't give a "nothing happens" message.
    if (source == MELEE_MISCAST)
        source_known = false;
    beam.is_beam      = false;
    beam.is_explosion = true;
    if (cause.empty())
        cause = get_default_cause();
    beam.aux_source  = cause;
    beam.beam_source = kill_source;
    beam.thrower     = kt;
}
std::string MiscastEffect::get_default_cause()
{
    // This is only for true miscasts, which means both a spell and that
    // the source of the miscast is the same as the target of the miscast.
    ASSERT(source >= 0 && source <= NON_MONSTER);
    ASSERT(spell != SPELL_NO_SPELL);
    ASSERT(school == SPTYP_NONE);
    if (source == NON_MONSTER)
    {
        ASSERT(target->atype() == ACT_PLAYER);
        std::string str = "you miscasting ";
        str += spell_title(spell);
        return str;
    }
    ASSERT(mon_source != NULL);
    ASSERT(mon_source == mon_target);
    if (you.can_see(mon_source))
    {
        std::string str = mon_source->base_name(DESC_PLAIN, false);
        str += "'s spell miscasting";
        str = replace_all(str, "s's", "s'");
        return str;
    }
    else
        return "something's spell miscasting";    
}
bool MiscastEffect::neither_end_silenced()
{
    return (!silenced(you.pos()) && !silenced(target->pos()));

static bool _send_abyss(const char *cause)

void MiscastEffect::do_miscast()
{
    // Repeated calls to do_miscast() on a single object instance have
    // killed a target which was alive when the object was created,
    // or the target is a dead but not-yet-exploded giant spore or
    // ball lightning.
    if (!target->alive())
    {
        mprf(MSGCH_DIAGNOSTICS, "Miscast target '%s' already dead",
             target->name(DESC_PLAIN, true).c_str());
        return;
    }
    spschool_flag_type sp_type;
    int                severity;
    if (spell != SPELL_NO_SPELL)
    {
        std::vector<int> school_list;
        for (int i = 0; i < SPTYP_LAST_EXPONENT; i++)
            if (spell_typematch(spell, 1 << i))
                school_list.push_back(i);
        unsigned int _school = school_list[random2(school_list.size())];
        sp_type = static_cast<spschool_flag_type>(1 << _school);
    }
    else
    {
        sp_type = school;
        if (sp_type == SPTYP_RANDOM)
        {
            int exp = (random2(SPTYP_LAST_EXPONENT));
            sp_type = (spschool_flag_type) (1 << exp);
        }
    }
    if (level != -1)
        severity = level;
    else
    {
        severity = (pow * fail * (10 + pow) / 7 * WILD_MAGIC_NASTINESS) / 100;
#if DEBUG_DIAGNOSTICS || DEBUG_MISCAT
        mprf(MSGCH_DIAGNOSTICS, "'%s' miscast power: %d",
             spell != SPELL_NO_SPELL ? spell_title(spell)
                                     : spelltype_short_name(sp_type),
             severity);
#endif
        if (random2(40) > severity && random2(40) > severity)
        {
            if (target->atype() == ACT_PLAYER)
                canned_msg(MSG_NOTHING_HAPPENS);
            return;
        }
        severity /= 100;
        severity = random2(severity);
        if (severity > 3)
            severity = 3;
        else if (severity < 0)
            severity = 0;
    }
#if DEBUG_DIAGNOSTICS || DEBUG_MISCAT
    mprf(MSGCH_DIAGNOSTICS, "Sptype: %u, severity: %d",
         spelltype_short_name(sp_type), severity );
#endif
    beam.ex_size            = 1;
    beam.name               = "";
    beam.damage             = dice_def(0, 0);
    beam.flavour            = BEAM_NONE;
    beam.msg_generated      = false;
    beam.in_explosion_phase = false;
    // Do this here since multiple miscasts (wizmode testing) might move
    // the target around.
    beam.source_x = target->pos().x;
    beam.source_y = target->pos().y;
    beam.target_x = target->pos().x;
    beam.target_y = target->pos().y;
    beam.pos      = target->pos();
    all_msg = you_msg = mon_msg = mon_msg_seen = mon_msg_unseen = "";
    msg_ch  = MSGCH_PLAIN;
    switch (sp_type)
    {
    case SPTYP_CONJURATION:    _conjuration(severity);    break;
    case SPTYP_ENCHANTMENT:    _enchantment(severity);    break;
    case SPTYP_TRANSLOCATION:  _translocation(severity);  break;
    case SPTYP_SUMMONING:      _summoning(severity);      break;
    case SPTYP_NECROMANCY:     _necromancy(severity);     break;
    case SPTYP_TRANSMIGRATION: _transmigration(severity); break;
    case SPTYP_FIRE:           _fire(severity);           break;
    case SPTYP_ICE:            _ice(severity);            break;
    case SPTYP_EARTH:          _earth(severity);          break;
    case SPTYP_AIR:            _air(severity);            break;
    case SPTYP_POISON:         _poison(severity);         break;
    case SPTYP_DIVINATION:
        // Divination miscasts have nothing in common between the player
        // and monsters.
        if (target->atype() == ACT_PLAYER)
            _divination_you(severity);
        else
            _divination_mon(severity);
        break;
    default:
        ASSERT(false);
    }
    if (target->atype() == ACT_PLAYER)
        xom_is_stimulated(severity * 50);
}
void MiscastEffect::do_msg(bool suppress_nothing_happnes)
{
    if (mon_target != NULL && !mons_near(mon_target))
        return;
    std::string msg;
    if (!all_msg.empty())
        msg = all_msg;
    else if (target->atype() == ACT_PLAYER)
        msg = you_msg;
    else if (!mon_msg.empty())
    {
        msg = mon_msg;
        // Monster might be unseen with hands that can't be seen.
        ASSERT(msg.find("@hand") == std::string::npos);
    }
    else
    {
        if (you.can_see(target))
            msg = mon_msg_seen;
        else
        {
            msg = mon_msg_unseen;
            // Can't see the hands of invisible monsters.
            ASSERT(msg.find("@hand") == std::string::npos);
        }
    }
    if (msg.empty())
    {
        if (!suppress_nothing_happnes
            && (nothing_happens_when == NH_ALWAYS 
                || (nothing_happens_when == NH_DEFAULT && source_known
                    && target_known)))
        {
            canned_msg(MSG_NOTHING_HAPPENS);
        }
        return;
    }
    msg = replace_all(msg, "@hand@",  target->hand_name(false));
    msg = replace_all(msg, "@hands@", target->hand_name(true));
    if (target->atype() == ACT_MONSTER)
        msg = do_mon_str_replacements(msg, mon_target, S_SILENT);
    mpr(msg.c_str(), msg_ch);
}
void MiscastEffect::_ouch(int dam, beam_type flavour)

    if (you.level_type != LEVEL_ABYSS)

    do_msg(true);
    if (target->atype() == ACT_MONSTER)

        you.banish(cause ? cause : "");
        return (true);

        bolt beem;
        beem.flavour = flavour;
        dam = mons_adjust_flavoured(mon_target, beem, dam, true);
        hurt_monster(mon_target, dam);
        if (mon_target->hit_points < 1)
            monster_die(mon_target, kt, kill_source);

    {
        kill_method_type method;
        if (source == NON_MONSTER && spell != SPELL_NO_SPELL)
            method = KILLED_BY_WILD_MAGIC;
        else if (source == ZOT_TRAP_MISCAST)
            method = KILLED_BY_TRAP;
        else if (source < 0 && -source < NUM_GODS)
        {
            god_type god = static_cast<god_type>(-source);
            if (god == GOD_XOM && you.penance[GOD_XOM] == 0)
                method = KILLED_BY_XOM;
            else
            {
                method = KILLED_BY_DIVINE_WRATH;
                if (you.penance[god] == 0)
                   mpr("God making you miscast, but not under penance.",
                       MSGCH_DIAGNOSTICS);
            }
        }
        else if (source >= 0 && source < NON_MONSTER)
            method = KILLED_BY_MONSTER;
        else
            method = KILLED_BY_SOMETHING;
        dam = check_your_resists(dam, flavour);
        bool see_source = false;
        if (kill_source != NON_MONSTER)
            see_source = you.can_see(&menv[kill_source]);
        ouch(dam, kill_source, method, cause.c_str(), see_source);
    }
}
void MiscastEffect::_explosion()
{
    ASSERT(!beam.name.empty());
    ASSERT(beam.damage.num != 0 && beam.damage.size != 0);
    ASSERT(beam.flavour != BEAM_NONE);
    do_msg(true);
    explosion(beam, false, true);
}
void MiscastEffect::_potion_effect(int pot_eff, int pot_pow)
{
    if (target->atype() == ACT_PLAYER)
    {
        potion_effect(static_cast<potion_type>(pot_eff), pot_pow, false);
        return;
    }
    switch(pot_eff)

        mpr("The world appears momentarily distorted.");
        return (false);

        case POT_LEVITATION:
            // There's no levitation enchantment for monsters, and anyways
            // it's not nearly as inconveniencing for monsters as for the
            // player, so backlight them instead.
            mon_target->add_ench( mon_enchant(ENCH_BACKLIGHT, pot_pow, kc) );
            break;
        case POT_BERSERK_RAGE:
            if (target->can_go_berserk())
            {
                target->go_berserk(false);
                break;
            }
            // Intentional fallthrough if that didn't work.
        case POT_SLOWING:
            target->slow_down(pot_pow);
            break;
        case POT_PARALYSIS:
            target->paralyse(pot_pow);
            break;
        case POT_CONFUSION:
            target->confuse(pot_pow);
            break;
        default:
            ASSERT(false);
    }
}
void MiscastEffect::send_abyss()
{
    if (you.level_type == LEVEL_ABYSS)
    {
        you_msg        = "The world appears momentarily distorted.";
        mon_msg_seen   = "@The_monster@ wobbles for a moment.";
        mon_msg_unseen = "An empty piece of space momentarily distorts.";
        do_msg();
        return;
    }
    target->banish(cause);
}
bool MiscastEffect::_create_monster(monster_type what, int abj_deg,
                                    bool alert)
{
    const god_type god =
        (crawl_state.is_god_acting()) ? crawl_state.which_god_acting()
                                      : GOD_NO_GOD;
    mgen_data data = mgen_data::hostile_at(what, target->pos(),
                                           abj_deg, 0, alert, god);
    // hostile_at() assumes the monster is hostile to the player,
    // but should be hostile to the target monster unless the miscast
    // is a result of either divine wrath or a Zot trap.
    if (target->atype() == ACT_MONSTER && you.penance[god] == 0
        && source != ZOT_TRAP_MISCAST)
    {
        switch(mon_target->temp_attitude())
        {
            case ATT_FRIENDLY:     data.behaviour = BEH_HOSTILE; break;
            case ATT_HOSTILE:      data.behaviour = BEH_FRIENDLY; break;
            case ATT_GOOD_NEUTRAL:
            case ATT_NEUTRAL:
                data.behaviour = BEH_NEUTRAL;
            break;
        }
        if (alert)
            data.foe = monster_index(mon_target);
        // No permanent allies from miscasts.
        if (data.behaviour == BEH_FRIENDLY && abj_deg == 0)
            data.abjuration_duration = 6;

    return (create_monster(data) != -1);

static void _miscast_conjuration(int severity, const char* cause)

void MiscastEffect::_conjuration(int severity)

    bolt beam;

            msg::stream << "Sparks fly from your " << your_hand(true)
                        << '!' << std::endl;

            you_msg      = "Sparks fly from your @hands@!";
            mon_msg_seen = "Sparks fly from @the_monster@'s @hands@!";

            mpr("The air around you crackles with energy!");

            you_msg      = "The air around you crackles with energy!";
            mon_msg_seen = "The air around @the_monster@ crackles "
                              "with energy!";

            msg::stream << "Wisps of smoke drift from your "
                        << your_hand(true) << '.' << std::endl;

            you_msg      = "Wisps of smoke drift from your @hands@.";
            mon_msg_seen = "Wisps of smoke drift from @the_monster@'s "
                           "@hands@.";

            mpr("You feel a strange surge of energy!");

            you_msg = "You feel a strange surge of energy!";
            // Monster messages needed.

            mpr("You are momentarily dazzled by a flash of light!");

            you_msg      = "You are momentarily dazzled by a flash of light!";
            mon_msg_seen = "@The_monster@ emits a flash of light!";

            mpr("Strange energies run through your body.");

            you_msg = "Strange energies run through your body.";
            // Monster messages needed.

            mpr("Your skin tingles.");

            you_msg = "Your skin tingles.";
            // Monster messages needed.

            mpr("Your skin glows momentarily.");

            you_msg      = "Your skin glows momentarily.";
            mon_msg_seen = "@The_monster@ glows momentarily.";
            // A smal glow isn't going to make it past invisibility.

            canned_msg(MSG_NOTHING_HAPPENS);

            // Set nothing; canned_msg(MSG_NOTHING_HAPPENS) will be taken
            // care of elsewhere.

                mpr("You smell something strange.");

                all_msg = "You smell something strange.";

                mpr("Your bandages flutter.");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

                you_msg = "Your bandages flutter.";

        do_msg();

            msg::stream << "Smoke pours from your " << your_hand(true)
                        << '!' << std::endl;
            big_cloud( CLOUD_GREY_SMOKE, (cause ? KC_OTHER : KC_YOU),
                       you.x_pos, you.y_pos, 20,
                       7 + random2(7) );

            you_msg        = "Smoke pours from your @hands@!";
            mon_msg_seen   = "Smoke pours from @the_monster@'s @hands@!";
            mon_msg_unseen = "Smoke appears from out of nowhere!";
            do_msg();
            big_cloud( CLOUD_GREY_SMOKE, kc, kt,
                       target->pos().x, target->pos().y,
                       20, 7 + random2(7) );

            mpr("A wave of violent energy washes through your body!");
            ouch(6 + random2avg(7, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg = "A wave of violent energy washes through your body!";
            // Monster messages needed.
            _ouch(6 + random2avg(7, 2));

            mpr("Energy rips through your body!");
            ouch(9 + random2avg(17, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg = "Energy rips through your body!";
            // Monster messages needed.
            _ouch(9 + random2avg(17, 2));

            mpr("You are caught in a violent explosion!");
            beam.type = dchar_glyph(DCHAR_FIRED_BURST);
            beam.damage = dice_def( 3, 12 );

            you_msg        = "You are caught in a violent explosion!";
            mon_msg_seen   = "@The_monster@ is caugh in a violent explosion!";
            mon_msg_unseen = "A violent explosion happens from "
                             "out of thin air!";
            beam.damage  = dice_def( 3, 12 );

            beam.target_x = you.x_pos;
            beam.target_y = you.y_pos;
            beam.name = "explosion";

            beam.name   = "explosion";

            beam.beam_source = NON_MONSTER;
            beam.thrower = (cause) ? KILL_MISC : KILL_YOU;
            beam.aux_source.clear();
            if (cause)
                beam.aux_source = cause;
            beam.ex_size = 1;
            beam.is_explosion = true;

            explosion(beam);

            _explosion();

            mpr("You are blasted with magical energy!");
            ouch(12 + random2avg(29, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg      = "You are blasted with magical energy!";
            mon_msg_seen = "@The_monster@ is blasted with magical energy!";
            // No message for invis monsters?
            _ouch(12 + random2avg(29, 2));

            mpr("There is a sudden explosion of magical energy!");
            beam.type = dchar_glyph(DCHAR_FIRED_BURST);
            beam.damage = dice_def( 3, 20 );

            all_msg = "There is a sudden explosion of magical energy!";
            beam.type    = dchar_glyph(DCHAR_FIRED_BURST);
            beam.damage  = dice_def( 3, 20 );

            beam.target_x = you.x_pos;
            beam.target_y = you.y_pos;
            beam.name = "explosion";
            beam.colour = random_colour();
            beam.beam_source = NON_MONSTER;
            beam.thrower = (cause) ? KILL_MISC : KILL_YOU;
            beam.aux_source.clear();
            if (cause)
                beam.aux_source = cause;

            beam.name    = "explosion";
            beam.colour  = random_colour();

            beam.is_explosion = true;

            explosion(beam);

            _explosion();

static void _your_hands_glow(actor* target, std::string& you_msg,
                             std::string& mon_msg_seen)
{
    you_msg      = "Your @hands@ ";
    mon_msg_seen = "@The_monster@'s @hands@ ";
    // No message for invisible monsters.

static void _miscast_enchantment(int severity, const char* cause)

    bool pluralized = true;
    target->hand_name(true, &pluralized);
    if (pluralized)
    {
       you_msg      += "glow";
       mon_msg_seen += "glow";
    }
    else
    {
        you_msg      += "glows";
        mon_msg_seen += "glows";
    }
    you_msg      += " momentarily.";
    mon_msg_seen += " momentarily.";
}
void MiscastEffect::_enchantment(int severity)

            msg::stream << "Your " << your_hand(true)
                        << " glow momentarily." << std::endl;

            _your_hands_glow(target, you_msg, mon_msg_seen);

            mpr("The air around you crackles with energy!");

            you_msg      = "The air around you crackles with energy!";
            mon_msg_seen = "The air around @the_monster@ crackles with"
                           " energy!";

            mpr("Multicolored lights dance before your eyes!");

            you_msg = "Multicolored lights dance before your eyes!";
            // Monster messages needed.

            mpr("You feel a strange surge of energy!");

            you_msg = "You feel a strange surge of energy!";
            // Monster messages needed.

            mpr("Waves of light ripple over your body.");

            you_msg      = "Waves of light ripple over your body.";
            mon_msg_seen = "Waves of light ripple over @the_monster@'s body.";

            mpr("Strange energies run through your body.");

            you_msg = "Strange energies run through your body.";
            // Monster messages needed.

            mpr("Your skin tingles.");

            you_msg = "Your skin tingles.";
            // Monster messages needed.

            mpr("Your skin glows momentarily.");

            you_msg      = "Your skin glows momentarily.";
            mon_msg_seen = "@The_monster@'s body glows momentarily.";

            canned_msg(MSG_NOTHING_HAPPENS);

            // Set nothing; canned_msg(MSG_NOTHING_HAPPENS) will be taken
            // care of elsewhere.

            if (!silenced(you.pos()))
                mpr("You hear something strange.", MSGCH_SOUND);
            else if (you.attribute[ATTR_TRANSFORMATION] != TRAN_AIR)
                mpr("Your skull vibrates slightly.");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (neither_end_silenced())
            {
                // XXX: Should use noisy().
                all_msg = "You hear something strange.";
                msg_ch  = MSGCH_SOUND;
                return;
            }
            else if (target->atype() == ACT_PLAYER
                     && you.attribute[ATTR_TRANSFORMATION] != TRAN_AIR)
            {
                you_msg = "Your skull vibrates slightly.";
            }

        do_msg();

            potion_effect(POT_LEVITATION, 20);

            _potion_effect(POT_LEVITATION, 20);

            // XXX: Something else for monsters?

            mpr("You sense a malignant aura.");
            curse_an_item(false);
            break;

            if (target->atype() == ACT_PLAYER)
            {
                mpr("You sense a malignant aura.");
                curse_an_item(false);
                break;
            }
            // Intentional fall-through for monsters.

            potion_effect(POT_SLOWING, 10);

            _potion_effect(POT_SLOWING, 10);

            potion_effect(POT_BERSERK_RAGE, 10);

            _potion_effect(POT_BERSERK_RAGE, 10);

        switch (random2(4))

        // Only use first two cases for monsters.
        switch (random2(target->atype() == ACT_PLAYER ? 4 : 2))

            _potion_effect(POT_PARALYSIS, 10);
            break;
        case 1:
            _potion_effect(POT_CONFUSION, 10);
            break;
        case 2:
            mpr("You feel saturated with unharnessed energies!");
            you.magic_contamination += random2avg(19,3);
            break;
        case 3:

            break;
        case 1:
            potion_effect(POT_PARALYSIS, 10);
            break;
        case 2:
            potion_effect(POT_CONFUSION, 10);
            break;
        case 3:
            mpr("You feel saturated with unharnessed energies!");
            you.magic_contamination += random2avg(19,3);

static void _miscast_translocation(int severity, const char* cause)

void MiscastEffect::_translocation(int severity)

    const god_type god =
        (crawl_state.is_god_acting()) ? crawl_state.which_god_acting()
                                      : GOD_NO_GOD;

            mpr("Space warps around you.");

            you_msg      = "Space warps around you.";
            mon_msg_seen = "Space warps around @the_monster@.";

            mpr("The air around you crackles with energy!");

            you_msg      = "The air around you crackles with energy!";
            mon_msg_seen = "The air around @the_monster@ crackles with "
                           "energy!";

            mpr("You feel a wrenching sensation.");

            you_msg = "You feel a wrenching sensation.";
            // Monster messages needed.

            mpr("You feel a strange surge of energy!");

            you_msg = "You feel a strange surge of energy!";
            // Monster messages needed.

            mpr("You spin around.");

            you_msg      = "You spin around.";
            mon_msg_seen = "@The_monster@ spins around.";

            mpr("Strange energies run through your body.");

            you_msg = "Strange energies run through your body.";
            // Monster messages needed.

            mpr("Your skin tingles.");

            you_msg = "Your skin tingles.";
            // Monster messages needed.

            mpr("The world appears momentarily distorted!");

            you_msg      = "The world appears momentarily distorted!";
            mon_msg_seen = "@The_monster@ appears momentarily distorted!";

            canned_msg(MSG_NOTHING_HAPPENS);

            // Set nothing; canned_msg(MSG_NOTHING_HAPPENS) will be taken
            // care of elsewhere.

            mpr("You feel uncomfortable.");

            you_msg = "You feel uncomfortable.";
            // Monster messages needed.

        do_msg();

            mpr("You are caught in a localised field of spatial distortion.");
            ouch(4 + random2avg(9, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg        = "You are caught in a localised field of spatial "
                             "distortion.";
            mon_msg_seen   = "@The_monster@ is caught in a localised field of "
                             "spatial distortion.";
            mon_msg_unseen = "A piece of empty space twists and distorts.";
            _ouch(4 + random2avg(9, 2));

            mpr("Space bends around you!");
            random_blink(false);
            ouch(4 + random2avg(7, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg        = "Space bends around you!";
            mon_msg_seen   = "Space bends around @the_monster@!";
            mon_msg_unseen = "A piece of empty space twists and distorts.";
            _ouch(4 + random2avg(7, 2));
            target->blink(false);

            if (create_monster(
                    mgen_data::hostile_at(MONS_SPATIAL_VORTEX,
                        you.pos(), 3, 0, false, god)) != -1)
            {
                mpr("Space twists in upon itself!");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (_create_monster(MONS_SPATIAL_VORTEX, 3))
                all_msg = "Space twists in upon itself!";
            do_msg();

            mpr("You are caught in a strong localised spatial distortion.");
            ouch(9 + random2avg(23, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg        = "You are caught in a strong localised spatial "
                             "distortion.";
            mon_msg_seen   = "@The_monster@ is caught in a strong localised "
                             "spatial distortion.";
            mon_msg_unseen = "A piece of empty space twists and writhes.";
            _ouch(9 + random2avg(23, 2));

            mpr("Space warps around you!");

            you_msg        = "Space warps around you!";
            mon_msg_seen   = "Space warps around @the_monster!";
            mon_msg_unseen = "A piece of empty space twists and writhes.";
            _ouch(5 + random2avg(9, 2));

                you_teleport_now( true );

                target->teleport(true);

                random_blink( false );

                target->blink(false);

            ouch(5 + random2avg(9, 2), 0, KILLED_BY_WILD_MAGIC, cause);
            potion_effect(POT_CONFUSION, 40);

            _potion_effect(POT_CONFUSION, 40);

                if (create_monster(
                        mgen_data::hostile_at(MONS_SPATIAL_VORTEX,
                            you.pos(), 3, 0, false, god)) != -1)
                {

                if (_create_monster(MONS_SPATIAL_VORTEX, 3))

                }

                mpr("Space twists in upon itself!");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

                all_msg = "Space twists in upon itself!";

            _send_abyss(cause);

            send_abyss();

        switch (random2(4))

        // Don't use the last case for monsters.
        switch (random2(target->atype() == ACT_PLAYER ? 4 : 3))

            mpr("You are caught in an extremely strong localised spatial distortion!");
            ouch(15 + random2avg(29, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg        = "You are caught in an extremely strong localised "
                             "spatial distortion!";
            mon_msg_seen   = "@The_monster@ is caught in an extremely strong "
                             "localised spatial distortion!";
            mon_msg_unseen = "A rift temporarily opens in the fabric of space!";
            _ouch(15 + random2avg(29, 2));

            mpr("Space warps crazily around you!");
            you_teleport_now( true );

            you_msg        = "Space warps crazily around you!";
            mon_msg_seen   = "Space warps crazily around @the_monster@!";
            mon_msg_unseen = "A rift temporarily opens in the fabric of space!";

            ouch(9 + random2avg(17, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            _ouch(9 + random2avg(17, 2));
            you_teleport_now( true );

            _send_abyss(cause);

            send_abyss();

static void _miscast_summoning(int severity, const char* cause)

void MiscastEffect::_summoning(int severity)

    const god_type god =
        (crawl_state.is_god_acting()) ? crawl_state.which_god_acting()
                                      : GOD_NO_GOD;

            mpr("Shadowy shapes form in the air around you, then vanish.");

            you_msg      = "Shadowy shapes form in the air around you, "
                           "then vanish.";
            mon_msg_seen = "Shadowy shapes form in the air around "
                           "@the_monster@, then vanish.";

            if (!silenced(you.pos()))
                mpr("You hear strange voices.", MSGCH_SOUND);
            else
                mpr("You feel momentarily dizzy.");

            if (neither_end_silenced())
            {
                all_msg = "You hear strange voices.";
                msg_ch  = MSGCH_SOUND;
            }
            else if (target->atype() == ACT_PLAYER)
                you_msg = "You feel momentarily dizzy.";

            mpr("Your head hurts.");

            you_msg = "Your head hurts.";
            // Monster messages needed.

            mpr("You feel a strange surge of energy!");

            you_msg = "You feel a strange surge of energy!";
            // Monster messages needed.

            mpr("Your brain hurts!");

            you_msg = "Your brain hurts!";
            // Monster messages needed.

            mpr("Strange energies run through your body.");

            you_msg = "Strange energies run through your body.";
            // Monster messages needed.

            mpr("The world appears momentarily distorted.");

            you_msg      = "The world appears momentarily distorted.";
            mon_msg_seen = "@The_monster@ appears momentarily distorted.";

            mpr("Space warps around you.");

            you_msg      = "Space warps around you.";
            mon_msg_seen = "Space warps around @the_monster@.";

            canned_msg(MSG_NOTHING_HAPPENS);

            // Set nothing; canned_msg(MSG_NOTHING_HAPPENS) will be taken
            // care of elsewhere.

            mpr("Distant voices call out to you!");

            if (neither_end_silenced())
            {
                you_msg      = "Distant voices call out to you!";
                mon_msg_seen = "Distant voices call out to @the_monster@!";
                msg_ch       = MSGCH_SOUND;
            }
            else if (target->atype() == ACT_PLAYER)
                you_msg = "You feel watched.";

        do_msg();

            mpr("You are caught in a localised spatial distortion.");
            ouch(5 + random2avg(9, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg        = "You are caught in a localised spatial "
                             "distortion.";
            mon_msg_seen   = "@The_monster@ is caught in a localised spatial "
                             "distortion.";
            mon_msg_unseen = "An empty piece of space distorts and twists.";
            _ouch(5 + random2avg(9, 2));

            if (create_monster(
                    mgen_data::hostile_at(MONS_SPATIAL_VORTEX,
                        you.pos(), 3, 0, false, god)) != -1)
            {
                mpr("Space twists in upon itself!");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (_create_monster(MONS_SPATIAL_VORTEX, 3))
                all_msg = "Space twists in upon itself!";
            do_msg();

            if (create_monster(
                    mgen_data::hostile_at(
                        summon_any_demon(DEMON_LESSER),
                        you.pos(), 5, 0, true, god)) != -1)
            {
                mpr("Something appears in a flash of light!");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (_create_monster(summon_any_demon(DEMON_LESSER), 5, true))
                all_msg = "Something appears in a flash of light!";
            do_msg();

                if (create_monster(
                        mgen_data::hostile_at(MONS_SPATIAL_VORTEX,
                            you.pos(), 3, 0, false, god)) != -1)
                {

                if (_create_monster(MONS_SPATIAL_VORTEX, 3))

                }

                mpr("Space twists in upon itself!");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

                all_msg = "Space twists in upon itself!";
            do_msg();

            if (create_monster(
                    mgen_data::hostile_at(
                        summon_any_demon(DEMON_COMMON),
                        you.pos(), 5, 0, true, god)) != -1)
            {
                mpr("Something forms out of thin air!");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (_create_monster(summon_any_demon(DEMON_COMMON), 5, true))
                all_msg = "Something forms from out of thin air!";
            do_msg();

                if (create_monster(
                        mgen_data::hostile_at(
                            summon_any_demon(DEMON_LESSER),
                            you.pos(), 5, 0, true, god)) != -1)
                {

                if (_create_monster(summon_any_demon(DEMON_LESSER), 5, true))

                }

            if (success)
                mpr("A chorus of chattering voices calls out to you!");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (success && neither_end_silenced())
            {
                you_msg = "A chorus of chattering voices calls out to you!";
                mon_msg = "A chorus of chattering voices calls out!";
                msg_ch  = MSGCH_SOUND;
            }
            do_msg();

            if (create_monster(
                    mgen_data::hostile_at(MONS_ABOMINATION_SMALL,
                        you.pos(), 0, 0, true, god)) != -1)
            {
                mpr("Something forms out of thin air.");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (_create_monster(MONS_ABOMINATION_SMALL, 0, true))
                all_msg = "Something forms from out of thin air.";
            do_msg();

            if (create_monster(
                    mgen_data::hostile_at(
                        summon_any_demon(DEMON_GREATER),
                        you.pos(), 0, 0, true, god)) != -1)
            {
                mpr("You sense a hostile presence.");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            if (_create_monster(summon_any_demon(DEMON_GREATER), 0, true))
                all_msg = "You sense a hostile presence.";
            do_msg();

                if (create_monster(
                        mgen_data::hostile_at(
                            summon_any_demon(DEMON_COMMON),
                            you.pos(), 3, 0, true, god)) != -1)
                {

                if (_create_monster(summon_any_demon(DEMON_COMMON), 3, true))

                }

                mpr("Something turns its malign attention towards you...");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            {
                you_msg = "Something turns its malign attention towards "
                          "you...";
                mon_msg = "You sense a malign presence.";
            }
            do_msg();

            _send_abyss(cause);

            send_abyss();

static void _miscast_divination(int severity, const char* cause)

void MiscastEffect::_divination_you(int severity)

static void _miscast_necromancy(int severity, const char* cause)

// XXX: Monster divination miscasts.
void MiscastEffect::_divination_mon(int severity)

    if (you.religion == GOD_KIKUBAAQUDGHA

}
void MiscastEffect::_necromancy(int severity)
{
    if (target->atype() == ACT_PLAYER && you.religion == GOD_KIKUBAAQUDGHA

    const god_type god =
        (crawl_state.is_god_acting()) ? crawl_state.which_god_acting()
                                      : GOD_NO_GOD;

                mpr("You smell decay.");

                all_msg = "You smell decay.";

                mpr("Your bandages flutter.");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

                you_msg = "Your bandages flutter.";

            if (!silenced(you.pos()))
                mpr("You hear strange and distant voices.", MSGCH_SOUND);
            else
                mpr("You feel homesick.");

            if (neither_end_silenced())
            {
                all_msg = "You hear strange and distant voices.";
                msg_ch  =  MSGCH_SOUND;
            }
            else if (target->atype() == ACT_PLAYER)
                you_msg = "You feel homesick.";

            mpr("Pain shoots through your body.");

            you_msg = "Pain shoots through your body.";
            // Monster messages needed.

            mpr("Your bones ache.");

            you_msg = "Your bones ache.";
            // Monster messages needed.

            mpr("The world around you seems to dim momentarily.");

            you_msg      = "The world around you seems to dim momentarily.";
            mon_msg_seen = "@The_monster@ seems to dim momentarily.";

            mpr("Strange energies run through your body.");

            you_msg = "Strange energies run through your body.";
            // Monster messages needed.

            mpr("You shiver with cold.");

            you_msg = "You shiver with cold.";
            // Monster messages needed.

            mpr("You sense a malignant aura.");

            you_msg = "You sense a malignant aura.";
            // Monster messages needed.

            canned_msg(MSG_NOTHING_HAPPENS);

            // Set nothing; canned_msg(MSG_NOTHING_HAPPENS) will be taken
            // care of elsewhere.

            mpr("You feel very uncomfortable.");

            you_msg = "You feel very uncomfortable.";
            // Monster messages needed.

            if (player_res_torment())

            // Monster messages needed.
            if (target->res_torment())

                mpr("You feel weird for a moment.");

                you_msg = "You feel weird for a moment.";
                do_msg();

            mpr("Pain shoots through your body!");
            ouch(5 + random2avg(15, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg = "Pain shoots through your body!";
            _ouch(5 + random2avg(15, 2));

            mpr("You feel horribly lethargic.");
            potion_effect(POT_SLOWING, 15);

            you_msg = "You feel horribly lethargic.";
            // Monster messages needed.
            _potion_effect(POT_SLOWING, 15);

            if (player_can_smell() && you.res_rotting() == 0)

            if (target->res_rotting() == 0)

                mpr("You smell decay."); // identical to a harmless message
                you.rotting++;

                if (player_can_smell())
                    // identical to a harmless message
                    all_msg = "You smell decay.";
                if (target->atype() == ACT_PLAYER)
                    you.rotting++;
                else
                    mon_target->add_ench( mon_enchant(ENCH_ROT, 1, kc) );

                mpr("Your bandages flutter.");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

                // Monster messages needed.
                you_msg = "Your bandages flutter.";
            do_msg();

                if (create_monster(
                        mgen_data::hostile_at(MONS_SHADOW,
                            you.pos(), 2, 0, true, god)) != -1)
                {

                if (_create_monster(MONS_SHADOW, 2, true))

                }

                mpr("Flickering shadows surround you.");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            {
                you_msg        = "Flickering shadows surround you.";
                mon_msg_seen   = "Flickering shadows surround @the_monster@.";
                mon_msg_unseen = "Shadows flicker in the thin air.";
            }
            do_msg();

            if (!player_prot_life() && one_chance_in(3))

            if (target->atype() == ACT_PLAYER && !player_prot_life()
                && one_chance_in(3))

            if (player_res_torment())

            // Monster messages needed.
            if (target->res_torment())

                mpr("You feel weird for a moment.");

                you_msg = "You feel weird for a moment.";
                do_msg();

            mpr("You convulse helplessly as pain tears through your body!");
            ouch(15 + random2avg(23, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg = "You convulse helplessly as pain tears through "
                      "your body!";
            _ouch(15 + random2avg(23, 2));

        switch (random2(6))

        // Don't use two last cases for monsters.
        switch (random2(target->atype() == ACT_PLAYER ? 6 : 4))

            if (you.is_undead)

            if (target->holiness() == MH_UNDEAD)

                mpr("Something just walked over your grave. No, really!");

                // Monster messages needed.
                you_msg = "Something just walked over your grave. No, really!";
                do_msg();

            torment_monsters(you.pos(), 0, TORMENT_GENERIC);

            torment_monsters(target->pos(), 0, TORMENT_GENERIC);

            mpr("You are engulfed in negative energy!");

            target->rot(act_source, random2avg(7, 2) + 1, 0);
            break;

            if (!player_prot_life())

        case 2:
            if (_create_monster(MONS_SOUL_EATER, 4, true))

                drain_exp();
                break;
            }               // otherwise it just flows through...
        case 2:
            lose_stat(STAT_RANDOM, 1 + random2avg(7, 2), false, cause);

                // Monster messages needed.
                you_msg = "Something reaches out for you...";
            }
            do_msg();

            rot_player( random2avg(7, 2) + 1 );

            if (_create_monster(MONS_REAPER, 4, true))
            {
                // Monster messages needed.
                you_msg = "Death has come for you...";
            }
            do_msg();

            if (create_monster(
                    mgen_data::hostile_at(MONS_SOUL_EATER,
                        you.pos(), 4, 0, true, god)) != -1)

            mpr("You are engulfed in negative energy!");
            if (!player_prot_life())

                mpr("Something reaches out for you...");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);
            break;

                drain_exp();
                break;
            }               // otherwise it just flows through...

            if (create_monster(
                    mgen_data::hostile_at(MONS_REAPER,
                        you.pos(), 4, 0, true, god)) != -1)
            {
                mpr("Death has come for you...");
            }
            else
                canned_msg(MSG_NOTHING_HAPPENS);

            lose_stat(STAT_RANDOM, 1 + random2avg(7, 2), false, cause);

static void _miscast_transmigration(int severity, const char* cause)

void MiscastEffect::_transmigration(int severity)

            msg::stream << "Your " << your_hand(true)
                        << " glow momentarily." << std::endl;

            _your_hands_glow(target, you_msg, mon_msg_seen);

            mpr("The air around you crackles with energy!");

            you_msg        = "The air around you crackles with energy!";
            mon_msg_seen   = "The air around @the_monster@ crackles with"
                             " energy!";
            mon_msg_unseen = "The thin air crackles with energy!";

            mpr("Multicolored lights dance before your eyes!");

            you_msg = "Multicolored lights dance before your eyes!";
            // Monster messages needed.

            mpr("You feel a strange surge of energy!");

            you_msg = "You feel a strange surge of energy!";
            // Monster messages needed.

            mpr("Waves of light ripple over your body.");

            you_msg        = "Waves of light ripple over your body.";
            mon_msg_seen   = "Waves of light ripple over @the_monster@'s body.";
            mon_msg_unseen = "Waves of light ripple in the air.";

            mpr("Strange energies run through your body.");

            you_msg = "Strange energies run through your body.";
            // Monster messages needed.

            mpr("Your skin tingles.");

            you_msg = "Your skin tingles.";
            // Monster messages needed.

            mpr("Your skin glows momentarily.");

            you_msg      = "Your skin glows momentarily.";
            mon_msg_seen = "@The_monster@'s body glows momentarily.";

            canned_msg(MSG_NOTHING_HAPPENS);

            // Set nothing; canned_msg(MSG_NOTHING_HAPPENS) will be taken
            // care of elsewhere.

                mpr("You smell something strange.");

                all_msg = "You smell something strange.";

                mpr("Your bandages flutter.");
            else
                canned_msg(MSG_NOTHING_HAPPENS);

                you_msg = "Your bandages flutter.";

        do_msg();

            mpr("Your body is twisted painfully.");
            ouch(1 + random2avg(11, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg      = "Your body is twisted painfully.";
            mon_msg_seen = "@The_monster@'s body twists unnaturally.";
            _ouch(1 + random2avg(11, 2));

        switch (random2(4))

        // Last case for players only.
        switch (random2(target->atype() == ACT_PLAYER ? 4 : 3))

            mpr("Your body is twisted very painfully!");
            ouch(3 + random2avg(23, 2), 0, KILLED_BY_WILD_MAGIC, cause);

            you_msg      = "Your body is twisted very painfully!";
            mon_msg_seen = "@The_monster@'s body twists and writhes.";
            _ouch(3 + random2avg(23, 2));

            mpr("You feel saturated with unharnessed energies!");
            you.magic_contamination += random2avg(19,3);

            _potion_effect(POT_PARALYSIS, 10);