#include "luadgn.h"

            // Don't clobber with BLACK, because the colour should be
            // already set.
            if (fdef.colour != BLACK)
                *colour = fdef.colour | colmask;

            if (object < NUM_REAL_FEATURES && env.grid_colours[x][y])
            {
                *colour = env.grid_colours[x][y] | colmask;
            }
            else
            {
                // Don't clobber with BLACK, because the colour should be
                // already set.
                if (fdef.colour != BLACK)
                    *colour = fdef.colour | colmask;

            if (fdef.em_colour != fdef.colour && fdef.em_colour)
                *colour =
                    view_emphasised_colour(
                        x, y, static_cast<dungeon_feature_type>(object),
                        *colour, fdef.em_colour | colmask);

                if (fdef.em_colour != fdef.colour && fdef.em_colour)
                    *colour =
                        view_emphasised_colour(
                            x, y, static_cast<dungeon_feature_type>(object),
                            *colour, fdef.em_colour | colmask);
            }

                        if ((grd(gc) == DNGN_ROCK_STAIRS_DOWN || grd(gc) == DNGN_ROCK_STAIRS_UP)
                            && see_grid( gc.x, gc.y ))
                        {
                            learned_something_new(TUT_SEEN_ESCAPE_HATCH, gc.x, gc.y);
                        }

                        if (grid_is_rock_stair(grd(gc)))
                            learned_something_new(
                                TUT_SEEN_ESCAPE_HATCH, gc.x, gc.y);

                                learned_something_new(TUT_SEEN_STAIRS, gc.x, gc.y);

                            learned_something_new(TUT_SEEN_STAIRS, gc.x, gc.y);

                        else if (grd(gc) == DNGN_CLOSED_DOOR
                                 && see_grid( gc.x, gc.y ))

                        else if (grd(gc) == DNGN_CLOSED_DOOR)

                        else if (grd(gc) == DNGN_ENTER_SHOP
                                 && see_grid( gc.x, gc.y ))

                        else if (grd(gc) == DNGN_ENTER_SHOP)

#define SAVE_MAJOR_VERSION 2

#define SAVE_MAJOR_VERSION 3

#include <memory>

    crawl_environment tmp = env;

    std::auto_ptr<crawl_environment> tmp(new crawl_environment(env));

        env = tmp;

        env = *tmp;

    env = tmp;

    env = *tmp;

template <typename marshall, typename grid>
void run_length_encode(tagHeader &th, marshall m, const grid &g,
                       int width, int height)
{
    int last = 0, nlast = 0;
    for (int y = 0; y < height; ++y)
    {
        for (int x = 0; x < width; ++x)
        {
            if (!nlast)
                last = g[x][y];
            if (last == g[x][y] && nlast < 255)
            {
                nlast++;
                continue;
            }
            marshallByte(th, nlast);
            m(th, last);
            last = g[x][y];
            nlast = 1;
        }
    }

    marshallByte(th, nlast);
    m(th, last);
}
template <typename unmarshall, typename grid>
void run_length_decode(tagHeader &th, unmarshall um, grid &g,
                       int width, int height)
{
    const int end = width * height;
    int offset = 0;
    while (offset < end)
    {
        const int run = (unsigned char) unmarshallByte(th);
        const int value = um(th);
        for (int i = 0; i < run; ++i)
        {
            const int y = offset / width;
            const int x = offset % width;
            g[x][y] = value;
            ++offset;
        }
    }
}

    run_length_encode(th, marshallByte, env.grid_colours, GXM, GYM);

    env.grid_colours.init(BLACK);
    run_length_decode(th, unmarshallByte, env.grid_colours, GXM, GYM);

void random_in_bounds( int &x_pos, int &y_pos, int terr, bool empty, bool excl )

void random_in_bounds( int &x_pos, int &y_pos, int terr,
                       bool empty, bool excl )

        else if (terr == DNGN_DEEP_WATER && grd[x_pos][y_pos] == DNGN_SHALLOW_WATER)

        else if (terr == DNGN_DEEP_WATER
                 && grd[x_pos][y_pos] == DNGN_SHALLOW_WATER)

static int apply_vehumet_wizardry_boost(spell_type spell, int chance)

