bool exclude_endpoints = true);

                      bool exclude_endpoints = true,
                      bool just_check = false);

// If just_check is true, the function will return early once one
// such feature is encountered.

                      bool exclude_endpoints)

                      bool exclude_endpoints, bool just_check)

    bool reached_target = false;

        if (feat >= min_feat && feat <= max_feat)
            count++;

        if (ray.x() == targetx && ray.y() == targety)
            reached_target = true;

        if (ray.x() == targetx && ray.y() == targety)

        if (feat >= min_feat && feat <= max_feat
            && (!exclude_endpoints || !reached_target))

            if (exclude_endpoints && feat >= min_feat && feat <= max_feat)
                count--;

            count++;

            break;

            if (just_check) // Only needs to be > 0.
                return (count);

        if (reached_target)
            break;

    return count;

    return (count);

    // We now need to redo travel colours

    // We now need to redo travel colours.

    return (num_feats_between(posx_1, posy_1, posx_2, posy_2, DNGN_UNSEEN,
                              max_disallowed) == 0);

    return (!num_feats_between(posx_1, posy_1, posx_2, posy_2, DNGN_UNSEEN,
                               max_disallowed, true, true));

        // Exploring

        // Exploring.

        // Remember what run-mode we were in so that we can resume explore/
        // interlevel travel correctly.

        // Remember what run-mode we were in so that we can resume
        // explore/interlevel travel correctly.

    {

            // tile already occupied by monster or yourself {dlb}:

            // Tile already occupied by monster or yourself {dlb}:

                    || (srx == you.x_pos && sry == you.y_pos))

                || srx == you.x_pos && sry == you.y_pos)

            // finally, place the wall {dlb}:

            // Finally, place the wall {dlb}:

        }                       // end "for srx,sry"
    }

        }

                                          DNGN_MAXWALL);

                                          DNGN_MAXWALL, true, true);

            // item is valid for cursing, so we'll give it a chance

            // Item is valid for cursing, so we'll give it a chance.

    // any item to curse?

    // Any item to curse?

    // curse item:

    // Curse item.

    // made against your stats.  You're the potential messiah, after
    // all.

    // made against your stats.  You're the potential messiah, after all.

                    // prefers demons)

                    // prefers demons).

        // Monster killed by trap/inanimate thing/itself/poison not from you

        // Monster killed by trap/inanimate thing/itself/poison not from you.

            // have to add case for disintegration effect here? {dlb}

            // Have to add case for disintegration effect here? {dlb}

    // now that we have a spot, find a monster slot {dlb}:

    // Now that we have a spot, find a monster slot {dlb}:

}                               // end alert_nearby_monsters()

}

    // morph targets are _always_ "base" classes, not derived ones.

    // 'morph targets are _always_ "base" classes, not derived ones.

    // various inappropriate polymorph targets

    // Various inappropriate polymorph targets.

        || mons_class_flag( new_mclass, M_NO_EXP_GAIN )        // not helpless
        || new_mclass == mons_species( monster->type ) // must be different

        || mons_class_flag( new_mclass, M_NO_EXP_GAIN ) // not helpless
        || new_mclass == mons_species( monster->type )  // must be different

        // Other poly-unsuitable things

        // Other poly-unsuitable things.

        || (new_mclass >= MONS_GERYON && new_mclass <= MONS_ERESHKIGAL))

        || new_mclass >= MONS_GERYON && new_mclass <= MONS_ERESHKIGAL)

    // Determine if the monster is happy on current tile

    // Determine if the monster is happy on current tile.

}        // end valid_morph()

}

            || (power == PPT_LESS && (tgt_pow < src_pow - (relax / 2)));

                || (power == PPT_LESS && (tgt_pow < src_pow - (relax / 2)));

            || (power == PPT_MORE && (tgt_pow > src_pow + relax));

                || (power == PPT_MORE && (tgt_pow > src_pow + relax));

            || (tgt_pow > src_pow + (relax * 3) / 2);

                || (tgt_pow > src_pow + (relax * 3) / 2);

            // Pick a monster that's guaranteed happy at this grid

            // Pick a monster that's guaranteed happy at this grid.

            // valid targets are always base classes ([ds] which is unfortunate
            // in that well-populated monster classes will dominate polymorphs)

            // Valid targets are always base classes ([ds] which is unfortunate
            // in that well-populated monster classes will dominate polymorphs).

    // messaging: {dlb}

    // Messaging.

    const int old_hp     = monster->hit_points;
    const int old_hp_max = monster->max_hit_points;

    const int  old_hp     = monster->hit_points;
    const int  old_hp_max = monster->max_hit_points;

    // New monster type might be interesting

    // New monster type might be interesting.

    // If new monster is visible to player, then we've seen it

    // If new monster is visible to player, then we've seen it.

