fiddlerwoaroof/crawl - Change HBRUWIHAOFRF57K4D7TNGLVAFWP3SLH6UUMQCSVKBFOKG3KYTRVQC

Add blood and glass to labyrinths.

In ASCII wizard mode these features are highlighted in the level map (&{) and can then easily be reached via xm (normal map), but only until the first shift takes place. Feedback welcome!

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

Created by j-p-e-g on November 26, 2008

HBRUWIHAOFRF57K4D7TNGLVAFWP3SLH6UUMQCSVKBFOKG3KYTRVQC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/tile2.cc at line 69 [4.13289]
B:BD[2.302] → [2.302:342]
```
//       at least for the portal walls.
```
[2.302]
[4.39661]
```
//       at least for the portal vaults.
```

Replacement in crawl-ref/source/misc.h at line 45 [6.1928926]

B:BD[5.36597] → [5.36597:36642]

                      bool spatter = false);

[5.36597]

[7.2579]

                      bool spatter = false, bool smell_alert = true);

Replacement in crawl-ref/source/misc.cc at line 1130 [6.1933596]

B:BD[8.5825] → [5.37337:37463]

static void maybe_bloodify_square(const coord_def& where, int amount,
                                  bool spatter = false)

[8.5825]

[8.5907]

static void _maybe_bloodify_square(const coord_def& where, int amount,
                                   bool spatter = false,
                                   bool smell_alert = true)

Replacement in crawl-ref/source/misc.cc at line 1150 [6.1933596]

B:BD[9.18616] → [10.6248:6317]

B:BD[10.6317] → [11.4609:4670]

∅:D[11.4670] → [5.37711:37747]

B:BD[5.37711] → [5.37711:37747]

∅:D[5.37747] → [10.6318:6365]

B:BD[12.7356] → [10.6318:6365]

B:BD[10.6365] → [5.37748:37783]

        // If old or new blood on square, the smell reaches further.
        if (testbits(env.map(where).property, FPROP_BLOODY))
            blood_smell(12, where);
        else // Still allow a lingering smell.
            blood_smell(7, where);

[9.18616]

[13.544399]

        if (smell_alert)
        {
            // If old or new blood on square, the smell reaches further.
            if (testbits(env.map(where).property, FPROP_BLOODY))
                blood_smell(12, where);
            else // Still allow a lingering smell.
                blood_smell(7, where);
        }

Replacement in crawl-ref/source/misc.cc at line 1162 [6.1933596]

B:BD[10.6431] → [14.6782:6840]

            for ( adjacent_iterator ai(where); ai; ++ai )

[10.6431]

[5.37856]

            for (adjacent_iterator ai(where); ai; ++ai)

Replacement in crawl-ref/source/misc.cc at line 1168 [6.1933596]

B:BD[8.6786] → [14.6908:6963]

                maybe_bloodify_square(*ai, amount/15);

[8.6786]

[5.38166]

                _maybe_bloodify_square(*ai, amount/15);

Replacement in crawl-ref/source/misc.cc at line 1178 [6.1933596]

B:BD[5.38240] → [5.38240:38288]

                      int damage, bool spatter)

[5.38240]

[8.7189]

                      int damage, bool spatter, bool smell_alert)

Replacement in crawl-ref/source/misc.cc at line 1184 [6.1933596]

B:BD[8.7244] → [5.38320:38371]

    maybe_bloodify_square(where, damage, spatter);

[8.7244]

[8.7294]

    _maybe_bloodify_square(where, damage, spatter, smell_alert);

Replacement in crawl-ref/source/misc.cc at line 1189 [6.1933596]

B:BD[7.3024] → [14.6964:7021]

    for ( adjacent_iterator ai(where, false); ai; ++ai )

[7.3024]

[5.38505]

    for (adjacent_iterator ai(where, false); ai; ++ai)

Replacement in crawl-ref/source/misc.cc at line 2484 [6.1933596]
B:BD[15.4567] → [3.5525:5528]
```
  
```
[15.4567]
[16.6515]

Insertion in crawl-ref/source/dungeon.cc at line 6667 [6.3429798]

[17.373]