static int apply_spellcasting_success_boosts(spell_type spell, int chance)

    // Draconians get a boost to dragon-form.
    if (spell == SPELL_DRAGON_FORM && player_genus(GENPC_DRACONIAN))
        fail_reduce = fail_reduce * 70 / 100;

    chance2 = apply_vehumet_wizardry_boost(spell, chance2);

    chance2 = apply_spellcasting_success_boosts(spell, chance2);

      "summon the demons of the Abyss to your aid",
      "",

      "banish your foes",
      "corrupt the fabric of space",

    " of Impeachment",

    //    take_note(Note(NOTE_HP_CHANGE, you.hp, you.hp_max));

      take_note(Note(NOTE_MAXHP_CHANGE, you.hp_max));

        take_note(Note(NOTE_MAXHP_CHANGE, you.hp_max));
    

#define SAME_ATTITUDE(x) (mons_friendly(x)?BEH_FRIENDLY:BEH_HOSTILE)

#define SAME_ATTITUDE(x) (mons_friendly(x)? BEH_FRIENDLY:    \
                          mons_neutral(x)?  BEH_NEUTRAL : BEH_HOSTILE)

    bool isNeutral = mons_neutral(mon);

    if (mon->attitude == ATT_NEUTRAL && mon->foe == MHITNOT)
        set_nearest_monster_foe(mon);

    // neutral monsters prefer not to attack players, or other neutrals.
    if (mon->foe != MHITNOT && isNeutral
        && (mon->foe == MHITYOU || mons_neutral(&menv[mon->foe])))
    {
        mon->foe = MHITNOT;
    }

    if (!isFriendly && mon->foe != MHITYOU && mon->foe != MHITNOT

    if (!isFriendly && !isNeutral
        && mon->foe != MHITYOU && mon->foe != MHITNOT

                if (!proxPlayer)

                if (!proxPlayer || isNeutral)

                if (isFriendly || proxPlayer)

                if ((isFriendly || proxPlayer) && !isNeutral)

                               bool friendly)

                               bool friendly, bool neutral)

    if (!friendly && x == you.x_pos && y == you.y_pos

    if (!friendly && !neutral && x == you.x_pos && y == you.y_pos

            && mons_friendly(foe) != friendly)

            && (mons_friendly(foe) != friendly
                || (neutral && !mons_neutral(foe))))

    const bool neutral  = mons_neutral(mon);

            if (mons_check_set_foe(mon, x, my - k, friendly)
                || mons_check_set_foe(mon, x, my + k, friendly))

            if (mons_check_set_foe(mon, x, my - k, friendly, neutral)
                || mons_check_set_foe(mon, x, my + k, friendly, neutral))

            if (mons_check_set_foe(mon, mx - k, y, friendly)
                || mons_check_set_foe(mon, mx + k, y, friendly))

            if (mons_check_set_foe(mon, mx - k, y, friendly, neutral)
                || mons_check_set_foe(mon, mx + k, y, friendly, neutral))

