fiddlerwoaroof/crawl - Change PJ7HBIWAV3H23LXGZAAD2QYJ7HMOFOIR5ZJ4U2UTHI766LOTRRWQC

Labyrinth entry points are now a guaranteed minimum distance away from the

exit.

Exits from bazaars are treated as rock stairs instead of stone stairs.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@1952 c06c8d41-db1a-0410-9941-cceddc491573

Created by dshaligram on August 1, 2007

PJ7HBIWAV3H23LXGZAAD2QYJ7HMOFOIR5ZJ4U2UTHI766LOTRRWQC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/mapmark.h at line 107 [3.10602]
[3.13304]
[3.13304]
```
std::vector<map_marker*> env_get_all_markers();
```

Insertion in crawl-ref/source/mapmark.cc at line 445 [3.13502]

[2.3907]

[3.23547]

std::vector<map_marker*> env_get_all_markers()
{
    std::vector<map_marker*> rmarkers;
    for (dgn_marker_map::const_iterator i = env.markers.begin();
         i != env.markers.end(); ++i)
    {
        rmarkers.push_back(i->second);
    }
    return (rmarkers);    
}

Replacement in crawl-ref/source/files.cc at line 646 [5.3084589]

B:BD[4.5400] → [4.5400:5475]

static void place_player_on_stair(branch_type old_branch, int stair_taken)

[4.4723]

[4.5475]

static void place_player_on_stair(branch_type old_branch,
                                  int stair_taken)

Replacement in crawl-ref/source/files.cc at line 670 [5.3084589]

B:BD[4.6074] → [4.6074:6172]

    else if (stair_taken == DNGN_ENTER_HELL 
             || stair_taken == DNGN_ENTER_LABYRINTH)

[4.6074]

[4.6172]

    else if (stair_taken == DNGN_ENTER_HELL)

Replacement in crawl-ref/source/files.cc at line 713 [5.3084589]

B:BD[3.28583] → [3.28583:28631]

        stair_taken = DNGN_STONE_STAIRS_DOWN_I;

[3.28583]

[3.28631]

        stair_taken = DNGN_ROCK_STAIRS_DOWN;
    }
    else if (stair_taken == DNGN_ENTER_LABYRINTH)
    {
        // dgn_find_nearby_stair uses special logic for labyrinths.
        stair_taken = DNGN_ENTER_LABYRINTH;

Replacement in crawl-ref/source/files.cc at line 728 [5.3084589]

B:BD[6.2108] → [6.2108:2164]

        dgn_find_nearby_stair(stair_taken, find_first);

[6.2108]

[7.12208]

        dgn_find_nearby_stair(static_cast<dungeon_feature_type>(stair_taken),
                              find_first);

Replacement in crawl-ref/source/dungeon.h at line 284 [5.3428186]

B:BD[8.3085] → [8.3085:3156]

coord_def dgn_find_nearby_stair(int stair_to_find, bool find_closest);

[8.3085]

[9.148283]

coord_def dgn_find_nearby_stair(dungeon_feature_type stair_to_find,
                                bool find_closest);

Insertion in crawl-ref/source/dungeon.cc at line 5600 [5.3429798]

[10.1082]

    }
}
// Checks if there is a square with the given mask within radius of pos.
static bool has_vault_in_radius(const coord_def &pos, int radius,
                                unsigned mask)
{
    for (int yi = -radius; yi <= radius; ++yi)
    {
        for (int xi = -radius; xi <= radius; ++xi)
        {
            const coord_def p = pos + coord_def(xi, yi);
            if (!in_bounds(p))
                continue;
            if (!unforbidden(p, mask))
                return (true);
        }
    }
    return (false);
}
// Find an entry point that's:
// * At least 25 squares away from the exit.
// * At least 4 squares away from the nearest vault.
// * Floor (well, obviously).
static coord_def labyrinth_find_entry_point(const dgn_region &reg,
                                            const coord_def &end)
{
    const int min_distance = 25 * 25;
    // Try many times.
    for (int i = 0; i < 2000; ++i)
    {
        const coord_def place = reg.random_point();
        if (grd(place) != DNGN_FLOOR)
            continue;
        if ((place - end).abs() < min_distance)
            continue;
        if (has_vault_in_radius(place, 4, MMT_VAULT))
            continue;
        return (place);

Insertion in crawl-ref/source/dungeon.cc at line 5644 [5.3429798]
[10.1088]
[10.1088]
```
    return (coord_def());
```

Insertion in crawl-ref/source/dungeon.cc at line 5647 [5.3429798]

[10.1091]

[5.3662594]

static void labyrinth_place_entry_point(const dgn_region &region,
                                        const coord_def &pos)
{
    const coord_def p = labyrinth_find_entry_point(region, pos);
    if (in_bounds(p))
        env_add_marker(new map_feature_marker(pos, DNGN_ENTER_LABYRINTH));
}

Insertion in crawl-ref/source/dungeon.cc at line 5720 [5.3429798]
[11.3509]
[12.5827]
```
    labyrinth_place_entry_point(lab, end);
```

Replacement in crawl-ref/source/dungeon.cc at line 6817 [5.3429798]

B:BD[9.157799] → [6.5185:5255]

coord_def dgn_find_nearby_stair(int stair_to_find, bool find_closest)

[9.157799]

[6.5255]

static coord_def dgn_find_labyrinth_entry_point()
{
    std::vector<map_marker*> markers = env_get_all_markers();
    for (int i = 0, size = markers.size(); i < size; ++i)
    {
        map_marker *mark = markers[i];
        if (mark->get_type() == MAT_FEATURE
            && dynamic_cast<map_feature_marker*>(mark)->feat
            == DNGN_ENTER_LABYRINTH)
        {
            return (mark->pos);
        }
    }
    return (coord_def());
}
coord_def dgn_find_nearby_stair(dungeon_feature_type stair_to_find,
                                bool find_closest)

Insertion in crawl-ref/source/dungeon.cc at line 6843 [5.3429798]

[6.5484]


    if (stair_to_find == DNGN_ENTER_LABYRINTH)
    {
        const coord_def pos(dgn_find_labyrinth_entry_point());
        if (in_bounds(pos))
            return (pos);
        // Couldn't find a good place, warn, and use old behaviour.
        mpr("Oops, couldn't find labyrinth entry marker.", MSGCH_DIAGNOSTICS);
        stair_to_find = DNGN_FLOOR;
    }