[18.2761]

}
static bool _is_deadend(const coord_def pos)
{
    std::vector<coord_def> dirs;
    dirs.push_back(coord_def(0, -1));
    dirs.push_back(coord_def(1,  0));
    dirs.push_back(coord_def(0,  1));
    dirs.push_back(coord_def(-1, 0));
    int count_neighbours = 0;
    for (unsigned int i = 0; i < dirs.size(); i++)
    {
        coord_def p = pos + dirs[i];
        if (!in_bounds(p))
            continue;
        if (grd(p) == DNGN_FLOOR)
            count_neighbours++;
    }
    return (count_neighbours <= 1);
}
static coord_def _find_random_deadend(const dgn_region &region)
{
    int tries = 0;
    coord_def result;
    bool floor_pos = false;
    while (++tries < 50)
    {
        coord_def pos = region.random_point();
        if (grd(pos) != DNGN_FLOOR)
            continue;
        else if (!floor_pos)
        {
            result = pos;
            floor_pos = true;
        }
        if (!_is_deadend(pos))
            continue;
        return (pos);
    }
    return (result);
}
// Adds a bloody trail ending in a dead end with spattered walls.
static void _labyrinth_add_blood_trail(const dgn_region &region)
{
    if (one_chance_in(5))
        return;
    int count_trails = 1 + one_chance_in(5) + one_chance_in(7);
    int tries = 0;
    while (++tries < 20)
    {
        const coord_def start = _find_random_deadend(region);
        const coord_def dest  = region.random_point();
        monster_pathfind mp;
        if (!mp.init_pathfind(dest, start))
            continue;
        const std::vector<coord_def> path = mp.backtrack();
        if (path.size() < 10)
            continue;
        env.map(start).property |= FPROP_BLOODY;
#ifdef WIZARD
        env.map(start).property |= FPROP_HIGHLIGHT;
#endif
        bleed_onto_floor(start, MONS_HUMAN, 150, true, false);
        for (unsigned int step = 0; step < path.size(); step++)
        {
            coord_def pos = path[step];
            if (step < 2 || step < 12 && coinflip()
                || step >= 12 && one_chance_in(step/4))
            {
                env.map(pos).property |= FPROP_BLOODY;
            }
#ifdef WIZARD
            env.map(pos).property |= FPROP_HIGHLIGHT;
#endif
            if (step >= 10 && one_chance_in(7))
                break;
        }
        if (--count_trails > 0)
            continue;
        break;
    }
}
static bool _find_random_nonmetal_wall(const dgn_region &region,
                                       coord_def &pos)
{
    int tries = 0;
    while (++tries < 50)
    {
        pos = region.random_point();
        if (!in_bounds(pos))
            continue;
        if (grd(pos) == DNGN_ROCK_WALL || grd(pos) == DNGN_STONE_WALL)
            return (true);
    }
    return (false);
}
static bool _grid_has_wall_neighbours(const coord_def pos, const coord_def dir)
{
    std::vector<coord_def> dirs;
    dirs.push_back(coord_def(0, -1));
    dirs.push_back(coord_def(1,  0));
    dirs.push_back(coord_def(0,  1));
    dirs.push_back(coord_def(-1, 0));
    for (unsigned int i = 0; i < dirs.size(); i++)
    {
        coord_def p = pos + dirs[i];
        if (!in_bounds(p))
            continue;
        if (dirs[i] == dir)
            continue;
        if (grd(p) == DNGN_ROCK_WALL || grd(p) == DNGN_STONE_WALL)
            return (true);
    }
    return (false);
}
static void _vitrify_wall_neighbours(const coord_def pos)
{
    // This hinges on clear wall types having the same order as non-clear ones!
    const int clear_plus = DNGN_CLEAR_ROCK_WALL - DNGN_ROCK_WALL;
    std::vector<coord_def> dirs;
    dirs.push_back(coord_def(0, -1));
    dirs.push_back(coord_def(1,  0));
    dirs.push_back(coord_def(0,  1));
    dirs.push_back(coord_def(-1, 0));
    for (unsigned int i = 0; i < dirs.size(); i++)
    {
        coord_def p = pos + dirs[i];
        if (!in_bounds(p))
            continue;
        // Don't vitrify vault grids
        if (testbits(env.map(p).property, FPROP_VAULT))
            continue;
        if (grd(p) == DNGN_ROCK_WALL || grd(p) == DNGN_STONE_WALL)
        {
            grd(p) = static_cast<dungeon_feature_type>(grd(p) + clear_plus);
#ifdef WIZARD
            env.map(p).property |= FPROP_HIGHLIGHT;
#endif
            if (one_chance_in(3) || _grid_has_wall_neighbours(p, dirs[i]))
                _vitrify_wall_neighbours(p);
        }
    }
}
static void _labyrinth_add_glass_walls(const dgn_region &region)
{
    int glass_num = random2(3) + random2(4);
    if (!glass_num)
        return;
    // This hinges on clear wall types having the same order as non-clear ones!
    const int clear_plus = DNGN_CLEAR_ROCK_WALL - DNGN_ROCK_WALL;
    coord_def pos;
    while (0 < glass_num--)
    {
        if (!_find_random_nonmetal_wall(region, pos))
            break;
        if (_has_vault_in_radius(pos, 6, MMT_VAULT))
            continue;
        grd(pos) = static_cast<dungeon_feature_type>(grd(pos) + clear_plus);
#ifdef WIZARD
        env.map(pos).property |= FPROP_HIGHLIGHT;
#endif
        _vitrify_wall_neighbours(pos);
    }

Insertion in crawl-ref/source/dungeon.cc at line 6926 [6.3429798]

[19.5920]

[20.6143]

    _labyrinth_add_blood_trail(lab);
    _labyrinth_add_glass_walls(lab);