const unsigned int idx = MIN( (unsigned int) door_size*2,
                                  ARRAYSZ(descriptions) - 2 );

    const unsigned int idx = std::min(static_cast<unsigned int>(door_size*2),
                                      ARRAYSZ(descriptions) - 2);

    const int  monster = mgrd(where);

    monsters *monster = monster_at(where);

    if (monster == NON_MONSTER)

    if (monster == NULL)

    switch (menv[monster].type)

    switch (monster->type)

        if (mons_flies( &menv[monster] ))

        if (mons_flies(monster))

    int damage = dam_dice.roll() - random2( menv[monster].ac );

    int damage = dam_dice.roll() - random2(monster->ac);

        _player_hurt_monster( monster, damage );

        _player_hurt_monster(*monster, damage);

        if (!_player_hurt_monster(mon->mindex(), damage))

        if (!_player_hurt_monster(*mon, damage))

    const int midx = mgrd(spd.target);

    if (midx != NON_MONSTER)

    if (monsters *mon = monster_at(spd.target))

        monsters *mon = &menv[midx];

        std::string name_cap_the = mon->name(DESC_CAP_THE);

        const std::string name_cap_the = mon->name(DESC_CAP_THE);

            _player_hurt_monster(midx, beam.damage.roll());

            _player_hurt_monster(*mon, beam.damage.roll());

            if (_player_hurt_monster(midx, beam.damage.roll()))

            if (_player_hurt_monster(*mon, beam.damage.roll()))

            if (_player_hurt_monster(midx, beam.damage.roll()))

            if (_player_hurt_monster(*mon, beam.damage.roll()))

                if (_player_hurt_monster(midx, statue_damage))

                if (_player_hurt_monster(*mon, statue_damage))

            if (_player_hurt_monster(midx, beam.damage.roll()))

            if (_player_hurt_monster(*mon, beam.damage.roll()))

                if (_player_hurt_monster(midx, beam.damage.roll()))

                if (_player_hurt_monster(*mon, beam.damage.roll()))

                      if (_player_hurt_monster(midx, beam.damage.roll()))

                      if (_player_hurt_monster(*mon, beam.damage.roll()))

                    if (_player_hurt_monster(midx, beam.damage.roll()))

                    if (_player_hurt_monster(*mon, beam.damage.roll()))

            _player_hurt_monster(midx, roll_dice(1, 5 + pow / 25));

            _player_hurt_monster(*mon, roll_dice(1, 5 + pow / 25));

        menv[monster].hit_dice = MIN(30, menv[monster].hit_dice);

        menv[monster].hit_dice = std::min(30, menv[monster].hit_dice);

#include <algorithm>

    int spending_limit = MIN(MAX_SPENDING_LIMIT, you.exp_available);

    int spending_limit = std::min(MAX_SPENDING_LIMIT, you.exp_available);

            skill_inc *= MAX(5, you.strength);

            skill_inc *= std::max<int>(5, you.strength);

            skill_inc *= MAX(5, you.dex);

            skill_inc *= std::max<int>(5, you.dex);

            skill_inc *= MAX(5, you.intel);

            skill_inc *= std::max<int>(5, you.intel);

