// Set the seed point

    // Set the seed point.
    // For each round, circumference will store all points that were discovered
    // in the previous round of a given distance. We use an array of size 2,
    // so we can comfortably switch between the list of points to be
    // investigated this round and the slowly growing list of points to be
    // inspected next round. Once we've finished with the current round, i.e.
    // there are no more points to be looked at in the current array, we switch
    // circ_index over to !circ_index (between 0 and 1), so the "next round"
    // becomes the current one, and the old points can be overwritten with
    // newer ones. Since we count the number of points for next round in
    // next_iter_points, we don't even need to reset the array.

    // point_distance will hold the distance of all points from the starting
    // point, i.e. the distance travelled to get there.

            // Look at all neighbours of the current grid.
            // path_examine_point() returns true if the target is reached
            // and marked as such.

        // If there are no more points to look at, we're done, but we did
        // not find a path to our target.

        // This point is going to be on the agenda for the next
        // iteration

        // This point is going to be on the agenda for the next iteration.

// Checks all neighbours of c, adds them to next round's list of points
// - happens in path_flood() - and returns true if one of them turns out
// to be the target; otherwise, false.

        && you.piety >= piety_breakpoint(4));

            && you.piety >= piety_breakpoint(4));

    if ((you.num_gifts[GOD_NEMELEX_XOBEH] == 0
         && random2(piety_breakpoint(1)) < you.piety) ||
        (random2(MAX_PIETY) <= you.piety
         && one_chance_in(3)
         && !you.attribute[ATTR_CARD_COUNTDOWN]))

    if (you.num_gifts[GOD_NEMELEX_XOBEH] == 0
           && random2(piety_breakpoint(1)) < you.piety
        || random2(MAX_PIETY) <= you.piety && one_chance_in(3)
           && !you.attribute[ATTR_CARD_COUNTDOWN])

    // Apply hysteresis

    // Apply hysteresis.

        you.piety_hysteresis = (unsigned char)std::max<int>(
            0, you.piety_hysteresis - pgn);

        you.piety_hysteresis =
            (unsigned char) std::max<int>( 0, you.piety_hysteresis - pgn );

mprf(MSGCH_DIAGNOSTICS, "Piety increasing by %d (and %d taken from hysteresis)", pgn, pgn_borrowed);

        mprf(MSGCH_DIAGNOSTICS, "Piety increasing by %d (and %d taken from "
                                "hysteresis)", pgn, pgn_borrowed);

        if ( you.piety >= piety_breakpoint(i) &&
             old_piety < piety_breakpoint(i) )

        if (you.piety >= piety_breakpoint(i)
            && old_piety < piety_breakpoint(i))

            if ( you.piety < piety_breakpoint(i) &&
                 old_piety >= piety_breakpoint(i) )

            if (you.piety < piety_breakpoint(i)
                && old_piety >= piety_breakpoint(i))

int piety_rank( int piety )

int piety_rank(int piety)

    if ( piety < 0 )

    if (piety < 0)

    for ( int i = 0; i < numbreakpoints; ++i )
        if ( piety >= breakpoints[i] )

    for (int i = 0; i < numbreakpoints; ++i)
        if (piety >= breakpoints[i])

    if ( i >= MAX_GOD_ABILITIES || i < 0 )

    if (i >= MAX_GOD_ABILITIES || i < 0)

        || (mon->invisible() && !player_see_invis()))

        || mon->invisible() && !player_see_invis())

// returns true if player is beheld by a given monster

// Returns true if player is beheld by a given monster.

    // can this monster even behold you?

    // Can this monster even behold you?

    bool was_seen = player_monster_visible(monster) && mons_near(monster);

    bool was_seen = player_monster_visible(monster) && mons_near(monster)
                    && monster->behaviour != BEH_LURK;

                    // We've got a target, so we'll continue on our way.

                    // We've got a target, so we'll continue on our way.

            if (mon->foe == MHITYOU && proxPlayer)

            if (mon->foe == MHITYOU)

                // Just because we can *see* the player, that doesn't mean
                // we can actually get there. To find about that, we first
                // check for transparent walls. If there are transparent
                // walls in the way we'll need pathfinding, no matter what.
                // (Though monsters with a los attack don't need to get any
                // closer to hurt the player.)
                // If no walls are detected, there could still be a river
                // or a pool of lava in the way. So we check whether there
                // is water or lava in LoS (boolean) and if so, try to find
                // a way around it. It's possible that the player can see
                // lava but it actually has no influence on the monster's
                // movement (because it's lying in the opposite direction)
                // but if so, we'll find that out during path finding.
                // In another attempt of optimization, don't bother with
                // path finding if the monster in question has no trouble
                // travelling through water or flying across lava.
                // Also, if no path is found (too far away, perhaps) set a
                // flag, so we don't directly calculate the whole thing again
                // next turn, and even extend that flag to neighbouring
                // monsters of similar movement restrictions.

#ifdef DEBUG_PATHFIND
                        mpr("Already travelling...");
#endif

#ifdef DEBUG_PATHFIND
                            mpr("Target still valid?");
#endif

                // Whew. If we arrived here, path finding didn't yield anything
                // (or wasn't even attempted) and we need to set our target
                // the traditional way.

                // We have a foe but it's not the player.

                        // Not by much, though, since the original path was
                        // optimal (A*) and the distance between the waypoints
                        // is rather small.

/*

                            // The last coordinate in the path vector is our
                            // destination.

#ifdef DEBUG_PATHFIND
                                mprf("Next waypoint: (%d, %d)",
                                     mon->target_x, mon->target_y);
#endif

*/