// allow_adjacent:  allow target to be adjacent to origin
// restrict_LOS:    restict target to be within PLAYER line of sight

// allow_adjacent:  allow target to be adjacent to origin.
// restrict_LOS:    restict target to be within PLAYER line of sight.

                                             DNGN_CLEAR_PERMAROCK_WALL);

                                             DNGN_CLEAR_PERMAROCK_WALL,
                                             true, true);

void mons_get_damage_level(
    const monsters* monster,
    std::string& desc, mon_dam_level_type& dam_level)

void mons_get_damage_level( const monsters* monster, std::string& desc,
                            mon_dam_level_type& dam_level )

    simple_monster_message(monster, desc.c_str(), MSGCH_MONSTER_DAMAGE, dam_level);
}                               // end print_wounds()

    simple_monster_message(monster, desc.c_str(), MSGCH_MONSTER_DAMAGE,
                           dam_level);
}

            // faking LOS by checking the neighbouring square

            // Faking LOS by checking the neighbouring square.

        // setup tracer

        // Setup tracer.

        // fire tracer

        // Fire tracer.

        // good idea?

        // Good idea?

        // setup tracer

        // Setup tracer.

        // fire tracer

        // Fire tracer.

        // good idea?

        // Good idea?

                // fire tracer

                // Fire tracer.

                // good idea?

                // Good idea?

        // set up the beam

        // Set up the beam.

        // fire tracer

        // Fire tracer.

        // good idea?

        // Good idea?

            // decrement # of volleys left

            // Decrement # of volleys left.

    // dragon breath weapon:

    // Dragon breath weapons:

            // fire tracer

            // Fire tracer.

            // good idea?

            // Good idea?

        // Don't behold player already half down or up the stairs

        // Don't behold player already half down or up the stairs.

    // yes, there is a logic to this ordering {dlb}:

    // Yes, there is a logic to this ordering {dlb}:

            // notice that these are the same odd colours used in

            // Notice that these are the same odd colours used in

    // yes, there is a logic to this ordering {dlb}:

    // Yes, there is a logic to this ordering {dlb}:

    // yes, there is a logic to this ordering {dlb}:

    // Yes, there is a logic to this ordering {dlb}:

            // these have been deemed "too tricky" at this time {dlb}:

            // These have been deemed "too tricky" at this time {dlb}:

        // these are wands that monsters will aim at themselves {dlb}:

        // These are wands that monsters will aim at themselves {dlb}:

            // good idea?

            // Good idea?

    if (nearby)      // handle monsters within range of player

    if (nearby)

        // Handle monsters within range of player.

    else                    // handle far-away monsters

    else

        // Handle far-away monsters.

    // yes, there is a logic to this ordering {dlb}:

    // Yes, there is a logic to this ordering {dlb}:

                spell_cast =
                    monster->has_spell(SPELL_GREATER_HEALING)?
                    SPELL_GREATER_HEALING : SPELL_LESSER_HEALING;

                spell_cast = monster->has_spell(SPELL_GREATER_HEALING)?
                             SPELL_GREATER_HEALING : SPELL_LESSER_HEALING;

                // setup the spell

                // Setup the spell.

                    // good idea?

                    // Good idea?

                    // all direct-effect/summoning/self-enchantments/etc.

                    // All direct-effect/summoning/self-enchantments/etc.

            // why only cast blink if nearby? {dlb}

            // Why only cast blink if nearby? {dlb}

    // fire tracer

    // Fire tracer.

    // good idea?

    // Good idea?

    // shapeshifters don't get spells

    // Shapeshifters don't get spells.

    if ( energy_gained == 0 && monster->speed != 0 )

    if (energy_gained == 0 && monster->speed != 0)

        // submerging monsters will hide from clouds

        // Submerging monsters will hide from clouds.