class level_id;
monster_type pick_random_monster(const level_id &place,
                                 int power,
                                 int &lev_mons);

}
monster_type pick_random_monster(const level_id &place,
                                 int power,
                                 int &lev_mons)
{
    monster_type mon_type = MONS_PROGRAM_BUG;
    
    lev_mons = power;
    if (place.branch == BRANCH_MAIN_DUNGEON
        && lev_mons != 51 && one_chance_in(4))
    {
        lev_mons = random2(power);
    }
    if (place.branch == BRANCH_MAIN_DUNGEON
        && lev_mons < 28)
    {
        lev_mons = fuzz_mons_level(lev_mons);
        // potentially nasty surprise, but very rare
        if (need_super_ood(lev_mons))
            lev_mons += random2(12);
        // slightly out of depth monsters are more common:
        // [ds] Replaced with a fuzz above for a more varied mix.
        //if (need_moderate_ood(lev_mons))
        //    lev_mons += random2(5);
        if (lev_mons > 27)
            lev_mons = 27;
    }
    /* Abyss or Pandemonium. Almost never called from Pan;
       probably only if a rand demon gets summon anything spell */
    if (lev_mons == 51
        || place.level_type == LEVEL_PANDEMONIUM
        || place.level_type == LEVEL_ABYSS)
    {
        do
        {
            int count = 0;
            do
            {
                // was: random2(400) {dlb}
                mon_type = static_cast<monster_type>( random2(NUM_MONSTERS) );
                count++;
            }
            while (mons_abyss(mon_type) == 0 && count < 2000);
            if (count == 2000)
                return (MONS_PROGRAM_BUG);
        }
        while (random2avg(100, 2) > mons_rare_abyss(mon_type)
               && !one_chance_in(100));
    }
    else
    {
        int level, diff, chance;
        if (lev_mons > 30)
            lev_mons = 30;
        int i;
        for (i = 0; i < 10000; i++)
        {
            int count = 0;
            do
            {
                mon_type = static_cast<monster_type>(random2(NUM_MONSTERS));
                count++;
            }
            while (mons_rarity(mon_type) == 0 && count < 2000);
            if (count == 2000)
                return (MONS_PROGRAM_BUG);
            level  = mons_level( mon_type, place );
            diff   = level - lev_mons;
            chance = mons_rarity( mon_type, place ) - (diff * diff);
            if ((lev_mons >= level - 5 && lev_mons <= level + 5)
                && random2avg(100, 2) <= chance)
            {
                break;
            }
        }
        if (i == 10000)
            return (MONS_PROGRAM_BUG);
    }
    return (mon_type);

    int count;

        if (player_in_branch( BRANCH_MAIN_DUNGEON )
            && lev_mons != 51 && one_chance_in(4))
        {
            lev_mons = random2(power);
        }
        if (player_in_branch( BRANCH_MAIN_DUNGEON )
            && lev_mons < 28)
        {
            lev_mons = fuzz_mons_level(lev_mons);
            // potentially nasty surprise, but very rare
            if (need_super_ood(lev_mons))
                lev_mons += random2(12);
            // slightly out of depth monsters are more common:
            // [ds] Replaced with a fuzz above for a more varied mix.
            //if (need_moderate_ood(lev_mons))
            //    lev_mons += random2(5);
            if (lev_mons > 27)
                lev_mons = 27;
        }
        /* Abyss or Pandemonium. Almost never called from Pan;
           probably only if a rand demon gets summon anything spell */
        if (lev_mons == 51
            || you.level_type == LEVEL_PANDEMONIUM
            || you.level_type == LEVEL_ABYSS)
        {
            do
            {
                count = 0;
                do
                {
                    // was: random2(400) {dlb}
                    mon_type = random2(NUM_MONSTERS);
                    count++;
                }
                while (mons_abyss(mon_type) == 0 && count < 2000);
                if (count == 2000)
                    return (false);
            }
            while (random2avg(100, 2) > mons_rare_abyss(mon_type)
                    && !one_chance_in(100));
        }
        else
        {
            int level, diff, chance;
            if (lev_mons > 30)
                lev_mons = 30;
            for (i = 0; i < 10000; i++)
            {
                count = 0;
                do
                {
                    mon_type = random2(NUM_MONSTERS);
                    count++;
                }
                while (mons_rarity(mon_type) == 0 && count < 2000);
                if (count == 2000)
                    return (false);
                level  = mons_level( mon_type );
                diff   = level - lev_mons;
                chance = mons_rarity( mon_type ) - (diff * diff);
                if ((lev_mons >= level - 5 && lev_mons <= level + 5)
                    && random2avg(100, 2) <= chance)
                {
                    break;
                }
            }
            if (i == 10000)
                return (false);
        }

        mon_type = pick_random_monster(level_id::current(), lev_mons,
                                       lev_mons);
        if (mon_type == MONS_PROGRAM_BUG)
            return (false);

        if (behaviour == BEH_NEUTRAL)
            menv[id].attitude = ATT_NEUTRAL;

bool mons_neutral(const monsters *m);
mon_attitude_type mons_attitude(const monsters *m);

    bool fr1, fr2;

    mon_attitude_type fr1, fr2;

        fr1 = true;

        fr1 = ATT_FRIENDLY;

        fr1 = (mon1->attitude == ATT_FRIENDLY) || mon1->has_ench(ENCH_CHARM);

        fr1 = mons_attitude(mon1);

        fr2 = true;

        fr2 = ATT_FRIENDLY;

        fr2 = (mon2->attitude == ATT_FRIENDLY) || mon2->has_ench(ENCH_CHARM);

        fr2 = mons_attitude(mon2);

}
bool mons_neutral(const monsters *m)
{
    return (m->attitude == ATT_NEUTRAL);

mon_attitude_type mons_attitude(const monsters *m)
{
    return (m->has_ench(ENCH_CHARM)? ATT_FRIENDLY : m->attitude);
}

    if (!force && behaviour != BEH_WANDER)

    if (!force && (behaviour != BEH_WANDER || attitude == ATT_NEUTRAL))

#include "travel.h"

int mons_rarity(int mcls);

int mons_rarity(int mcls, const level_id &place = level_id::current());

int mons_level(int mcls);

int mons_level(int mcls, const level_id &place = level_id::current());

int mons_level(int mcls)

int mons_level(int mcls, const level_id &place)

    if (you.level_type == LEVEL_ABYSS)

    if (place.level_type == LEVEL_ABYSS)

    else if (you.level_type == LEVEL_PANDEMONIUM)

    else if (place.level_type == LEVEL_PANDEMONIUM)

    else
        monster_level = your_branch().mons_level_function(mcls);

    else if (place.level_type == LEVEL_DUNGEON)
        monster_level = branches[place.branch].mons_level_function(mcls);

int mons_rarity(int mcls)

int mons_rarity(int mcls, const level_id &place)

    if (you.level_type == LEVEL_ABYSS)

    if (place.level_type == LEVEL_ABYSS)

        return your_branch().mons_rarity_function(mcls);

        return branches[place.branch].mons_rarity_function(mcls);

                             bool preserve_features = false);

                             bool preserve_features = false,
                             bool preserve_items = false);