#include <algorithm>

    you.penance[god] = MIN(MAX_PENANCE, you.penance[god]);

    you.penance[god] = std::min<unsigned char>(MAX_PENANCE, you.penance[god]);

    you.piety = MIN(MAX_PIETY, you.piety);

    you.piety = std::min<int>(MAX_PIETY, you.piety);

                    noisy(SL_SPLASH, you.pos(), "Splash!");

                    noisy(8, you.pos(), "Splash!");

        int midx = mgrd(pbolt.target);
        if (midx != NON_MONSTER)
        {
            monsters* mtarg = &menv[midx];

        if (monsters* mtarg = monster_at(pbolt.target))

        }

                const int midx = mgrd(*ai);
                if (midx != NON_MONSTER && you.can_see(&menv[midx]))

                const monsters *m = monster_at(*ai);
                if (m && you.can_see(m))

                        target = menv[midx].name(DESC_NOCAP_THE);

                        target = m->name(DESC_NOCAP_THE);

            const int midx = mgrd(pos);

            const monsters *m = monster_at(pos);

            else if (visible_path && midx != NON_MONSTER
                     && you.can_see(&menv[midx]))

            else if (visible_path && m && you.can_see(m))

                bool        is_aligned = mons_aligned(midx, monster->mindex());
                std::string name       = menv[midx].name(DESC_NOCAP_THE);

                bool is_aligned  = mons_aligned(m->mindex(), monster->mindex());
                std::string name = m->name(DESC_NOCAP_THE);

                    const int midx2 = mgrd(*ai);
                    if (midx2 != NON_MONSTER && you.can_see(&menv[midx2]))

                    const monsters *m2 = monster_at(*ai);
                    if (m2 && you.can_see(m2))

                            target = menv[midx2].name(DESC_NOCAP_THE);

                            target = m2->name(DESC_NOCAP_THE);

        if (mgrd(target) != NON_MONSTER || target == you.pos())

        if (actor_at(target))

    const int mindex = mgrd(pos);
    if (mindex == NON_MONSTER)

    monsters *target = monster_at(pos);
    if (target == NULL)

    monsters *target = &menv[mindex];

            if (in_bounds(p) && p != you.pos() && mgrd(p) == NON_MONSTER

            if (in_bounds(p)
                && !actor_at(p)

            if (in_bounds(p) && p != you.pos() && mgrd(p) == NON_MONSTER

            if (in_bounds(p)
                && !actor_at(p)

    ASSERT(mgrd(pos) == NON_MONSTER && you.pos() != pos);

    ASSERT( !actor_at(pos) );

    {
        if (mgrd(*ai) == NON_MONSTER
            && parent->can_pass_through(*ai)
            && (*ai != you.pos()))
        {

        if (actor_at(*ai) == NULL && parent->can_pass_through(*ai))

        }
    }

            || mgrd(target) != NON_MONSTER
            || target == you.pos()

            || actor_at(target)

        if (mgrd(*ri) != NON_MONSTER)

        if (monster_at(*ri))

            continue;
        if (mgrd(*ri) == NON_MONSTER)

        monsters* const m = &menv[mgrd(*ri)];

        monsters* const m = monster_at(*ri);
        if (m == NULL)
            continue;

    if (mgrd(p) != NON_MONSTER)

    if (monsters *foe = monster_at(p))

        monsters *foe = &menv[mgrd(p)];

            mon->foe = mgrd(p);

            mon->foe = foe->mindex();

        if (mgrd(*ri) != NON_MONSTER)

        if (monsters *mon = monster_at(*ri))

            monsters *mon = &menv[mgrd(*ri)];

        if (mgrd(pos[i]) == NON_MONSTER)

        const monsters *ally = monster_at(pos[i]);
        if (ally == NULL)

        if (mons_is_stationary(&menv[mgrd(pos[i])]))

        if (mons_is_stationary(ally))

            && mons_genus(mon->type) != mons_genus((&menv[mgrd(pos[i])])->type))

            && mons_genus(mon->type) != mons_genus(ally->type))

        if (mons_aligned(monster_index(mon), mgrd(pos[i])))

        if (mons_aligned(mon->mindex(), ally->mindex()))

        if (mgrd(pos) == NON_MONSTER)

        const monsters* ally = monster_at(pos);
        if (ally == NULL)

        if (mons_aligned(monster_index(mon), mgrd(pos)))

        if (mons_aligned(mon->mindex(), ally->mindex()))

                && mons_genus(mon->type) != mons_genus((&menv[mgrd(pos)])->type))

                && mons_genus(mon->type) != mons_genus(ally->type))

            monsters *m = &menv[mgrd(pos)];
            if (mons_has_ranged_attack(m) || mons_has_ranged_spell(m, true))

            if (mons_has_ranged_attack(ally)
                || mons_has_ranged_spell(ally, true))
            {

            }

            monsters *mon = NULL;
            if (mgrd(newpos) != NON_MONSTER)

            monsters *mon = monster_at(newpos);
            if (mon)

                mon = &menv[mgrd(newpos)];

    const actor *act = actor_at(beem.target);

        && ( beem.target == you.pos() && you.caught()
             || mgrd(beem.target) != NON_MONSTER
             && mons_is_caught(&menv[mgrd(beem.target)])))

        && act && act->caught())

    if (is_sanctuary(monster->pos())
        && (targ == you.pos() || mgrd(targ) != NON_MONSTER))
    {

    if (is_sanctuary(monster->pos()) && actor_at(targ))

    }

    if (mgrd(targ) != NON_MONSTER)

    if (monsters *targmonster = monster_at(targ))

        const int thismonster = monster->mindex(),
                  targmonster = mgrd(targ);

        if (!invalid_monster_index(targmonster)
            && mons_aligned(thismonster, targmonster)
            && !_mons_can_displace(monster, &menv[targmonster]))

        if (mons_aligned(monster->mindex(), targmonster->mindex())
            && !_mons_can_displace(monster, targmonster))

        if (mgrd(*ai) != NON_MONSTER)

        if (actor_at(*ai))

        if (*ai == you.pos())
            continue;

                if (mgrd(pos) != NON_MONSTER || pos == you.pos())

                if (actor_at(pos))

    if (mgrd(mg_pos) != NON_MONSTER || mg_pos == you.pos())

    if (actor_at(mg_pos))

    if (mg.use_position() && mgrd(mg.pos) != NON_MONSTER)

    if (mg.use_position() && monster_at(mg.pos))

                    {
                        proxOK = false;
                        break;
                    }
                    // You can't be shoved if you're caught in a net.
                    if (you.caught())

        && mgrd(mg.pos) == NON_MONSTER && mg.pos != you.pos()

        && actor_at(mg.pos) == NULL

        if (mgrd(dc) == NON_MONSTER && dc != you.pos()
            && one_chance_in(++nfound))

        if (actor_at(dc) == NULL && one_chance_in(++nfound))

        || mgrd(mg.pos) != NON_MONSTER
        || mg.pos == you.pos()

        || actor_at(mg.pos)

        if ( *ri == you.pos() )
            continue;

        if (mgrd(*ri) != NON_MONSTER)

        if (actor_at(*ri))

        mgrd(pos()) = monster_index(this);

        mgrd(pos()) = mindex();

            unit_mass = MAXIMUM( unit_mass, 5 );

            unit_mass = std::max(unit_mass, 5);

    item_def& item = you.inv[item_slot];

        // "Putting on" an equipped item means taking it off.

    if (you.inv[item_slot].base_type != OBJ_JEWELLERY)

    if (item.base_type != OBJ_JEWELLERY)

    const bool is_amulet = jewellery_is_amulet( you.inv[item_slot] );

    const bool lring = (you.slot_item(EQ_LEFT_RING)  != NULL);
    const bool rring = (you.slot_item(EQ_RIGHT_RING) != NULL);
    const bool is_amulet = jewellery_is_amulet(item);

    if (!is_amulet)     // ie it's a ring

    if (!is_amulet)     // i.e. it's a ring

        if (you.equip[EQ_GLOVES] != -1
            && item_cursed( you.inv[you.equip[EQ_GLOVES]] ))

        const item_def* gloves = you.slot_item(EQ_GLOVES);
        if (gloves && item_cursed(*gloves))

        if (you.equip[EQ_LEFT_RING] != -1
            && you.equip[EQ_RIGHT_RING] != -1)
        {

        if (lring && rring)

        }

    else if (you.equip[EQ_AMULET] != -1)

    else if (item_def* amulet = you.slot_item(EQ_AMULET))

        if (!check_warning_inscriptions(you.inv[you.equip[EQ_AMULET]],
                                        OPER_REMOVE)
            || !remove_ring( you.equip[EQ_AMULET], true ))

        // Remove the previous one.
        if (!check_warning_inscriptions(*amulet, OPER_REMOVE)
            || !remove_ring(you.equip[EQ_AMULET], true))

        // Put on the new amulet.
        if (!safe_to_remove_or_wear(you.inv[item_slot], false))

        // Check that the new amulet won't kill us.
        if (!safe_to_remove_or_wear(item, false))

        // Put on the new amulet.

    // Put on the amulet.
    if (!safe_to_remove_or_wear(you.inv[item_slot], false))

    // Check that it won't kill us.
    if (!safe_to_remove_or_wear(item, false))

    // First ring goes on left hand if we're choosing automatically.
    int hand_used = 0;
    if (you.equip[EQ_LEFT_RING] != -1)
        hand_used = 1;
    if (you.equip[EQ_RIGHT_RING] != -1)
        hand_used = 0;

    equipment_type hand_used;

        hand_used = 2;
    else if (prompt_finger
                && you.equip[EQ_LEFT_RING] == -1
                && you.equip[EQ_RIGHT_RING] == -1)

        mpr("Put on which hand (l or r)?", MSGCH_PROMPT);
        int keyin = get_ch();

        hand_used = EQ_AMULET;
    }
    else
    {
        // First ring goes on left hand if we're choosing automatically.
        hand_used = EQ_LEFT_RING;

        if (keyin == 'l')
            hand_used = 0;
        else if (keyin == 'r')
            hand_used = 1;
        else if (keyin == ESCAPE)
            return (false);
        else

        if (lring && !rring)
            hand_used = EQ_RIGHT_RING;
        else if (rring && !lring)
            hand_used = EQ_LEFT_RING;
        else if (prompt_finger) // both free; both busy has been handled

            mpr("You don't have such a hand!");
            return (false);

            mpr("Put on which hand (l or r)?", MSGCH_PROMPT);
            int keyin = get_ch();
            switch (keyin)
            {
            case 'l': hand_used = EQ_LEFT_RING;  break;
            case 'r': hand_used = EQ_RIGHT_RING; break;
            case ESCAPE: return (false);
            default:
                mpr("You don't have such a hand!");
                return (false);
            }

    you.equip[ EQ_LEFT_RING + hand_used ] = item_slot;

    // Actually equip the item.
    you.equip[hand_used] = item_slot;

    jewellery_wear_effects( you.inv[item_slot] );

    // And calculate the effects.
    jewellery_wear_effects(item);

        if (grd(you.pos()) >= DNGN_FOUNTAIN_BLUE
            && grd(you.pos()) <= DNGN_FOUNTAIN_BLOOD)
        {

        const dungeon_feature_type feat = grd(you.pos());
        if (feat >= DNGN_FOUNTAIN_BLUE && feat <= DNGN_FOUNTAIN_BLOOD)

        }

        const potion_type effects[] =
            { POT_WATER, POT_DECAY,
              POT_MUTATION, POT_HEALING, POT_HEAL_WOUNDS, POT_SPEED, POT_MIGHT,
              POT_DEGENERATION,
              POT_LEVITATION, POT_POISON, POT_SLOWING,
              POT_PARALYSIS, POT_CONFUSION, POT_INVISIBILITY,
              POT_MAGIC, POT_RESTORE_ABILITIES, POT_RESISTANCE,
              POT_STRONG_POISON, POT_BERSERK_RAGE,
              POT_GAIN_STRENGTH, POT_GAIN_INTELLIGENCE, POT_GAIN_DEXTERITY };
        const int weights[] = { 467, 48,
                                40, 40, 40, 40, 40,
                                32,
                                27, 27, 27,
                                27, 27, 27,
                                20, 20, 20,
                                20, 20,
                                4, 4, 4 };
        COMPILE_CHECK(ARRAYSZ(weights) == ARRAYSZ(effects), c1);
        fountain_effect =
            effects[choose_random_weighted(weights,
                                           weights + ARRAYSZ(weights))];

        fountain_effect = static_cast<potion_type>(
            random_choose_weighted(467, POT_WATER,
                                   48,  POT_DECAY,
                                   40,  POT_MUTATION,
                                   40,  POT_HEALING,
                                   40,  POT_HEAL_WOUNDS,
                                   40,  POT_SPEED,
                                   40,  POT_MIGHT,
                                   32,  POT_DEGENERATION,
                                   27,  POT_LEVITATION,
                                   27,  POT_POISON,
                                   27,  POT_SLOWING,
                                   27,  POT_PARALYSIS,
                                   27,  POT_CONFUSION,
                                   27,  POT_INVISIBILITY,
                                   20,  POT_MAGIC,
                                   20,  POT_RESTORE_ABILITIES,
                                   20,  POT_RESISTANCE,
                                   20,  POT_STRONG_POISON,
                                   20,  POT_BERSERK_RAGE,
                                   4,   POT_GAIN_STRENGTH,
                                   4,   POT_GAIN_INTELLIGENCE,
                                   4,   POT_GAIN_DEXTERITY,
                                   0));

        const int x_middle = MAX(beam.target.x, you.pos().x) - (x_distance / 2);
        const int y_middle = MAX(beam.target.y, you.pos().y) - (y_distance / 2);

        const int x_middle = std::max(beam.target.x, you.pos().x)
            - (x_distance / 2);
        const int y_middle = std::max(beam.target.y, you.pos().y)
            - (y_distance / 2);
        const coord_def middle(x_middle, y_middle);

            && mgrd[x_middle][y_middle] != NON_MONSTER)

            && monster_at(middle))

