/*
 *  File:       xom.h
 *  Summary:    Misc Xom related functions.
 *  Written by: Linley Henzell
 *
 *  Modified for Crawl Reference by $Author$ on $Date$
 *
 *  Change History (most recent first):
 *
 *               <1>     09/28/07        MPC             Split from religion.h
 */
#ifndef XOM_H
#define XOM_H
class item_def;
enum xom_message_type
{
    XM_NORMAL,
    XM_INTRIGUED,
    NUM_XOM_MESSAGE_TYPES
};
void xom_is_stimulated(int maxinterestingness,
                       xom_message_type message_type = XM_NORMAL,
                       bool force_message = false);
void xom_is_stimulated(int maxinterestingness, std::string message,
                       bool force_message = false);
bool xom_is_nice();
void xom_acts(bool niceness, int sever);
const char *describe_xom_favour();
inline void xom_acts(int sever)
{
    xom_acts(xom_is_nice(), sever);
}
void xom_check_lost_item(item_def& item);
#endif

#include "randart.h"

#include "xom.h"

#if DEBUG_RELIGION
#    define DEBUG_DIAGNOSTICS 1
#    define DEBUG_GIFTS       1
#endif
#if DEBUG_XOM
#    define DEBUG_DIAGNOSTICS 1
#    define DEBUG_RELIGION    1
#    define DEBUG_GIFTS       1
#endif

void xom_is_stimulated(int maxinterestingness)

static const char* xom_message_arrays[NUM_XOM_MESSAGE_TYPES][6] =
{
    // XM_NORMAL
    {
        "Xom roars with laughter!",
        "Xom thinks this is hilarious!",
        "Xom is highly amused!",
        "Xom is amused.",
        "Xom is mildly amused.",
        "Xom is interested."
    },
    // XM_INTRIGUED
    {
        "Xom is fascinated!",
        "Xom is very intrigued!",
        "Xom is intrigued!",
        "Xom is extremely interested.",
        "Xom is very interested.",
        "Xom is interested."
    }
};
static void _xom_is_stimulated(int maxinterestingness,
                               const char* message_array[],
                               bool force_message)

    if (you.religion != GOD_XOM)

    if (you.religion != GOD_XOM || maxinterestingness <= 0)

    if (interestingness < 12)
        return;

#if DEBUG_RELIGION || DEBUG_GIFTS || DEBUG_XOM
    mprf(MSGCH_DIAGNOSTICS,
         "Xom: maxinterestingness = %d, interestingness = %d",
         maxinterestingness, interestingness);
#endif

    if (interestingness > you.gift_timeout)

    bool was_stimulated = false;
    if (interestingness > you.gift_timeout && interestingness >= 12)

        god_speaks(GOD_XOM,
                   ((interestingness > 200) ? "Xom roars with laughter!" :
                    (interestingness > 100) ? "Xom thinks this is hilarious!" :
                    (interestingness > 75) ? "Xom is highly amused!" :
                    (interestingness > 50) ? "Xom is amused." :
                    (interestingness > 25) ? "Xom is mildly amused." :
                    "Xom is interested."));

        was_stimulated = true;

    if (was_stimulated || force_message)
        god_speaks(GOD_XOM,
                   ((interestingness > 200) ? message_array[5] :
                    (interestingness > 100) ? message_array[4] :
                    (interestingness > 75) ? message_array[3] :
                    (interestingness > 50) ? message_array[2] :
                    (interestingness > 25) ? message_array[1] :
                    message_array[0]));
}
void xom_is_stimulated(int maxinterestingness, xom_message_type message_type,
                       bool force_message)
{
    _xom_is_stimulated(maxinterestingness, xom_message_arrays[message_type],
                       force_message);
}
void xom_is_stimulated(int maxinterestingness, std::string message,
                       bool force_message)
{
    const char* message_array[6];
    for (int i = 0; i < 6; i++)
        message_array[i] = message.c_str();
    _xom_is_stimulated(maxinterestingness, message_array, force_message);

#if DEBUG_DIAGNOSTICS

#if DEBUG_DIAGNOSTICS || DEBUG_RELIGION || DEBUG_XOM

                   : "You hear Xom's maniacal chuckling.");

                   : "You hear Xom's maniacal cackling.");

#if DEBUG_DIAGNOSTICS