/*
                        if (monster->foe == enemy || mons_friendly(monster)
                                                     && monster->foe == MHITYOU)
                        {
                            monster->foe = MHITNOT;
                            monster->behaviour = BEH_WANDER;
                        }
                        monster->target_x = 10 + random2(GXM - 10);
                        monster->target_y = 10 + random2(GYM - 10);
*/

    // Monsters may now pick up several items in the same turn, though with
    // reducing chances. (jpeg)

            // trap one) form a corridor-like environment. If they don't
            // the trap square is marked as "unsafe", otherwise the decision
            // will be made according to later tests (monster hp, trap type, ...)

            // trap one).
            // If they don't, the trap square is marked as "unsafe" (because
            // there's good alternative move for the monster to take),
            // otherwise the decision will be made according to later tests
            // (monster hp, trap type, ...)

            // because it has less than half its maximum hp

            // because it has less than half its maximum hp.

            else // just be noisy without messaging the player

            else
            {
                // Just be noisy without messaging the player

            }

        {

        }

    // now, if a monster can't move in its intended direction, try

    // Now, if a monster can't move in its intended direction, try

    // gets it closer(farther for fleeing monsters) to its target.

    // gets it closer (farther for fleeing monsters) to its target.

        // first 1 away, then 2 (3 is silly)

        // First 1 away, then 2 (3 is silly).

            // try both directions

            // Try both directions.

            // now choose

            // Now choose.

    // fire tracer

    // Fire tracer.

}                               // end plant_spit()

}

    const int mindex = mslot == NUM_MONSTER_SLOTS? NON_ITEM : inv[mslot];
    return (mindex == NON_ITEM? NULL: &mitm[mindex]);

    const int mindex = (mslot == NUM_MONSTER_SLOTS) ? NON_ITEM : inv[mslot];
    return (mindex == NON_ITEM ? NULL : &mitm[mindex]);

    return (num_feats_between(x, y, tx, ty, DNGN_UNSEEN, max_disallowed) == 0);

    return (!num_feats_between(x, y, tx, ty, DNGN_UNSEEN, max_disallowed,
                               true, true));

// hack: prevent clrscr for some region

// Hack: prevent clrscr for some region.

// redefine color constants with shorter name to save space

// Redefine color constants with shorter names to save space.

    if ((you.level_type != LEVEL_LABYRINTH) && (you.level_type != LEVEL_ABYSS))

    // Unmappables...
    if (you.level_type != LEVEL_LABYRINTH && you.level_type != LEVEL_ABYSS)

        // highlight centre of the map

        // Highlight centre of the map.

/* initialize routines */

// Initialize routines.

    // Adjust sizes

    // Adjust sizes.

    // one more line for debug GPS
    region_stat = new TextRegionClass(crawl_view.hudsz.x, crawl_view.hudsz.y + 1, 0, 0);

    // One more line for debug GPS.
    region_stat = new TextRegionClass(crawl_view.hudsz.x,
                                      crawl_view.hudsz.y + 1, 0, 0);

    region_stat = new TextRegionClass(crawl_view.hudsz.x, crawl_view.hudsz.y, 0, 0);

    region_stat = new TextRegionClass(crawl_view.hudsz.x,
                                      crawl_view.hudsz.y, 0, 0);

    // do this before delete win_main

    // Do this before delete win_main.

/***  Save, Load, and Edit window prefs ***/