#define STR_REQ_THRESHOLD       10

const int STR_REQ_THRESHOLD = 10;

#define MAX_GHOSTS   10

const int MAX_GHOSTS = 10;

#define INFINITE_DISTANCE       30000

const int INFINITE_DISTANCE = 30000;

#define VIEW_BASE_WIDTH 33

#define VIEW_BASE_WIDTH 33      // FIXME: never used

#define ANON_FRIENDLY_MONSTER   -1999

const int ANON_FRIENDLY_MONSTER = -1999;

#define DEBUG_COOKIE            32767

const int DEBUG_COOKIE = 32767;

#define MAX_SKILL_LEVEL 27

const int MAX_SKILL_LEVEL = 27;

#define MIN_HIT_MISS_PERCENTAGE  5

const int MIN_HIT_MISS_PERCENTAGE = 5;

#define MONSTER_LOS_RANGE       8

const int MONSTER_LOS_RANGE = 8;

#define MAX_ROD_CHARGE                  17
#define ROD_CHARGE_MULT                 100

const int MAX_ROD_CHARGE  = 17;
const int ROD_CHARGE_MULT = 100;

// Should never exceed 255 - durations are saved as single bytes.
#define GOURMAND_MAX                    200
#define GOURMAND_NUTRITION_BASE         10