//                            }

                            }

                    }
                    else
                    {
#ifdef DEBUG_PATHFIND
                        mpr("All clear. Continue travelling.");
#endif

                    // Else, we can see the next waypoint and are making good
                    // progress. Carry on, then!

                // If we still need a target because we're not travelling
                // (any more), check for patrol routes instead.

                            // Ideally, smart monsters should be able to use
                            // pathfinding to find the way back, and animals
                            // could decide to stop patrolling if the path
                            // was too long.

                            // Other than for tracking the player, there's
                            // currently no distinction between smart and
                            // stupid monsters when it comes to travelling
                            // back to the patrol point. This is in part due
                            // to the flavourness of bees finding their way
                            // back to the Hive (patrolling should really be
                            // restricted to cases like this), and for the
                            // other part it's not that important because
                            // we calculate the path once and then follow it
                            // home, and the player won't ever see the
                            // orderly fashion the bees will trudge along.
                            // What he will see is them swarming back to the
                            // Hive entrance after some time, and that is what
                            // matters.

                                    // We're so close we don't even need
                                    // a path. (Shouldn't happen as that
                                    // should have been found above.)

#ifdef DEBUG_PATHFIND
                    if (!testbits( mon->flags, MF_BATTY ))
                        mprf("Monster is wandering randomly.");
#endif

                    // The monster is travelling randomly.

// The pathfinding is an implementation of the A* algorithm. Beginning at the
// destination square we check all neighbours of a given grid, estimate the
// distance needed for any shortest path including this grid and push the
// result into a hash. We can then easily access all points with the shortest
// distance estimates and then check _their_ neighbours and so on.
// The algorithm terminates once we reach the monster position since - because
// of the sorting of grids by shortest distance in the hash - there can be no
// path between start and target that is shorter than the current one. There
// could be other paths that have the same length but that has no real impact.
// If the hash has been cleared and the start grid has not been encountered,
// then there's no path that matches the requirements fed into monster_pathfind.
// (These requirements are usually preference of habitat of a specific monster
// or a limit of the distance between start and any grid on the path.)

// The main method in the monster_pathfind class.

        // Calculate the distance to all neighbours of the current position,
        // and add them to the hash, if they haven't already been looked at.

        // Pull the position with shortest distance estimate to our target grid.

    // zigzagging should be avoided. This means directions are looked at, in
    // order: 1, 3, 5, 7, 0, 2, 4, 6. (dir = 0) is an intentional assignment.

    // zigzagging can be significantly reduced.
    //
    //      1  0  2       This means directions are looked at, in order,
    //       \ | /        1, 3, 5, 7 (diagonals) followed by 0, 2, 4, 6
    //      7--.--3       (orthogonals). This is achieved by the assignment
    //       / | \        of (dir = 0) once dir has passed 7.
    //      6  5  4
    //

        // If the new distance is better than the old one (initialized with
        // INFINITE), update the position.

            //      7  0  1
            //      6  .  2
            //      5  4  3

            //      0  1  2         4  5  6
            //      7  .  3   ==>   3  .  7       e.g. (3 + 4) % 8          = 7
            //      6  5  4         2  1  0            (7 + 4) % 8 = 11 % 8 = 3

// Starting at known min_length (minimum total estimated path distance), check
// the hash for existing vectors, then pick the last entry of the first vector
// that matches. Update min_length, if necessary.

            // Pick the last position pushed into the vector as it's most
            // likely to be close to the target.

// Using the prev vector backtrack from start to target to find all steps to
// take along the shortest path.

// to reach the target.

// to reach the target. Waypoints are chosen such that from one waypoint you
// can only just see the next one. Note that grid_see_grid() is probably
// rather too conservative in these estimates.
// This is done because Crawl's path finding once a target can be seen is
// very robust and because it allows for more natural traversing if there are
// other monsters in the way.

    // whether a tracked enemy has moved too much, and we have to update the
    // path.

    // whether a tracked enemy has moved too much, in case we have to update
    // the path.

// Checks whether a given monster can pass over a certain position, respecting
// its preferred habit and capability of flight or opening doors.

    // Only tested for shallow water since they can't enter deep water anywa.

    // (The resulting path might not be optimal but it will lead to a path
    // a monster of such habits is likely to prefer.)
    // Only tested for shallow water since they can't enter deep water anyway.

    //

            // Zot traps are considered intraversable.

        return 1;

// The estimated cost to reach a grid is simply max(dx, dy).

// Petrification works in two stages. First the monster is slowed down in
// all of its actions and cannot move away (petrifying), and when that times
// out it remains properly petrified (no movement or actions). The second
// part is similar to paralysis, except that insubstantial monsters can't be
// affected and that stabbing damage is drastically reduced.

        // If the petrifying is not yet finished, we can force it to happen
        // right away by casting again. Otherwise, the spell has no further
        // effect.

        // Add both the petrifying and the petrified enchantment. The former
        // will run out sooner and result in plain petrification behaviour.

bool curare_hits_monster( const bolt &beam,
                          monsters *monster,
                          kill_category who,
                          int levels )

bool curare_hits_monster( const bolt &beam,  monsters *monster,
                          kill_category who, int levels )

            {

            }

            break;     // slow

            break;

            break;     // haste

            break;

            break;     // heal (heal wounds potion eff)

            break;

            break;     // paralysis

            break;

            break;     // confusion

            break;

            break;     // invisibility

            break;

            // 6 is used by digging

            you.banished = true;
            you.banished_by = _beam_zapper(beam);

            you.banished        = true;
            you.banished_by     = _beam_zapper(beam);

            break;     // banishment to the abyss

            break;

        case BEAM_PAIN:      // pain

        case BEAM_PAIN:

            // _all_ enchantments should be enumerated here!

            // _All_ enchantments should be enumerated here!

        }               // end of switch (beam.colour)

        }

                {

                }

                {

                }