// Save, Load, and Edit window prefs.

    const char *winTxt = winTxtString.c_str()[0] == 0 ?
        baseTxt : winTxtString.c_str();

    const char *winTxt = (winTxtString.c_str()[0] == 0 ? baseTxt
                                                       : winTxtString.c_str());

            {

            }

                        if (p->type == 'S')

                        else if (p->type == 'S')

                    }// tag match

                    }

        }// while

        } // while (!end of file)

    struct prefs *p = &pref_data[i];
    int idx = p->dummy_idx;
    if (p->type == 'I')
        dummy_int[pref_mode][idx] = *(int *)p->ptr;
    else if (p->type == 'S')
        strncpy(dummy_str[pref_mode][idx], (char *)p->ptr, MAX_PREF_CHAR);

        struct prefs *p = &pref_data[i];
        int idx = p->dummy_idx;
        if (p->type == 'I')
            dummy_int[pref_mode][idx] = *(int *)p->ptr;
        else if (p->type == 'S')
            strncpy(dummy_str[pref_mode][idx], (char *)p->ptr, MAX_PREF_CHAR);

            for ( i = 0; i < MAX_PREFS; i++)

            for (i = 0; i < MAX_PREFS; i++)

                 struct prefs *p = &pref_data[i];
                 int idx = p->dummy_idx;

                struct prefs *p = &pref_data[i];
                int idx = p->dummy_idx;

                 if (p->type == 'I')
                 {
                     fprintf(fp, "%s:%s=%d\n", pref_mode_name[mode],
                             p->tagname, dummy_int[mode][idx]);
                 }
                 else if (p->type == 'S')
                 {
                     fprintf(fp, "%s:%s=%s\n", pref_mode_name[mode],
                             p->tagname, dummy_str[mode][idx]);
                 }

                if (p->type == 'I')
                {
                    fprintf(fp, "%s:%s=%d\n", pref_mode_name[mode],
                            p->tagname, dummy_int[mode][idx]);
                }
                else if (p->type == 'S')
                {
                    fprintf(fp, "%s:%s=%s\n", pref_mode_name[mode],
                            p->tagname, dummy_str[mode][idx]);
                }

                 struct prefs *p = &pref_data[i];
                 cgotoxy(2, i+2, GOTO_STAT);
                 if (i == cur_pos)
                 {
                     textcolor(0xf0);
                     cprintf(">");
                 }
                 else
                 {
                     textcolor(LIGHTGREY);
                     cprintf(" ");
                 }

                struct prefs *p = &pref_data[i];
                cgotoxy(2, i+2, GOTO_STAT);
                if (i == cur_pos)
                {
                    textcolor(0xf0);
                    cprintf(">");
                }
                else
                {
                    textcolor(LIGHTGREY);
                    cprintf(" ");
                }

                 if (pref_data[i].type == 'I')
                     cprintf(" %s: %3d  ", p->name, *(int *)p->ptr);
                 else
                     cprintf(" %s: %s", p->name, (char *)p->ptr);

                if (pref_data[i].type == 'I')
                    cprintf(" %s: %3d  ", p->name, *(int *)p->ptr);
                else
                    cprintf(" %s: %s", p->name, (char *)p->ptr);

        int crt_x_old = crt_x;
        int crt_y_old = crt_y;

        int crt_x_old  = crt_x;
        int crt_y_old  = crt_y;

        int msg_x_old = msg_x;
        int msg_y_old = msg_y;

        int msg_x_old  = msg_x;
        int msg_y_old  = msg_y;

            // resize msg?

            // Resize msg?

            // resize crt?

            // Resize crt?

            // resize map?

            // Resize map?

            // resize dngn tile screen?

            // Resize dngn tile screen?

            // Now screens are all black

            // Now screens are all black.

                                // For Sandblast and Sticks to Snakes, respectively.

                                // For Sandblast and Sticks to Snakes,
                                // respectively.

                    // special handling since skeletons have no primary action

                    // Special handling since skeletons have no primary action.

                    // has to be non-equipped or non-cursed to drop

                    // Has to be non-equipped or non-cursed to drop.

            // character overview

            // Character overview.

            // Religion

            // Religion.

    const int dx[9] = {-1,0,1, -1,0,1, -1,0,1};
    const int dy[9] = {1,1,1,0,0,0,-1,-1,-1};

    const int dx[9] = {-1, 0, 1,
                       -1, 0, 1,
                       -1, 0, 1};
    const int dy[9] = { 1, 1, 1,
                        0, 0, 0,
                       -1,-1,-1};

    if (button == 2)
        trig = CK_MOUSE_B2;
    else if (button == 3)
        trig = CK_MOUSE_B3;
    else if (button == 4)
        trig = CK_MOUSE_B4;
    else if (button == 5)
        trig = CK_MOUSE_B5;

    switch (button)
    {
        case 2: trig = CK_MOUSE_B2; break;
        case 3: trig = CK_MOUSE_B3; break;
        case 4: trig = CK_MOUSE_B4; break;
        case 5: trig = CK_MOUSE_B5; break;
        default: break;
    }

    static int  old_button = 0;
    static int  old_hp = 0;

    static int  old_button   = 0;
    static int  old_hp       = 0;

    // prevent accidental wheel slip and subsequent char death

    // Prevent accidental wheel slip and subsequent char death.

        // quit telescope mode

        // Quit telescope mode.

    // item clicked

    // Clicked on item.

                // describe item

                // Describe item.

                    // try pick up one item

                    // Try to pick up one item.

                // use item

                // Use item.

            // pick up items

            // Pick up items.

            // else attempt to use stairs on square

            // Else attempt to use stairs on square.

            // describe yourself

            // Describe yourself.

                    return '%'; // character overview

                    return '%'; // Character overview.

                    return '^'; // religion screen

                    return '^'; // Religion screen.

            // Right Click: try to describe grid
            // otherwise return trigger key

            // R-Click: try to describe grid; otherwise return trigger key.

        // first, check if 3x3 grid around @ is clicked.
        // if so, return equivalent numpad key

        // First check if 3x3 grid around @ is clicked.
        // If so, return equivalent numpad key.

        // otherwise travel to that grid

        // Otherwise travel to that grid.

        // Activate travel

        // Activate travel.

        // begin telescope mode

        // Begin telescope mode.

        // L-click: try to travel to the grid

        // L-click: try to travel to the grid.

        // Activate travel

        // Activate travel.

        {

        }

        11, 10, 8, 12, '0', 25, 2, 'C', 21, 14

         11,  10,   8,  12, '0',  25,   2, 'C',  21,  14

    // init cursor etc

    // Init cursor etc.

    // clear Text regions

    // Clear Text regions.

    // Hack: Do not erase the backbuffer. Instead just hide it.

    // Hack: Do not erase the backbuffer; instead just hide it.

    /* Locate the cursor */

    // Locate the cursor.

    /* Paranoia -- check len */
    if (len < 1) len = 1;

    // Paranoia -- check len.
    if (len < 1)
        len = 1;

    /* Restrict the length */
    if (x + len > r->mx) len = r->mx - x;
    if (len > 40) len = 40;

    // Restrict the length.
    if (x + len > r->mx)
        len = r->mx - x;
    if (len > 40)
        len = 40;

    /* Paranoia -- Clip the default entry */

    // Paranoia -- Clip the default entry.

    buff[0] = '\0';

    buff[0]   = '\0';

    /* Process input */

    // Process input.

        /* Get a key */

        // Get a key.

        /* Analyze the key */

        // Analyze the key.

        /* Terminate */

        // Terminate.

        /* Update the entry */

        // Update the entry.

    }/* while */

    } // while (!done)

#define DELIMITER_END "-------------------------------------------------------------------------------"

#define DELIMITER_END  "-------------------------------------------------------------------------------"

    return (delay == DELAY_RUN || delay == DELAY_REST
            || delay == DELAY_TRAVEL);

    return (delay == DELAY_RUN || delay == DELAY_REST || delay == DELAY_TRAVEL);