// Set floor/wall colour based on the mons_alloc array. Used for
// Abyss and Pan.
void set_colours_from_monsters();

static void dgn_check_terrain_items(const coord_def &pos)

static void dgn_check_terrain_items(const coord_def &pos, bool preserve_items)

            if (item_is_critical(mitm[curr]))

            if (preserve_items || item_is_critical(mitm[curr]))

                             bool preserve_features)

                             bool preserve_features,
                             bool preserve_items)

        env.grid_colours(pos) = BLACK;

    dgn_check_terrain_items(pos);

    dgn_check_terrain_items(pos, preserve_items);

}
static char fix_black_colour(char incol)
{
    if ( incol == BLACK )
        return LIGHTGREY;
    else
        return incol;
}
void set_colours_from_monsters()
{
    env.floor_colour = fix_black_colour(mcolour[env.mons_alloc[9]]);
    env.rock_colour = fix_black_colour(mcolour[env.mons_alloc[8]]);

    if (you.level_type == LEVEL_PANDEMONIUM || you.level_type == LEVEL_ABYSS)
    {
        set_colours_from_monsters();
    }
    else if (you.level_type == LEVEL_LABYRINTH)
    {
        env.floor_colour = LIGHTGREY;
        env.rock_colour  = BROWN;
    }
    else
    {
        // level_type == LEVEL_DUNGEON
        const int youbranch = you.where_are_you;
        env.floor_colour = branches[youbranch].floor_colour;
        env.rock_colour = branches[youbranch].rock_colour;
        // Zot is multicoloured
        if ( you.where_are_you == BRANCH_HALL_OF_ZOT )
        {
            const char floorcolours_zot[] = { LIGHTGREY, LIGHTGREY, BLUE,
                                              LIGHTBLUE, MAGENTA };
            const char rockcolours_zot[] = { LIGHTGREY, BLUE, LIGHTBLUE,
                                             MAGENTA, LIGHTMAGENTA };
            const int curr_subdungeon_level = player_branch_depth();
            if ( curr_subdungeon_level > 5 || curr_subdungeon_level < 1 )
                mpr("Odd colouring!");
            else
            {
                env.floor_colour = floorcolours_zot[curr_subdungeon_level-1];
                env.rock_colour = rockcolours_zot[curr_subdungeon_level-1];
            }
        }
    }

    dgn_set_floor_colours();
    

    run_corruption_effects(you.time_taken);

    MAT_FEATURE_NAME,

    MAT_CORRUPTION_NEXUS,

};
class map_corruption_marker : public map_marker
{
public:
    map_corruption_marker(const coord_def &pos = coord_def(0, 0),
                          int dur = 0);
    void write(tagHeader &) const;
    void read(tagHeader &);
    std::string debug_describe() const;
    static map_marker *read(tagHeader &, map_marker_type);
public:
    int duration, radius;

std::vector<map_marker*> env_get_all_markers();

std::vector<map_marker*> env_get_all_markers(map_marker_type = MAT_ANY);

map_marker *env_find_marker(map_marker_type type);