#if DEBUG_DIAGNOSTICS || DEBUG_RELIGION || DEBUG_XOM

    entry_cause_type old_entry_cause = you.entry_cause;

    // Nemelex's deck of punishment drawing the Xom card
    if (crawl_state.is_god_acting()
        && crawl_state.which_god_acting() != GOD_XOM)
    {
        god_type which_god = crawl_state.which_god_acting();
        if (crawl_state.is_god_retribution())
        {
            niceness = false;
            mprf(MSGCH_GOD, which_god,
                 "%s asks Xom for help in punishing you, and Xom happily "
                 "agrees.", god_name(which_god));
        }
        else
        {
            niceness = true;
            mprf(MSGCH_GOD, which_god,
                 "%s calls in a favour from Xom.", god_name(which_god));
        }
    }

    // Nemelex's deck of punishment drawing the Xom card
    if (crawl_state.is_god_acting()
        && crawl_state.which_god_acting() != GOD_XOM)
    {
        if (old_entry_cause != you.entry_cause
            && you.entry_cause_god == GOD_XOM)
        {
            you.entry_cause_god = crawl_state.which_god_acting();
        }
    }

}
void xom_check_lost_item(item_def& item)
{
    if (item.base_type == OBJ_ORBS)
        xom_is_stimulated(255, "Xom laughs nastily.", true);
    else if (is_fixed_artefact(item))
        xom_is_stimulated(128, "Xom snickers.", true);
    else if (is_rune(item))
    {
        if (is_unique_rune(item))
            xom_is_stimulated(255, "Xom snickers loudly.", true);
        else if (you.entry_cause == EC_SELF_EXPLICIT &&
                !(item.flags & ISFLAG_DROPPED))
        {
            // Player voluntarily entered Pan or the Abyss looking
            // for runes, yet never found it.
            if (item.plus == RUNE_ABYSSAL)
            {
                // Ignore Abyss area shifts.
                if (you.level_type != LEVEL_ABYSS)
                    // Abyssal runes are a lot more trouble to find
                    // than demonic runes, so it gets twice the
                    // stimulation.
                    xom_is_stimulated(128, "Xom snickers.", true);
            }
            else
                xom_is_stimulated(64, "Xom snickers softly.", true);
        }
    }

#include "xom.h"

    int num_hostile = 0;

                if (mons_attitude(monster) == ATT_HOSTILE)
                    num_hostile++;

    // Xom thinks it's hilarious the way the player picks up an ever
    // growing entourage of monsters while running through the Abyss.
    // To approximate this, if the number of hostile monsters in view
    // is greater than it ever was for this particular trip to the
    // Abyss, Xom is stimulated in proprotion to the number of
    // hostile monsters.  Thus if the entourage doesn't grow, then
    // Xom becomes bored.
    if (you.level_type == LEVEL_ABYSS
        && you.attribute[ATTR_ABYSS_ENTOURAGE] < num_hostile)
    {
        you.attribute[ATTR_ABYSS_ENTOURAGE] = num_hostile;
        xom_is_stimulated(16 * num_hostile);
    }

    marshallByte(th,you.entry_cause);
    marshallByte(th,you.entry_cause_god);

    you.entry_cause = static_cast<entry_cause_type>( unmarshallByte(th) );
    you.entry_cause_god = static_cast<god_type>( unmarshallByte(th) );

    god_act.retribution = is_retribution;

    god_act.retribution = is_retribution || god_act.retribution;

#include "xom.h"

#include "religion.h"

                            "a distortion effect" );

                            "cast bend on self" );

                            "a distortion effect" );

                            "cast bend on self" );

#include "religion.h"

#include "xom.h"

    // dangerous place.
    if (randtele && player_in_a_dangerous_place())

    // dangerous place, unless the player is in the Abyss and
    // teleported to escape from all the monsters chasing him/her,
    // since in that case the new dangerous area is almost certainly
    // *less* dangerous than the old dangerous area.
    if (randtele && player_in_a_dangerous_place()
        && you.level_type != LEVEL_ABYSS)
    {

    }

#include "xom.h"

            bool was_butchering = is_being_butchered(item);

            {

                if (was_butchering)
                    xom_is_stimulated(255);
            }

        //                9, 90, 100, "a distortion effect");

        //                9, 90, 100, "distortion branding");

#include "religion.h"

bool xom_is_nice();
void xom_is_stimulated(int maxinterestingness);
void xom_acts(bool niceness, int sever);
const char *describe_xom_favour();

inline void xom_acts(int sever)
{
    xom_acts(xom_is_nice(), sever);
}

#include "xom.h"

#include "xom.h"

    where_are_you = BRANCH_MAIN_DUNGEON;

    entry_cause     = EC_SELF_EXPLICIT;
    entry_cause_god = GOD_NO_GOD;
    where_are_you  = BRANCH_MAIN_DUNGEON;