const int GOURMAND_MAX            = 200;
const int GOURMAND_NUTRITION_BASE = 10;

#define CHUNK_BASE_NUTRITION            1000

const int CHUNK_BASE_NUTRITION    = 1000;

#define MAG_IMMUNE                      5000

const int MAG_IMMUNE = 5000;

#define INSTANT_DEATH                   -9999
// grids that monsters can see
#define MONSTER_LOS_RANGE               8

const int INSTANT_DEATH = -9999;

// most items allowed in a shop
#define MAX_SHOP_ITEMS                  16
// sound level standards
// mininum is the base, we add mult * radius to it:
#define SL_EXPLODE_MIN                  10
#define SL_EXPLODE_MULT                 10
// #define SL_BOW                          3
#define SL_TRAP_CLICK                   3
#define SL_HISS                         6
#define SL_BUZZ                         6
#define SL_GROWL                        8
#define SL_MOAN                         8
#define SL_SPLASH                       8
#define SL_CREAK                        8
#define SL_CROAK                        8
#define SL_BARK                         10
#define SL_YELL                         10
#define SL_TRAP_JAM                     12
#define SL_SHRIEK                       12
#define SL_ROAR                         15
#define SL_DIG                          15
#define SL_NOISY_WEAPON                 20
#define SL_HORN                         25
#define SL_NOISE_SCROLL                 30
#define SL_THUNDER                      30
#define SL_PROJECTED_NOISE              30
#define SL_EARTHQUAKE                   30
#define SL_TRAP_ZOT                     30

#define MAX_WPN_ENCHANT                 9

const int MAX_WPN_ENCHANT = 9;

#define MAX_ARM_ENCHANT                 8
#define MAX_SEC_ENCHANT                 2

const int MAX_ARM_ENCHANT = 8;
const int MAX_SEC_ENCHANT = 2;

#define MINIMUM( xxx, yyy )     (((xxx) < (yyy)) ? (xxx) : (yyy))
#define MAXIMUM( xxx, yyy )     (((xxx) > (yyy)) ? (xxx) : (yyy))

#define MIN(x, y) MINIMUM(x, y)
#define MAX(x,y) (((x) > (y)) ? (x) : (y))

    g = (float) MAXIMUM(place_info.mon_kill_exp,
                        place_info.mon_kill_exp_avail) /
        (float) place_info.levels_seen;

    g = std::max<float>(place_info.mon_kill_exp, place_info.mon_kill_exp_avail)
        / place_info.levels_seen;