    &map_corruption_marker::read,

    NULL,

// map_corruption_marker
map_corruption_marker::map_corruption_marker(const coord_def &p,
                                             int dur)
    : map_marker(MAT_CORRUPTION_NEXUS, p), duration(dur), radius(0)
{
}
void map_corruption_marker::write(tagHeader &out) const
{
    map_marker::write(out);
    marshallShort(out, duration);
    marshallShort(out, radius);
}
void map_corruption_marker::read(tagHeader &in)
{
    map_marker::read(in);
    duration = unmarshallShort(in);
    radius   = unmarshallShort(in);
}
map_marker *map_corruption_marker::read(tagHeader &th, map_marker_type)
{
    map_corruption_marker *mc = new map_corruption_marker();
    mc->read(th);
    return (mc);
}
std::string map_corruption_marker::debug_describe() const
{
    return make_stringf("Lugonu corrupt (%d)", duration);
}
//////////////////////////////////////////////////////////////////////////

        if (type == MAT_ANY || i->second->get_type() == type)
            return (i->second);
    return (NULL);
}
map_marker *env_find_marker(map_marker_type type)
{
    for (dgn_marker_map::const_iterator i = env.markers.begin();
         i != env.markers.end(); ++i)
    {

    }

std::vector<map_marker*> env_get_all_markers()

std::vector<map_marker*> env_get_all_markers(map_marker_type mat)

        rmarkers.push_back(i->second);

        if (mat == MAT_ANY || i->second->get_type() == mat)
            rmarkers.push_back(i->second);

        return (MAXIMUM(::abs(x), ::abs(y)));

        return (std::max(std::abs(x), std::abs(y)));

    FixedArray< unsigned short, GXM, GYM >   grid_colours; // colour overrides

    ABIL_LUGONU_SUMMON_DEMONS,

    ABIL_LUGONU_BANISH,
    ABIL_LUGONU_CORRUPT,

    BEH_NEUTRAL,                       //  creation only

// Set floor/wall colour based on the mons_alloc array. Used for
// Abyss and Pan.
void dgn_set_colours_from_monsters();
void dgn_set_floor_colours();

    make_box(0, 0, GXM - 1, GYM - 1, DNGN_ROCK_WALL, DNGN_ROCK_WALL);

    grd.init(DNGN_ROCK_WALL);
    env.grid_colours.init(BLACK);

    // unlink all monsters and items from the grid
    for(int x=0; x<GXM; x++)
    {
        for(int y=0; y<GYM; y++)
        {
            mgrd[x][y] = NON_MONSTER;
            igrd[x][y] = NON_ITEM;
        }
    }

    mgrd.init(NON_MONSTER);
    igrd.init(NON_ITEM);

    dgn_set_floor_colours();

static char fix_black_colour(char incol)
{
    if ( incol == BLACK )
        return LIGHTGREY;
    else
        return incol;
}
void dgn_set_colours_from_monsters()
{
    env.floor_colour = fix_black_colour(mcolour[env.mons_alloc[9]]);
    env.rock_colour = fix_black_colour(mcolour[env.mons_alloc[8]]);
}
void dgn_set_floor_colours()
{
    if (you.level_type == LEVEL_PANDEMONIUM || you.level_type == LEVEL_ABYSS)
    {
        dgn_set_colours_from_monsters();
    }
    else if (you.level_type == LEVEL_LABYRINTH)
    {
        env.floor_colour = LIGHTGREY;
        env.rock_colour  = BROWN;
    }
    else
    {
        // level_type == LEVEL_DUNGEON
        const int youbranch = you.where_are_you;
        env.floor_colour = branches[youbranch].floor_colour;
        env.rock_colour = branches[youbranch].rock_colour;
        // Zot is multicoloured
        if ( you.where_are_you == BRANCH_HALL_OF_ZOT )
        {
            const char floorcolours_zot[] = { LIGHTGREY, LIGHTGREY, BLUE,
                                              LIGHTBLUE, MAGENTA };
            const char rockcolours_zot[] = { LIGHTGREY, BLUE, LIGHTBLUE,
                                             MAGENTA, LIGHTMAGENTA };
            const int curr_subdungeon_level = player_branch_depth();
            if ( curr_subdungeon_level > 5 || curr_subdungeon_level < 1 )
                mpr("Odd colouring!");
            else
            {
                env.floor_colour = floorcolours_zot[curr_subdungeon_level-1];
                env.rock_colour = rockcolours_zot[curr_subdungeon_level-1];
            }
        }
    }    
}

                m.attitude = m.attitude == ATT_FRIENDLY?
                    ATT_HOSTILE : ATT_FRIENDLY;

                m.attitude = m.attitude == ATT_FRIENDLY? ATT_NEUTRAL :
                    m.attitude == ATT_HOSTILE? ATT_FRIENDLY :
                    ATT_HOSTILE;

        else if (menv[i].attitude == ATT_NEUTRAL)
            mprf("%s is indifferent to you.",
                 mons_pronoun(menv[i].type, PRONOUN_CAP));

bool lugonu_corrupt_level(int power);
void run_corruption_effects(int duration);

#include "mapmark.h"

#include "player.h"

#include "view.h"

    set_colours_from_monsters(); // and new colours

    dgn_set_colours_from_monsters(); // and new colours

}
//////////////////////////////////////////////////////////////////////////////
// Abyss effects in other levels, courtesy Lugonu.
static void place_corruption_seed(const coord_def &pos, int duration)
{
    env_add_marker(new map_corruption_marker(pos, duration));
}
static void initialise_level_corrupt_seeds(int power)
{
    const int low = power / 2, high = power * 3 / 2;
    int nseeds = random_range(1, std::min(2 + power / 110, 4));
#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS, "Placing %d corruption seeds", nseeds);
#endif
    // The corruption centered on the player is free.
    place_corruption_seed(you.pos(), high + 100);
    for (int i = 0; i < nseeds; ++i)
    {
        coord_def where;
        do
            where = coord_def(random2(GXM), random2(GYM));
        while (!in_bounds(where) || grd(where) != DNGN_FLOOR
               || env_find_marker(where, MAT_ANY));
        place_corruption_seed(where, random_range(low, high, 2));
    }

static bool spawn_corrupted_servant_near(const coord_def &pos)
{
    // Thirty tries for a place
    for (int i = 0; i < 30; ++i)
    {
        const coord_def p( pos.x + random2avg(4, 3) + random2(3),
                           pos.y + random2avg(4, 3) + random2(3) );
        if (!in_bounds(p) || p == you.pos() || mgrd(p) != NON_MONSTER
            || !grid_compatible(DNGN_FLOOR, grd(p), true))
            continue;
        // Got a place, summon the beast.
        int level = 51;
        monster_type mons =
            pick_random_monster(level_id(LEVEL_ABYSS), level, level);
        if (mons == MONS_PROGRAM_BUG)
            return (false);
        const beh_type beh =
            one_chance_in(5 + you.skills[SK_INVOCATIONS] / 4)?
            BEH_HOSTILE : BEH_NEUTRAL;
        const int mid =
            create_monster( mons, 3, beh, p.x, p.y, MHITNOT, 250 );
        return (mid != -1);
    }
    return (false);
}
                                        
static void apply_corruption_effect(
    map_marker *marker, int duration)
{
    if (!duration)
        return;
    map_corruption_marker *cmark = dynamic_cast<map_corruption_marker*>(marker);
    const coord_def center = cmark->pos;
    const int neffects = std::max(div_rand_round(duration, 5), 1);
    for (int i = 0; i < neffects; ++i)
    {
        if (random2(7000) < cmark->duration)
        {
            if (!spawn_corrupted_servant_near(cmark->pos))
                break;
        }
    }
    cmark->duration -= duration;
    if (cmark->duration < 1)
        env_remove_marker(cmark);
}
void run_corruption_effects(int duration)
{
    std::vector<map_marker*> markers =
        env_get_all_markers(MAT_CORRUPTION_NEXUS);
    for (int i = 0, size = markers.size(); i < size; ++i)
    {
        map_marker *mark = markers[i];
        if (mark->get_type() != MAT_CORRUPTION_NEXUS)
            continue;
        apply_corruption_effect(mark, duration);
    }
}
static bool is_grid_corruptible(const coord_def &c)
{
    if (c == you.pos())
        return (false);
    
    const dungeon_feature_type feat = grd(c);
    
    // Stairs and portals cannot be corrupted.
    if (grid_stair_direction(feat) != CMD_NO_CMD)
        return (false);
    switch (feat)
    {
    case DNGN_PERMAROCK_WALL:
    case DNGN_GREEN_CRYSTAL_WALL:
        return (false);
    case DNGN_METAL_WALL:
        return (one_chance_in(5));
        
    case DNGN_STONE_WALL:
        return (one_chance_in(3));
    case DNGN_ROCK_WALL:
        return (!one_chance_in(3));
        
    default:
        return (true);
    }
}
// Returns true if the square has <= 4 traversable neighbours. 
static bool is_crowded_square(const coord_def &c)
{
    int neighbours = 0;
    for (int xi = -1; xi <= 1; ++xi)
    {
        for (int yi = -1; yi <= 1; ++yi)
        {
            if (!xi && !yi)
                continue;
            const coord_def n(c.x + xi, c.y + yi);
            if (!in_bounds(n) || !is_traversable(grd(n)))
                continue;
            if (++neighbours > 4)
                return (false);
        }
    }
    return (true);
}
// Returns true if the square has all opaque neighbours.
static bool is_sealed_square(const coord_def &c)
{
    for (int xi = -1; xi <= 1; ++xi)
    {
        for (int yi = -1; yi <= 1; ++yi)
        {
            if (!xi && !yi)
                continue;
            const coord_def n(c.x + xi, c.y + yi);
            if (!in_bounds(n))
                continue;
            if (!grid_is_opaque(grd(n)))
                return (false);
        }
    }
    return (true);
}
static void corrupt_square(const crawl_environment &oenv, const coord_def &c)
{
    dungeon_feature_type feat = DNGN_UNSEEN;
    if (grid_altar_god(grd(c)) != GOD_NO_GOD)
    {
        if (!one_chance_in(3))
            feat = DNGN_ALTAR_LUGONU;
    }
    else
        feat = oenv.grid(c);
    if (grid_is_trap(feat) || feat == DNGN_UNDISCOVERED_TRAP
        || feat == DNGN_SECRET_DOOR || feat == DNGN_UNSEEN)
        return;
    if (is_traversable(grd(c)) && !is_traversable(feat)
        && is_crowded_square(c))
        return;
    if (!is_traversable(grd(c)) && is_traversable(feat) && is_sealed_square(c))
        return;
    if (feat == DNGN_EXIT_ABYSS)
        feat = DNGN_ENTER_ABYSS;
    dungeon_terrain_changed(c, feat, true, true, true);
    if (feat == DNGN_ROCK_WALL)
        env.grid_colours(c) = oenv.rock_colour;
    else if (feat == DNGN_FLOOR)
        env.grid_colours(c) = oenv.floor_colour;
}
static void corrupt_level_features(const crawl_environment &oenv)
{
    std::vector<coord_def> corrupt_seeds;
    std::vector<map_marker*> corrupt_markers =
        env_get_all_markers(MAT_CORRUPTION_NEXUS);
    for (int i = 0, size = corrupt_markers.size(); i < size; ++i)
        corrupt_seeds.push_back(corrupt_markers[i]->pos);
    
    for (int y = MAPGEN_BORDER; y < GYM - MAPGEN_BORDER; ++y)
    {
        for (int x = MAPGEN_BORDER; x < GXM - MAPGEN_BORDER; ++x)
        {
            const coord_def c(x, y);
            int distance = GXM * GXM + GYM * GYM;
            for (int i = 0, size = corrupt_seeds.size(); i < size; ++i)
            {
                const int dist = (c - corrupt_seeds[i]).rdist();
                if (dist < distance)
                    distance = dist;
            }
            if ((distance < 6 || one_chance_in(1 + distance - 6))
                && is_grid_corruptible(c))
            {
                corrupt_square(oenv, c);
            }
        }
    }
}
static bool is_level_corrupted()
{
    if (you.level_type == LEVEL_ABYSS
        || you.level_type == LEVEL_PANDEMONIUM
        || player_in_hell()
        || player_in_branch(BRANCH_VESTIBULE_OF_HELL))
        return (true);
    return (!!env_find_marker(MAT_CORRUPTION_NEXUS));
}
static bool is_level_incorruptible()
{
    if (is_level_corrupted())
    {
        mpr("This place is already infused with evil and corruption.");
        return (true);
    }
    return (false);
}
bool lugonu_corrupt_level(int power)
{
    if (is_level_incorruptible())
        return (false);
    mprf(MSGCH_GOD, "Lugonu's Hand of Corruption reaches out!");
    you.flash_colour = EC_MUTAGENIC;
    viewwindow(true, false);
    
    initialise_level_corrupt_seeds(power);
    std::auto_ptr<crawl_environment> backup(new crawl_environment(env));
    generate_abyss();
    generate_area(MAPGEN_BORDER, MAPGEN_BORDER,
                  GXM - MAPGEN_BORDER, GYM - MAPGEN_BORDER);
    dgn_set_colours_from_monsters();
    std::auto_ptr<crawl_environment> abyssal(new crawl_environment(env));
    env = *backup;
    backup.reset(NULL);
    
    corrupt_level_features(*abyssal);
    run_corruption_effects(100);
    you.flash_colour = EC_MUTAGENIC;
    viewwindow(true, false);
    // Allow extra time for the flash to linger.
    delay(1000);
    viewwindow(true, false);
    return (true);
}

#include "abyss.h"

static void lugonu_bends_space();
static int find_ability_slot( ability_type which_ability );
static bool activate_talent(const talent& tal);
static bool do_ability(const ability_def& abil);
static void pay_ability_costs(const ability_def& abil);
static std::string describe_talent(const talent& tal);

static void lugonu_bends_space();
static int find_ability_slot( ability_type which_ability );
static bool activate_talent(const talent& tal);
static bool do_ability(const ability_def& abil);
static void pay_ability_costs(const ability_def& abil);
static std::string describe_talent(const talent& tal);

      ABIL_LUGONU_SUMMON_DEMONS, ABIL_NON_ABILITY,

      ABIL_LUGONU_BANISH, ABIL_LUGONU_CORRUPT,

    { ABIL_LUGONU_ABYSS_EXIT, "Depart the Abyss", 0, 0, 100, 10, ABFLAG_PAIN },
    { ABIL_LUGONU_BEND_SPACE, "Bend Space", 1, 0, 50, 0, ABFLAG_PAIN },
    { ABIL_LUGONU_SUMMON_DEMONS, "Summon Abyssal Servants", 7, 0, 100, 5, ABFLAG_NONE },
    { ABIL_LUGONU_ABYSS_ENTER, "Enter the Abyss", 9, 0, 200, 40, ABFLAG_NONE },

    { ABIL_LUGONU_ABYSS_EXIT,  "Depart the Abyss", 0, 0, 100, 10, ABFLAG_PAIN },
    { ABIL_LUGONU_BEND_SPACE,  "Bend Space", 1, 0, 50, 0, ABFLAG_PAIN },
    { ABIL_LUGONU_BANISH,      "Banish", 4, 0, 200, 5, ABFLAG_NONE },
    { ABIL_LUGONU_CORRUPT,     "Corrupt", 7, 5, 500, 20, ABFLAG_NONE },
    { ABIL_LUGONU_ABYSS_ENTER, "Enter the Abyss", 9, 0, 500, 40, ABFLAG_NONE },

    {

        // Lose 1d2 permanent HP
        you.hp_max -= (coinflip() ? 2 : 1);

        const int maxloss = std::max(2, div_rand_round(you.hp_max, 30));
        // Lose permanent HP
        you.hp_max -= random_range(1, maxloss);
        // Paranoia.
        if (you.hp_max < 1)
            you.hp_max = 1;
        

    }

    case ABIL_LUGONU_SUMMON_DEMONS:
    {
        int ndemons = 1 + you.skills[SK_INVOCATIONS] / 4;
        if (ndemons > 5)
            ndemons = 5;
        
        for ( int i = 0; i < ndemons; ++i )
            summon_ice_beast_etc( 20 + you.skills[SK_INVOCATIONS] * 3,
                                  summon_any_demon(DEMON_COMMON), true);
        
        exercise(SK_INVOCATIONS, 6 + random2(6));

    case ABIL_LUGONU_BANISH:
        if ( !spell_direction(spd, beam, DIR_NONE, TARG_ENEMY) )
            return (false);
        zapping( ZAP_BANISHMENT, 16 + you.skills[SK_INVOCATIONS] * 8, beam );
        exercise(SK_INVOCATIONS, 3 + random2(5));        
        break;
    case ABIL_LUGONU_CORRUPT:
        if (!lugonu_corrupt_level(300 + you.skills[SK_INVOCATIONS] * 15))
            return (false);
        exercise(SK_INVOCATIONS, 5 + random2(5));

    }