#include "xom.h"

    if ((death_type != KILLED_BY_MONSTER && death_type != KILLED_BY_BEAM)
        || death_source < 0 || death_source >= MAX_MONSTERS)

    if (death_type == KILLED_BY_TARGETTING)
    {
        // Xom thinks the player hurting him/herself is funny.
        xom_is_stimulated(255 * dam / (dam + you.hp));
        return;
    }
    else if (death_type == KILLED_BY_FALLING_DOWN_STAIRS)
    {
        // Xom thinks falling down the stairs is hilarious
        xom_is_stimulated(255);
        return;
    }
    else if ((death_type != KILLED_BY_MONSTER && death_type != KILLED_BY_BEAM)
             || death_source < 0 || death_source >= MAX_MONSTERS)

    if (mons_attitude(monster) == ATT_FRIENDLY)
    {
        // Xom thinks collateral damage is funny
        xom_is_stimulated(255 * dam / (dam + you.hp));
        return;
    }

#include "xom.h"

#include "xom.h"

        // Xom is amused by useful potions being ruined.
        if (item_value(you.inv[item], true) / you.inv[item].quantity > 2)
            xom_is_stimulated(32 * you.inv[item].quantity);

void down_stairs(int old_level, dungeon_feature_type force_stair = DNGN_UNSEEN);

void down_stairs(int old_level,
                 dungeon_feature_type force_stair = DNGN_UNSEEN,
                 entry_cause_type entry_cause = EC_UNKNOWN);

void up_stairs(dungeon_feature_type force_stair = DNGN_UNSEEN);

void up_stairs(dungeon_feature_type force_stair = DNGN_UNSEEN,
               entry_cause_type entry_cause = EC_UNKNOWN);

#include "state.h"

