run_los_tests(depth, 1, 10)

  run_los_tests(depth, 1, 3)

local function test_gridseegrid_symmetry()

local function test_cellseecell_symmetry()

  you.losight()
  crawl.redraw_view()

        local foreward = dgn.grid_see_grid(you_x, you_y, px, py)
        local backward = dgn.grid_see_grid(px, py, you_x, you_y)

        local foreward = dgn.cell_see_cell(you_x, you_y, px, py)
        local backward = dgn.cell_see_cell(px, py, you_x, you_y)

        if forward ~= backward then

        if (forward and backward) or (not forward and not backward) then

                 "grid_see_grid asymmetry detected (iter #" .. checks .. "): "

                 "cell_see_cell asymmetry detected (iter #" .. checks .. "): "

      test_gridseegrid_symmetry()

      test_cellseecell_symmetry()

  run_los_tests(depth, 1, 10)

  run_los_tests(depth, 1, 1)

        || grid_see_grid(mon->pos(), you.pos(), can_move))

        || can_go_straight(mon->pos(), you.pos(), can_move))

            if (grid_see_grid(targ, you.pos(), can_move))

            if (can_go_straight(targ, you.pos(), can_move))

                else if (grid_see_grid(mon->pos(), mon->travel_path[0],

                else if (can_go_straight(mon->pos(), mon->travel_path[0],

    if (!grid_see_grid(mon->pos(), mon->travel_path[0], can_move))

    if (!can_go_straight(mon->pos(), mon->travel_path[0], can_move))

            if (grid_see_grid(mon->pos(), mon->travel_path[i], can_move))

            if (can_go_straight(mon->pos(), mon->travel_path[i], can_move))

// grid_see_grid() is probably rather too conservative in these estimates.

// can_go_straight() is probably rather too conservative in these estimates.

        if (grid_see_grid(pos, path[i], can_move))

        if (can_go_straight(pos, path[i], can_move))

LUAFN(dgn_grid_see_grid)

LUAFN(dgn_cell_see_cell)

    return grid_see_grid(p, q);

    PLUARET(number, cell_see_cell(p, q));

    { "weight", dgn_weight },

    { "grid_see_grid", dgn_grid_see_grid },

    { "cell_see_cell", dgn_cell_see_cell },

// A complete base implementation that does standard visibility
// based on env.grid.
struct los_param_base : los_param_trans

// Standard visibility disregarding clouds.
struct los_param_nocloud : los_param_trans

    los_param_base(const coord_def& c);

    los_param_nocloud(const coord_def& c);

    opacity_type opacity(const coord_def& p) const;
};
// Standard visibility.
struct los_param_base : los_param_nocloud
{
    los_param_base(const coord_def& c);

/* los_param_base */

/* los_param_nocloud */

los_param_base::los_param_base(const coord_def& c)

los_param_nocloud::los_param_nocloud(const coord_def& c)

dungeon_feature_type los_param_base::feature(const coord_def& p) const

dungeon_feature_type los_param_nocloud::feature(const coord_def& p) const

unsigned los_param_base::appearance(const coord_def& p) const

unsigned los_param_nocloud::appearance(const coord_def& p) const

opacity_type los_param_nocloud::opacity(const coord_def& p) const
{
    dungeon_feature_type f = feature(p);
    if (grid_is_opaque(f))
        return OPC_OPAQUE;
    else
        return OPC_CLEAR;
}
/* los_param_base */
los_param_base::los_param_base(const coord_def& c)
    : los_param_nocloud(c)
{
}

bool grid_see_grid(const coord_def& p1, const coord_def& p2,
                   dungeon_feature_type allowed = DNGN_UNSEEN);

bool cell_see_cell(const coord_def& p1, const coord_def& p2);
bool can_go_straight(const coord_def& p1, const coord_def& p2,
                     dungeon_feature_type allowed);

// Usually calculates whether from one grid someone could see the other.
// Depending on the viewer's habitat, 'allowed' can be set to DNGN_FLOOR,
// DNGN_SHALLOW_WATER or DNGN_DEEP_WATER.
// Yes, this ignores lava-loving monsters.
// XXX: It turns out the beams are not symmetrical, i.e. switching
// pos1 and pos2 may result in small variations.
bool grid_see_grid(const coord_def& p1, const coord_def& p2,
                   dungeon_feature_type allowed)

// Is p2 visible from p1, disregarding clouds?
// XXX: Horribly inefficient since we do an entire LOS calculation;
//      needs to be rewritten if it is used more.
bool cell_see_cell(const coord_def& p1, const coord_def& p2)
{
    env_show_grid show;
    losight(show, los_param_nocloud(p1));
    return see_grid(show, p1, p2);
}
// Checks whether there is a straight path from p1 to p2 that passes
// through features >= allowed.
// If it exists, such a path may be missed; on the other hand, it
// is not guaranteed that p2 is visible from p1 according to LOS rules.
// Not symmetric.
bool can_go_straight(const coord_def& p1, const coord_def& p2,
                     dungeon_feature_type allowed)

    // XXX: Ignoring clouds for now.

            if (x == 0 && y == 0)
                continue;

        if (not_seen && grid_see_grid(cp, centre))

        if (not_seen && cell_see_cell(cp, centre))