#include "xom.h"

}
static void set_entry_cause(entry_cause_type default_cause,
                            level_area_type old_level_type)
{
    ASSERT(default_cause != NUM_ENTRY_CAUSE_TYPES);
    if (old_level_type == you.level_type)
        return;
    if (crawl_state.is_god_acting())
    {
        if (crawl_state.is_god_retribution())
            you.entry_cause = EC_GOD_RETRIUBTION;
        else
            you.entry_cause = EC_GOD_ACT;
        you.entry_cause_god = crawl_state.which_god_acting();
    }
    else if (default_cause != EC_UNKNOWN)
    {
        you.entry_cause     = default_cause;
        you.entry_cause_god = GOD_NO_GOD;
    }
    else
    {
        you.entry_cause     = EC_SELF_EXPLICIT;
        you.entry_cause_god = GOD_NO_GOD;
    }

void up_stairs(dungeon_feature_type force_stair)

static int runes_in_pack()
{
    int num_runes = 0;
    for (int i = 0; i < ENDOFPACK; i++)
    {
        if (is_valid_item( you.inv[i] )
            && you.inv[i].base_type == OBJ_MISCELLANY
            && you.inv[i].sub_type == MISC_RUNE_OF_ZOT)
        {
            num_runes += you.inv[i].quantity;
        }
    }
    return num_runes;
}
void up_stairs(dungeon_feature_type force_stair,
               entry_cause_type entry_cause)

    set_entry_cause(entry_cause, old_level_type);
    entry_cause = you.entry_cause;

    // Left Zot without enough runes to get back in (probably because
    // of dropping some runes within Zot), but need to get back in Zot
    // to get the Orb?  Zom finds that funny.
    if (stair_find == DNGN_RETURN_FROM_ZOT
        && runes_in_pack() < NUMBER_OF_RUNES_NEEDED
        && (branches[BRANCH_HALL_OF_ZOT].branch_flags & BFLAG_HAS_ORB))
    {
        xom_is_stimulated(255, "Xom snickers loudly.", true);
    }

void down_stairs( int old_level, dungeon_feature_type force_stair )

void down_stairs( int old_level, dungeon_feature_type force_stair,
                  entry_cause_type entry_cause )

        int num_runes = 0;

        int num_runes = runes_in_pack();

        for (i = 0; i < ENDOFPACK; i++)
        {
            if (is_valid_item( you.inv[i] )
                && you.inv[i].base_type == OBJ_MISCELLANY
                && you.inv[i].sub_type == MISC_RUNE_OF_ZOT)
            {
                num_runes += you.inv[i].quantity;
            }
        }

        more();

        if (!(you.wizard && crawl_state.is_replaying_keys()))
            more();

    set_entry_cause(entry_cause, old_level_type);
    entry_cause = you.entry_cause;

        xom_is_stimulated(49);

    {
        switch(you.level_type)
        {
        case LEVEL_DUNGEON:
            xom_is_stimulated(49);
            break;
        case LEVEL_PORTAL_VAULT:
            // Portal vaults aren't as interesting.
            xom_is_stimulated(25);
            break;
        case LEVEL_LABYRINTH:
            // Finding the way out of a labyrinth interests Xom.
            xom_is_stimulated(98);
            break;
        case LEVEL_ABYSS:
        case LEVEL_PANDEMONIUM:
        {
            // Paranoia
            if (old_level_type == you.level_type)
                break;

            PlaceInfo &place_info = you.get_place_info();
            // Entering voluntarily only stimulates Xom if you've never
            // been there before
            if ((place_info.num_visits == 1 && place_info.levels_seen == 1)
                || entry_cause != EC_SELF_EXPLICIT)
            {
                if (crawl_state.is_god_acting())
                    xom_is_stimulated(256);
                else if (entry_cause == EC_SELF_EXPLICIT)
                {
                    // Entering Pandemonium or the Abyss for the first
                    // time *voluntarily* stimulates Xom much more than
                    // entering a normal dungeon level for the first time.
                    xom_is_stimulated(128, XM_INTRIGUED);
                }
                else if (entry_cause == EC_SELF_RISKY)
                    xom_is_stimulated(128);
                else
                    xom_is_stimulated(256);
            }
            break;
        }
        default:
            ASSERT(false);
        }
    }

bool is_unique_rune(const item_def &item);

bool item_is_equipped(const item_def &item);

#include "branch.h"

#include "xom.h"

            xom_check_lost_item( mitm[o] );

    return (item.base_type == OBJ_MISCELLANY &&
            item.sub_type == MISC_RUNE_OF_ZOT);

    return (item.base_type == OBJ_MISCELLANY
            && item.sub_type == MISC_RUNE_OF_ZOT);
}
bool is_unique_rune(const item_def &item)
{
    return (item.base_type == OBJ_MISCELLANY
            && item.sub_type == MISC_RUNE_OF_ZOT
            && item.plus != RUNE_DEMONIC
            && item.plus != RUNE_ABYSSAL);

        xom_is_stimulated(255, XM_INTRIGUED);

    if (item.base_type == OBJ_ORBS && you.level_type == LEVEL_DUNGEON)
        unset_branch_flags(BFLAG_HAS_ORB);

    if (mitm[*obj].base_type == OBJ_ORBS && you.level_type == LEVEL_DUNGEON)
        set_branch_flags(BFLAG_HAS_ORB);

bool item_is_equipped(const item_def &item)
{
    if (item.x != -1 || item.y != -1)
        return (false);
    for (int i = 0; i < NUM_EQUIP; i++)
    {
        if (you.equip[i] == EQ_NONE)
            continue;
        item_def& eq(you.inv[you.equip[i]]);
        if (!is_valid_item(eq))
            continue;
        if (eq.slot == item.slot)
            return (true);
        else if (&eq == &item)
            return (true);
    }
    return (false);
}

#include "xom.h"

    // Xom is amused by the player's items being cursed, especially
    // if they're worn/equipped.
    if (!(item.flags & ISFLAG_CURSED) && item.x == -1 && item.y == -1)
    {
        int amusement = 64;
        if (item_is_equipped(item))
        {
            amusement *= 2;
            // Cursed cloaks prevent you from removing body armour
            if (item.base_type == OBJ_ARMOUR
                && get_armour_slot(item) == EQ_CLOAK)
            {
                amusement *= 2;
            }
        }
        xom_is_stimulated(amusement);
    }

#include "shopping.h"

#include "xom.h"

    const bool known_cursed = item_known_cursed(you.inv[item_wield_2]);

                miscast_effect( SPTYP_TRANSLOCATION, 9, 90, 100, "a distortion effect" );

                if (!was_known)
                    xom_is_stimulated(128);
                miscast_effect( SPTYP_TRANSLOCATION, 9, 90, 100,
                                was_known ? "distortion wield" :
                                            "uknowning distortion wield");

            xom_is_stimulated(64);

            if (known_cursed)
                xom_is_stimulated(32);
            else
                xom_is_stimulated(64);

    const bool artefact = is_random_artefact( item );
    const bool identified = fully_identified( item );

    const bool artefact     = is_random_artefact( item );
    const bool identified   = fully_identified( item );
    const bool known_cursed = item_known_cursed( item );
    const bool known_bad    = item_type_known( item )
        && (item_value( item ) <= 2);

        xom_is_stimulated(128);

        if (known_cursed || known_bad)
            xom_is_stimulated(64);
        else
            xom_is_stimulated(128);

                        "a distortion effect" );

                        "distortion affixation" );

#include "xom.h"

#include "xom.h"

                                "a distortion effect" );

                                "distortion unwield" );

#include "xom.h"

#include "xom.h"

// Should be called afetr grab_followers(), so that items carried by
// followers won't be considered lost.
static void _xom_check_lost_items(level_area_type old_level_type)
{
    if (old_level_type == LEVEL_DUNGEON)
        return;
    
    int amusement = 0;

    for (int i = 0; i < MAX_ITEMS; i++)
    {
        item_def& item(mitm[i]);
        if (!is_valid_item(item))
            continue;
        // Item is in player intentory, so it's not lost.
        if (item.x == -1 && item.y == -1)
            continue;
        xom_check_lost_item(item);
    }
}

    _xom_check_lost_items(old_level_type);

    if (just_created_level)
        you.attribute[ATTR_ABYSS_ENTOURAGE] = 0;

#include "xom.h"

    // Xom thinks fumbles are funny...

        xom_is_stimulated(14); // Xom thinks that is funny.

        // ... and thinks fumbling when trying to hit yourself is just
        // hilarious.
        if (attacker == defender)
            xom_is_stimulated(255);
        else
            xom_is_stimulated(14);

    // Non-fumbled self-attacks due to confusion are still pretty
    // funny, though.
    else if (attacker == defender && attacker->confused())
    {
        // And is still hilarious if it's the player.
        if (attacker->atype() == ACT_PLAYER)
            xom_is_stimulated(255);
        else
            xom_is_stimulated(128);
    }

  entry_cause_type entry_cause;
  god_type         entry_cause_god;

    ATTR_ABYSS_ENTOURAGE,       // maximum number of hostile monsters in
                                // sight of the player while in the Abyss.

enum entry_cause_type
{
    EC_UNKNOWN,
    EC_SELF_EXPLICIT,
    EC_SELF_RISKY,    // i.e., wielding an id'd distorion weapon
    EC_SELF_ACCIDENT, // i.e., wielding an un-id'd distortion weapon
    EC_MISCAST,
    EC_GOD_RETRIUBTION,
    EC_GOD_ACT, // Xom sending the player somewhere for amusement
    EC_MONSTER,
    NUM_ENTRY_CAUSE_TYPES
};

#include "religion.h"

#include "state.h"

#include "xom.h"

    down_stairs(you.your_level, gate_type);  // heh heh

    // Now figure out how we got here.
    if (who.find("self") != std::string::npos || who == you.your_name
        || who == "you" || who == "You" || crawl_state.is_god_acting())
    {
        // down_stairs() will take care of setting things.
        you.entry_cause = EC_UNKNOWN;
    }
    else if (who.find("distortion") != std::string::npos)
    {
        if (who.find("wield") != std::string::npos)
        {
            if (who.find("unknowing") != std::string::npos)
                you.entry_cause = EC_SELF_ACCIDENT;
            else
                you.entry_cause = EC_SELF_RISKY;
        }
        else if (who.find("affixation") != std::string::npos)
            you.entry_cause = EC_SELF_ACCIDENT;
        else if (who.find("branding")  != std::string::npos)
            you.entry_cause = EC_SELF_RISKY;
        else
            you.entry_cause = EC_MONSTER;
    }
    else if (who == "drawing a card")
        you.entry_cause = EC_SELF_RISKY;
    else if (who.find("miscast") != std::string::npos)
        you.entry_cause = EC_MISCAST;
    else if (who == "wizard command")
        you.entry_cause = EC_SELF_EXPLICIT;
    else
        you.entry_cause = EC_MONSTER;

    if (gate_type == DNGN_ENTER_ABYSS || gate_type == DNGN_ENTER_PANDEMONIUM)
        xom_is_stimulated(255);

    down_stairs(you.your_level, gate_type, you.entry_cause);  // heh heh

#include "xom.h"

#include "xom.h"

}
// Xom is amused by a potential food source going to waste, and is
// more amused the hungrier you are.
static void xom_check_corpse_waste()
{
    int food_need = 7000 - you.hunger;
    if (food_need < 0)
        food_need = 0;
    xom_is_stimulated(64 + (191 * food_need / 6000));

        // original and that's why we do it this way.  Note that 
        // we ignore the conversion to skeleton possibility just to 
        // be nice. -- bwr

        // original and that's why we do it this way.

            // special < 100 is the rottenness check
            if ( (mitm[delay.parm1].special < 100) &&
                 (delay.parm2 >= 100) )

            if (mitm[ delay.parm1 ].sub_type == CORPSE_SKELETON)

                mpr("The corpse rots.", MSGCH_ROTTEN_MEAT);
                delay.parm2 = 99; // don't give the message twice

                mpr("The corpse rots away into a skeleton!");
                if (you.species == SP_GHOUL)
                    xom_check_corpse_waste();
                else
                    xom_is_stimulated(32);
                delay.duration = 0;

            else
            {
                // special < 100 is the rottenness check
                if ( (mitm[delay.parm1].special < 100) &&
                     (delay.parm2 >= 100) )
                {
                    mpr("The corpse rots.", MSGCH_ROTTEN_MEAT);
                    delay.parm2 = 99; // don't give the message twice

            // mark work done on the corpse in case we stop -- bwr
            mitm[ delay.parm1 ].plus2++;

                    if (you.species != SP_VAMPIRE
                        && you.species != SP_MUMMY
                        && you.species != SP_GHOUL)
                    {
                        xom_check_corpse_waste();
                    }
                }
                // mark work done on the corpse in case we stop -- bwr
                mitm[ delay.parm1 ].plus2++;
            }

            if (item.sub_type == CORPSE_SKELETON)
            {
                mpr("The corpse rots away into a skeleton just before you "
                    "finish butchering it!");
                if (you.species == SP_GHOUL)
                    xom_check_corpse_waste();
                else
                    xom_is_stimulated(64);
                break;
            }

    const equipment_type eq_slot = get_armour_slot(arm);

    const equipment_type eq_slot      = get_armour_slot(arm);
    const bool           known_cursed = item_known_cursed(arm);

        xom_is_stimulated(128);

        // Cursed cloaks prevent you from removing body armour
        int cloak_mult = 1;
        if (get_armour_slot(arm) == EQ_CLOAK)
            cloak_mult = 2;
        if (known_cursed)
            xom_is_stimulated(32 * cloak_mult);
        else
            xom_is_stimulated(64 * cloak_mult);

#include "xom.h"

static card_type choose_one_card(const item_def& item, bool message)

static card_type choose_one_card(const item_def& item, bool message,
                                 bool &was_oddity)

        pdeck = &deck_of_oddities;

        pdeck      = &deck_of_oddities;
        was_oddity = true;

static card_type choose_one_card(const item_def& item, bool message)
{
    bool garbage;
    return choose_one_card(item, message, garbage);
}

        card_effect( choose_one_card(deck, true), deck_rarity(deck) );

        // Could a Xom worshipper ever get a stacked deck in the first
        // place?
        int       amusement  = 64;
        bool      was_oddity = false;
        card_type card       = choose_one_card(deck, true, was_oddity);
        if (!item_type_known(deck))
            amusement *= 2;
        // Expecting one type of card but got another, real funny.
        else if (was_oddity)
            amusement = 255;
        if (player_in_a_dangerous_place())
            amusement *= 2;
        switch (card)
        {
        case CARD_XOM:
            // Handled elswehre
            amusement = 0;
            break;
        case CARD_BLANK:
            // Boring
            amusement = 0;
            break;
        case CARD_DAMNATION:
            // Nothing happened, boring.
            if (you.level_type != LEVEL_DUNGEON)
                amusement = 0;
            break;

        case CARD_MINEFIELD:
        case CARD_FAMINE:
        case CARD_CURSE:
            // Always hilarious.
            amusement = 255;
        default:
            break;
        }
        card_effect(card, deck_rarity(deck) );
        xom_is_stimulated(amusement);

            banished(DNGN_ENTER_ABYSS);

            banished(DNGN_ENTER_ABYSS, "drawing a card");

    if (which_card == CARD_XOM && !crawl_state.is_god_acting())
    {
        if (you.religion == GOD_XOM)
        {
            // Being a self-centered diety, Xom *always* finds this
            // maximally hilarious.
            god_speaks(GOD_XOM, "Xom roars with laughter!");
            you.gift_timeout = 255;
        }
        else if (you.penance[GOD_XOM] > 0)
            god_speaks(GOD_XOM, "Xom laughs nastily.");
    }

    }
    if (you.religion == GOD_XOM && which_card == CARD_BLANK)
    {
        god_speaks(GOD_XOM, "\"How boring, lets spice things up a little.\"");
        xom_acts(abs(you.piety - 100));

    std::string wanted = buf;
    lowercase(wanted);

        if ( strstr(card_name(c), buf) != NULL )

        std::string card = card_name(c);
        lowercase(card);
        if ( card.find(wanted) != std::string::npos )

                       "Ctrl-A : generate new Abyss area\n"

                       "C      : (un)curse item\n"

                       "t      : tweak object properties\n"
                       "T      : make a trap\n",

                       "t      : tweak object properties\n",

                       "T      : make a trap\n"

    BFLAG_NO_MAGIC_MAP    = (1 << 2)  // Branch levels can't be magic mapped.

    BFLAG_NO_MAGIC_MAP    = (1 << 2), // Branch levels can't be magic mapped.
    BFLAG_HAS_ORB         = (1 << 3)  // Orb is on the floor in this branch

    { BRANCH_HALL_OF_ZOT, BRANCH_MAIN_DUNGEON, 5, 27, 0, 0,

    { BRANCH_HALL_OF_ZOT, BRANCH_MAIN_DUNGEON, 5, 27, BFLAG_HAS_ORB, 0,

    int         fr_hurt, foe_hurt;     // # of friends/foes actually hurt
    int         fr_helped, foe_helped; // # of friends/foes actually helped

bool nice_beam( struct monsters *mon, struct bolt &beam );

#include "xom.h"

    if (!pbolt.is_tracer && pbolt.beam_source != NON_MONSTER)
    {
        if (pbolt.foe_hurt == 0 && pbolt.fr_hurt > 0)
            xom_is_stimulated(128);
        else if (pbolt.foe_helped > 0 && pbolt.fr_helped == 0)
            xom_is_stimulated(128);
    }

        bool nasty = true, nice = false;

            // You *could* have gotten a free teleportation in the Abyss,
            // but no, you resisted.
            if (beam.flavour != BEAM_TELEPORT && you.level_type == LEVEL_ABYSS)
                xom_is_stimulated(255);

            nasty = false;
            nice  = true;

            nasty = false;
            nice  = true;

            nasty = false;
            nice  = true;

            // An enemy helping you escape while in the Abyss, or an
            // enemy stabalizing a teleport that was about to happen.
            if (beam.attitude == ATT_HOSTILE && you.level_type == LEVEL_ABYSS)
                xom_is_stimulated(255);

        if (nasty)
        {
            if (beam.attitude != ATT_HOSTILE)
            {
                beam.fr_hurt++;
                xom_is_stimulated(128);
            }
            else
                beam.foe_hurt++;
        }
        if (nice)
        {
            if (beam.attitude != ATT_HOSTILE)
                beam.fr_helped++;
            else
            {
                beam.foe_helped++;
                xom_is_stimulated(128);
            }
        }

    bool was_affected = false;
    int  old_hp       = you.hp;

        {

            was_affected = true;
        }

        {

            was_affected = true;
        }

            was_affected = true;

    {

        was_affected = true;
    }

            was_affected = true;

        {

            was_affected = true;
        }

    if (hurted > 0 || old_hp < you.hp || was_affected)
    {
        if (beam.attitude != ATT_HOSTILE)
        {
            beam.fr_hurt++;

            // Xom's ammusement at the player being damaged is handled
            // elsewhere.
            if (was_affected)
                xom_is_stimulated(128);
        }
        else
            beam.foe_hurt++;
    }

static void update_hurt_or_helped(bolt &beam, monsters *mon)
{
    if (beam.attitude != mons_attitude(mon))
    {
        if (nasty_beam(mon, beam))
            beam.foe_hurt++;
        else if (nice_beam(mon, beam))
            beam.foe_helped++;
    }
    else
    {
        if (nasty_beam(mon, beam))
            beam.fr_hurt++;
        else if (nice_beam(mon, beam))
            beam.fr_helped++;
    }
}

        update_hurt_or_helped(beam, mon);

                update_hurt_or_helped(beam, mon);

    update_hurt_or_helped(beam, mon);

}
bool nice_beam( struct monsters *mon, struct bolt &beam )
{
    // haste
    if (beam.flavour == BEAM_HASTE || beam.flavour == BEAM_HEALING
        || beam.flavour == BEAM_INVISIBILITY)
    {
        return (true);
    }
    return (false);

               fr_hurt(0), foe_hurt(0), fr_helped(0), foe_helped(0),

#include "xom.h"

    case 'C':
    {
        // this command isn't very exciting... feel free to replace
        i = prompt_invent_item( "(Un)curse which item?", MT_INVLIST, -1 );
        if (i == PROMPT_ABORT)
        {
            canned_msg( MSG_OK );
            break;
        }
        item_def& item(you.inv[i]);

        if (item_cursed(item))
            do_uncurse_item(item);
        else
            do_curse_item(item);
        break;
    }

            banished( DNGN_ENTER_ABYSS );

            banished( DNGN_ENTER_ABYSS, "wizard command" );

    case CONTROL('A'):
        if (you.level_type == LEVEL_ABYSS)
            abyss_teleport(true);
        else
            mpr("You can only abyss_teleport() inside the Abyss.");
        break;

#include "xom.h"

#if DEBUG_ABYSS
    mpr("generate_abyss().", MSGCH_DIAGNOSTICS);
#endif

#if DEBUG_ABYSS
    mpr("generate_area().", MSGCH_DIAGNOSTICS);
#endif

#if DEBUG_ABYSS
                        mpr("Placing an Abyssal rune.", MSGCH_DIAGNOSTICS);
#endif

    int exits_wanted  = 0;
    int altars_wanted = 0;

                exits_wanted++;
            // Don't place exit under items
            if (exits_wanted > 0 && igrd[i][j] == NON_ITEM)
            {

                exits_wanted--;
#if DEBUG_ABYSS
                mpr("Placing Abyss exit.", MSGCH_DIAGNOSTICS);
#endif
            }

                altars_wanted++;
            // Don't place altars under items.
            if (altars_wanted > 0 && igrd[i][j] == NON_ITEM)

                altars_wanted--;
#if DEBUG_ABYSS
                mpr("Placing altar.", MSGCH_DIAGNOSTICS);
#endif
            }
        }
    }
}
static int abyss_exit_nearness()
{
    int nearness = INFINITE_DISTANCE;
    for (int x = you.x_pos - LOS_RADIUS; x < you.x_pos + LOS_RADIUS; x++)
        for (int y = you.y_pos - LOS_RADIUS; y < you.y_pos + LOS_RADIUS; y++)
        {
            if (!in_bounds(x, y))
                continue;
            // HACK: Why doesn't is_terrain_known() work here?
            if (grd[x][y] == DNGN_EXIT_ABYSS
                && get_screen_glyph(x, y) != '\0')
            {
                nearness = MIN(nearness,
                               grid_distance(you.x_pos, you.y_pos,
                                             x, y));
            }
        }
    return (nearness);
}
static int abyss_rune_nearness()
{
    int nearness = INFINITE_DISTANCE;
    for (int x = you.x_pos - LOS_RADIUS; x < you.x_pos + LOS_RADIUS; x++)
        for (int y = you.y_pos - LOS_RADIUS; y < you.y_pos + LOS_RADIUS; y++)
        {
            if (!in_bounds(x, y))
                continue;
            // HACK: Why doesn't is_terrain_known() work here?
            if (get_screen_glyph(x, y) != '\0')
            {
                int i = igrd[x][y];
                while (i != NON_ITEM)
                {
                    item_def& item(mitm[i]);
                    if (is_rune(item) && item.plus == RUNE_ABYSSAL)
                        nearness = MIN(nearness,
                                       grid_distance(you.x_pos, you.y_pos,
                                                     x, y));
                    i = item.link;
                }

    return (nearness);
}
static int exit_was_near;
static int rune_was_near;
static void xom_check_nearness_setup()
{
    exit_was_near = abyss_exit_nearness();
    rune_was_near = abyss_rune_nearness();
}
// If the player was almost to the exit when it disppeared, Xom is
// exteremely amused.  He's also extremely amused if the player winds
// up right next to an exit when there wasn't one there before.  The
// same applies to Abyssal runes.
static void xom_check_nearness()
{
    // Update known terrain
    viewwindow(true, false);
    int exit_is_near = abyss_exit_nearness();
    if ((exit_was_near < INFINITE_DISTANCE &&
         exit_is_near == INFINITE_DISTANCE)
        || (exit_was_near == INFINITE_DISTANCE &&
            exit_is_near  <  INFINITE_DISTANCE))
    {
        xom_is_stimulated(255);
    }
    int rune_is_near = abyss_rune_nearness();
    if ((rune_was_near < INFINITE_DISTANCE &&
         rune_is_near == INFINITE_DISTANCE)
        || (rune_was_near == INFINITE_DISTANCE &&
            rune_is_near  <  INFINITE_DISTANCE))
    {
        xom_is_stimulated(255);

#if DEBUG_ABYSS
    mpr("area_shift().", MSGCH_DIAGNOSTICS);
#endif
    xom_check_nearness_setup();

    xom_check_nearness();

    xom_check_nearness_setup();

#if DEBUG_ABYSS
            mpr("Non-new area Abyss teleport.", MSGCH_DIAGNOSTICS);
#endif

            xom_check_nearness();

#if DEBUG_ABYSS
    mpr("New area Abyss teleport.", MSGCH_DIAGNOSTICS);
#endif

            xom_check_lost_item( mitm[k] );

    xom_check_nearness();

        banished(DNGN_ENTER_PANDEMONIUM);

        banished(DNGN_ENTER_PANDEMONIUM, "self");