fiddlerwoaroof/crawl - Change SW3RLYFNRT3IJBK6LYKHKP2J2YDU7SXQWAJZX7U6S7ICYW43OMNQC

load() cleanups.

Rock stairs now take you to the closest stair distance-wise. This invalidates the interlevel travel cache.

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

Created by haranp on April 25, 2007

SW3RLYFNRT3IJBK6LYKHKP2J2YDU7SXQWAJZX7U6S7ICYW43OMNQC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/files.h at line 47 [4.3082298]

B:BD[4.3083342] → [2.2759:2825]

void load( int stair_taken, int load_mode, bool was_a_labyrinth,

[4.3083342]

[2.2825]

void load( int stair_taken, load_mode_type load_mode, bool was_a_labyrinth,

Insertion in crawl-ref/source/files.cc at line 544 [4.3084589]

[5.433866]

[6.865859]


static coord_def find_nearby_stair(int stair_to_find, bool find_closest)
{
    // scan around the player's position first
    int basex = you.x_pos;
    int basey = you.y_pos;
    // check for illegal starting point
    if ( !in_bounds(basex, basey) )
    {
        basex = 0;
        basey = 0;
    }
    coord_def result;

Replacement in crawl-ref/source/files.cc at line 560 [4.3084589]

B:BD[6.865860] → [2.3740:3861]

void load( int stair_taken, int load_mode, bool was_a_labyrinth,
           int old_level, branch_type where_were_you2 )

[6.865860]

[4.3091532]

    int found = 0;
    int best_dist = 1 + GXM*GXM + GYM*GYM;
    // XXX These passes should be rewritten to use an iterator of STL
    // algorithm of some kind.
    // First pass: look for an exact match
    for (int xcode = 0; xcode < GXM; ++xcode )
    {
        const int xsign = ((xcode % 2) ? 1 : -1);
        const int xdiff = xsign * (xcode + 1)/2;
        const int xpos  = (basex + xdiff + GXM) % GXM;
        for (int ycode = 0; ycode < GYM; ++ycode)
        {
            const int ysign = ((ycode % 2) ? 1 : -1);
            const int ydiff = ysign * (ycode + 1)/2;
            const int ypos  = (basey + ydiff + GYM) % GYM;
            // note that due to the wrapping above, we can't just use
            // xdiff*xdiff + ydiff*ydiff
            const int dist = (xpos-basex)*(xpos-basex) +
                (ypos-basey)*(ypos-basey);
            if (grd[xpos][ypos] == stair_to_find)
            {
                found++;
                if (find_closest && dist < best_dist)
                {
                    best_dist = dist;
                    result.x = xpos;
                    result.y = ypos;
                }
                else if (one_chance_in( found ))
                {
                    result.x = xpos;
                    result.y = ypos;
                }
            }
        }
    }
    if ( found )
        return result;
    best_dist = 1 + GXM*GXM + GYM*GYM;
    // Second pass: find a staircase in the proper direction
    for (int xcode = 0; xcode < GXM; ++xcode )
    {
        const int xsign = ((xcode % 2) ? 1 : -1);
        const int xdiff = xsign * (xcode + 1)/2;
        const int xpos  = (basex + xdiff + GXM) % GXM;
        for (int ycode = 0; ycode < GYM; ++ycode)
        {
            const int ysign = ((ycode % 2) ? 1 : -1);
            const int ydiff = ysign * (ycode + 1)/2;
            const int ypos  = (basey + ydiff + GYM) % GYM;
            bool good_stair;
            const int looking_at = grd[xpos][ypos];
            if (stair_to_find <= DNGN_ROCK_STAIRS_DOWN )
                good_stair =
                    (looking_at >= DNGN_STONE_STAIRS_DOWN_I) &&
                    (looking_at <= DNGN_ROCK_STAIRS_DOWN);
            else
                good_stair =
                    (looking_at >= DNGN_STONE_STAIRS_UP_I) &&
                    (looking_at <= DNGN_ROCK_STAIRS_UP);
            const int dist = (xpos-basex)*(xpos-basex) +
                (ypos-basey)*(ypos-basey);
            if ( good_stair )
            {
                found++;
                if (find_closest && dist < best_dist)
                {
                    best_dist = dist;
                    result.x = xpos;
                    result.y = ypos;
                }
                else if (one_chance_in( found ))
                {
                    result.x = xpos;
                    result.y = ypos;
                }
            }
        }
    }
    if ( found )
        return result;
    // Third pass: look for any clear terrain (shouldn't happen).
    // We abandon the idea of looking nearby now.
    for (int xpos = 0; xpos < GXM; xpos++)
    {
        for (int ypos = 0; ypos < GYM; ypos++)
        {
            if (grd[xpos][ypos] >= DNGN_FLOOR)
            {
                found++;
                if (one_chance_in( found ))
                {
                    result.x = xpos;
                    result.y = ypos;
                }
            }
        }
    }
    ASSERT( found );
    return result;
}
static void sanity_test_monster_inventory()
{
    // Sanity forcing of monster inventory items (required?)
    for (int i = 0; i < MAX_MONSTERS; i++)
    {
        if (menv[i].type == -1)
            continue;
        for (int j = 0; j < NUM_MONSTER_SLOTS; j++)
        {
            if (menv[i].inv[j] == NON_ITEM)
                continue;
            // items carried by monsters shouldn't be linked
            if (mitm[menv[i].inv[j]].link != NON_ITEM)
                mitm[menv[i].inv[j]].link = NON_ITEM;
        }
    }
}
static void fixup_pandemonium_stairs()

Replacement in crawl-ref/source/files.cc at line 700 [4.3084589]

B:BD[4.3091534] → [4.3091534:3091590]

    int j = 0;
    int i = 0, count_x = 0, count_y = 0;

[4.3091534]

[4.3091623]

    for (int i = 0; i < GXM; i++)
    {
        for (int j = 0; j < GYM; j++)
        {
            if (grd[i][j] >= DNGN_STONE_STAIRS_UP_I
                && grd[i][j] <= DNGN_ROCK_STAIRS_UP)
            {
                if (one_chance_in( you.mutation[MUT_PANDEMONIUM] ? 5 : 50 ))
                    grd[i][j] = DNGN_EXIT_PANDEMONIUM;
                else
                    grd[i][j] = DNGN_FLOOR;
            }
            
            if (grd[i][j] >= DNGN_ENTER_LABYRINTH
                && grd[i][j] <= DNGN_ROCK_STAIRS_DOWN)
            {
                grd[i][j] = DNGN_TRANSIT_PANDEMONIUM;
            }
        }
    }
}
static void place_player_on_stair(branch_type old_branch, int stair_taken)
{
    bool find_first = true;
    // Order is important here:
    if (you.level_type == LEVEL_DUNGEON 
        && old_branch == BRANCH_VESTIBULE_OF_HELL
        && stair_taken == DNGN_STONE_STAIRS_UP_I)
    {
        // leaving hell - look for entry portal first
        stair_taken = DNGN_ENTER_HELL;
        find_first = false;
    }
    else if (stair_taken == DNGN_EXIT_PANDEMONIUM)
    {
        stair_taken = DNGN_ENTER_PANDEMONIUM;
        find_first = false;
    }
    else if (stair_taken == DNGN_EXIT_ABYSS)
    {
        stair_taken = DNGN_ENTER_ABYSS;
        find_first = false;
    }
    else if (stair_taken == DNGN_ENTER_HELL 
             || stair_taken == DNGN_ENTER_LABYRINTH)
    {
        // the vestibule and labyrith always start from this stair
        stair_taken = DNGN_STONE_STAIRS_UP_I;
    }
    else if (stair_taken >= DNGN_STONE_STAIRS_DOWN_I 
             && stair_taken <= DNGN_ROCK_STAIRS_DOWN)
    {
        // look for coresponding up stair
        stair_taken += (DNGN_STONE_STAIRS_UP_I - DNGN_STONE_STAIRS_DOWN_I);
    }
    else if (stair_taken >= DNGN_STONE_STAIRS_UP_I 
             && stair_taken <= DNGN_ROCK_STAIRS_UP)
    {
        // look for coresponding down stair
        stair_taken += (DNGN_STONE_STAIRS_DOWN_I - DNGN_STONE_STAIRS_UP_I);
    }
    else if (stair_taken >= DNGN_RETURN_FROM_ORCISH_MINES 
             && stair_taken < 150) // 20 slots reserved
    {
            // find entry point to subdungeon when leaving
        stair_taken += (DNGN_ENTER_ORCISH_MINES - DNGN_RETURN_FROM_ORCISH_MINES);
    }
    else if (stair_taken >= DNGN_ENTER_ORCISH_MINES
             && stair_taken < DNGN_RETURN_FROM_ORCISH_MINES)
    {
        // find exit staircase from subdungeon when entering 
        stair_taken += (DNGN_RETURN_FROM_ORCISH_MINES - DNGN_ENTER_ORCISH_MINES);
    }
    else if (stair_taken >= DNGN_ENTER_DIS 
             && stair_taken <= DNGN_TRANSIT_PANDEMONIUM)
    {
        // when entering a hell or pandemonium
        stair_taken = DNGN_STONE_STAIRS_UP_I;
    }
    else // Note: stair_taken can equal things like DNGN_FLOOR
    {
        // just find a nice empty square
        stair_taken = DNGN_FLOOR;
        find_first = false;
    }
    
    const coord_def where_to_go = find_nearby_stair(stair_taken, find_first);
    you.x_pos = where_to_go.x;
    you.y_pos = where_to_go.y;
}
static void close_level_gates()
{
    for ( int i = 0; i < GXM; ++i )
    {
        for ( int j = 0; j < GYM; ++j )
        {
            if (you.char_direction == DIR_ASCENDING
                && you.level_type != LEVEL_PANDEMONIUM)
            {
                if (grd[i][j] == DNGN_ENTER_HELL
                    || grd[i][j] == DNGN_ENTER_ABYSS
                    || grd[i][j] == DNGN_ENTER_PANDEMONIUM)
                {
                    grd[i][j] = DNGN_STONE_ARCH;
                }
            }
        }
    }
}
static void clear_env_map()
{
    for (int i = 0; i < GXM; i++)
    {
        for (int j = 0; j < GYM; j++)
        {
            env.map[i][j] = 0;
            env.map_col[i][j].clear();
        }
    }
}
static void clear_clouds()
{
    for (int i = 0; i < GXM; i++)
        for (int j = 0; j < GYM; j++)
            env.cgrid[i][j] = EMPTY_CLOUD;
}
static void grab_followers(std::vector<follower>& followers)
{
    for (int i = you.x_pos - 1; i < you.x_pos + 2; i++)
    {
        for (int j = you.y_pos - 1; j < you.y_pos + 2; j++)
        {
            if (i == you.x_pos && j == you.y_pos)
                continue;
            if (mgrd[i][j] == NON_MONSTER)
                continue;
            monsters *fmenv = &menv[mgrd[i][j]];
            if (fmenv->type == MONS_PLAYER_GHOST
                && fmenv->hit_points < fmenv->max_hit_points / 2)
            {
                mpr("The ghost fades into the shadows.");
                monster_teleport(fmenv, true);
                continue;
            }
            // monster has to be already tagged in order to follow:
            if (!testbits( fmenv->flags, MF_TAKING_STAIRS ))
                continue;
#if DEBUG_DIAGNOSTICS
            mprf( "%s is following.", ptr_monam( fmenv, DESC_CAP_THE ) );
#endif
            follower f(*fmenv);
            followers.push_back(f);
            fmenv->destroy_inventory();
            monster_cleanup(fmenv);
        }
    }
}

Insertion in crawl-ref/source/files.cc at line 870 [4.3084589]

[4.3091624]

[6.865861]

void load( int stair_taken, load_mode_type load_mode, bool was_a_labyrinth,
           int old_level, branch_type old_branch )
{

Deletion in crawl-ref/source/files.cc at line 874 [4.3084589]
∅:D[6.865898] → [4.3091832:3091833]
B:BD[4.3091832] → [4.3091832:3091833]
B:BD[4.3092186] → [4.3092186:3092199]
```
    int val;
```
Insertion in crawl-ref/source/files.cc at line 899 [4.3084589]
[4.3093055]
[4.3093055]
```
        // XXX XXX FIXME shouldn't this just go into clear_clouds()?
```

Replacement in crawl-ref/source/files.cc at line 909 [4.3084589]

B:BD[4.3093312] → [4.3093312:3093610]

        // grab followers
        for (count_x = you.x_pos - 1; count_x < you.x_pos + 2; count_x++)
        {
            for (count_y = you.y_pos - 1; count_y < you.y_pos + 2; count_y++)
            {
                if (count_x == you.x_pos && count_y == you.y_pos)
                    continue;

[4.3093312]

[4.3093684]

        grab_followers(followers);

Deletion in crawl-ref/source/files.cc at line 911 [4.3084589]

B:BD[4.3093685] → [4.3093685:3093775]

B:BD[4.3093775] → [6.866194:866259]

∅:D[6.866259] → [4.3093847:3094341]

B:BD[4.3093847] → [4.3093847:3094341]

B:BD[4.3094341] → [2.3920:3998]

∅:D[2.3998] → [4.3094515:3094523]

B:BD[4.3094515] → [4.3094515:3094523]

B:BD[4.3094523] → [6.866260:866296]

B:BD[4.3095556] → [6.866478:866518]

B:BD[6.866518] → [7.14949:14993]

∅:D[7.14993] → [6.866518:866558]

B:BD[6.866518] → [6.866518:866558]

∅:D[6.866558] → [4.3096361:3096438]

B:BD[4.3096361] → [4.3096361:3096438]

                if (mgrd[count_x][count_y] == NON_MONSTER)
                    continue;
                monsters *fmenv = &menv[mgrd[count_x][count_y]];
                if (fmenv->type == MONS_PLAYER_GHOST
                    && fmenv->hit_points < fmenv->max_hit_points / 2)
                {
                    mpr("The ghost fades into the shadows.");
                    monster_teleport(fmenv, true);
                    continue;
                }
                // monster has to be already tagged in order to follow:
                if (!testbits( fmenv->flags, MF_TAKING_STAIRS ))
                    continue;
#if DEBUG_DIAGNOSTICS
                mprf( "%s is following.", ptr_monam( fmenv, DESC_CAP_THE ) );
#endif
                follower f(*fmenv);
                followers.push_back(f);
                fmenv->destroy_inventory();
                monster_cleanup(fmenv);
            }
        }                        // end of grabbing followers

Replacement in crawl-ref/source/files.cc at line 912 [4.3084589]

B:BD[4.3096468] → [2.3999:4068]

            save_level( old_level, LEVEL_DUNGEON, where_were_you2 );

[4.3096468]

[4.3096529]

            save_level( old_level, LEVEL_DUNGEON, old_branch );

Replacement in crawl-ref/source/files.cc at line 963 [4.3084589]

B:BD[4.3098144] → [4.3098144:3098260]

B:BD[4.3098260] → [8.2964:2978]

∅:D[8.2978] → [4.3098260:3098295]

B:BD[4.3098260] → [4.3098260:3098295]

B:BD[4.3098295] → [8.2979:3036]

    for (i = 0; i < GXM; i++)
    {
        for (j = 0; j < GYM; j++)
        {
            if (just_created_level)
            {
                env.map[i][j] = 0;
                env.map_col[i][j].clear();
            }

[4.3098144]

[4.3098295]

    if (you.char_direction == DIR_ASCENDING &&
        you.level_type != LEVEL_PANDEMONIUM)
        close_level_gates();

Replacement in crawl-ref/source/files.cc at line 967 [4.3084589]

B:BD[4.3098296] → [4.3098296:3098679]

            if (you.char_direction == DIR_ASCENDING
                && you.level_type != LEVEL_PANDEMONIUM)
            {
                if (grd[i][j] == DNGN_ENTER_HELL
                    || grd[i][j] == DNGN_ENTER_ABYSS
                    || grd[i][j] == DNGN_ENTER_PANDEMONIUM)
                {
                    grd[i][j] = DNGN_STONE_ARCH;
                }
            }

[4.3098296]

[4.3098679]

    if (just_created_level)
        clear_env_map();

Replacement in crawl-ref/source/files.cc at line 970 [4.3084589]

B:BD[4.3098680] → [4.3098680:3098791]

            if (load_mode != LOAD_RESTART_GAME)
                env.cgrid[i][j] = EMPTY_CLOUD;
        }
    }

[4.3098680]

[4.3098791]

    if (load_mode != LOAD_RESTART_GAME)
        clear_clouds();

Deletion in crawl-ref/source/files.cc at line 973 [4.3084589]

B:BD[4.3098792] → [4.3098792:3098892]

    // This next block is for cases where we want to look for a stairs 
    // to place the player.

Replacement in crawl-ref/source/files.cc at line 975 [4.3084589]

B:BD[4.3098971] → [4.3098971:3099208]

B:BD[4.3099208] → [9.10866:10924]

∅:D[9.10924] → [4.3099265:3104402]

B:BD[4.3099265] → [4.3099265:3104402]

        bool find_first = true;
        // Order is important here:
        if (you.level_type == LEVEL_DUNGEON 
            && where_were_you2 == BRANCH_VESTIBULE_OF_HELL
            && stair_taken == DNGN_STONE_STAIRS_UP_I)
        {
            // leaving hell - look for entry portal first
            stair_taken = DNGN_ENTER_HELL;
            find_first = false;
        }
        else if (stair_taken == DNGN_EXIT_PANDEMONIUM)
        {
            stair_taken = DNGN_ENTER_PANDEMONIUM;
            find_first = false;
        }
        else if (stair_taken == DNGN_EXIT_ABYSS)
        {
            stair_taken = DNGN_ENTER_ABYSS;
            find_first = false;
        }
        else if (stair_taken == DNGN_ENTER_HELL 
            || stair_taken == DNGN_ENTER_LABYRINTH)
        {
            // the vestibule and labyrith always start from this stair
            stair_taken = DNGN_STONE_STAIRS_UP_I;
        }
        else if (stair_taken >= DNGN_STONE_STAIRS_DOWN_I 
            && stair_taken <= DNGN_ROCK_STAIRS_DOWN)
        {
            // look for coresponding up stair
            stair_taken += (DNGN_STONE_STAIRS_UP_I - DNGN_STONE_STAIRS_DOWN_I);
        }
        else if (stair_taken >= DNGN_STONE_STAIRS_UP_I 
            && stair_taken <= DNGN_ROCK_STAIRS_UP)
        {
            // look for coresponding down stair
            stair_taken += (DNGN_STONE_STAIRS_DOWN_I - DNGN_STONE_STAIRS_UP_I);
        }
        else if (stair_taken >= DNGN_RETURN_FROM_ORCISH_MINES 
            && stair_taken < 150) // 20 slots reserved
        {
            // find entry point to subdungeon when leaving
            stair_taken += (DNGN_ENTER_ORCISH_MINES - DNGN_RETURN_FROM_ORCISH_MINES);
        }
        else if (stair_taken >= DNGN_ENTER_ORCISH_MINES
             && stair_taken < DNGN_RETURN_FROM_ORCISH_MINES)
        {
            // find exit staircase from subdungeon when entering 
            stair_taken += (DNGN_RETURN_FROM_ORCISH_MINES - DNGN_ENTER_ORCISH_MINES);
        }
        else if (stair_taken >= DNGN_ENTER_DIS 
            && stair_taken <= DNGN_TRANSIT_PANDEMONIUM)
        {
            // when entering a hell or pandemonium
            stair_taken = DNGN_STONE_STAIRS_UP_I;
        }
        else // Note: stair_taken can equal things like DNGN_FLOOR
        {
            // just find a nice empty square
            stair_taken = DNGN_FLOOR;
            find_first = false;
        }
        int found = 0;
        int x_pos = 0, y_pos = 0;
        // Start by looking for the expected entry point:
        for (count_x = 0; count_x < GXM; count_x++)
        {
            for (count_y = 0; count_y < GYM; count_y++)
            {
                if (grd[count_x][count_y] == stair_taken)
                {
                    found++;
                    if (one_chance_in( found ))
                    {
                        x_pos = count_x;
                        y_pos = count_y;
                    }
                    if (find_first)
                        goto found_stair;  // double break
                }
            }
        }
found_stair:
        if (!found)
        {
            // See if we can find a stairway in the "right" direction:
            for (count_x = 0; count_x < GXM; count_x++)
            {
                for (count_y = 0; count_y < GYM; count_y++)
                {
                    if (stair_taken <= DNGN_ROCK_STAIRS_DOWN)
                    {
                        // looking for any down stairs
                        if (grd[count_x][count_y] >= DNGN_STONE_STAIRS_DOWN_I
                            && grd[count_x][count_y] <= DNGN_ROCK_STAIRS_DOWN)
                        {
                            found++;
                            if (one_chance_in( found ))
                            {
                                x_pos = count_x;
                                y_pos = count_y;
                            }
                        }
                    }
                    else 
                    {
                        // looking for any up stairs
                        if (grd[count_x][count_y] >= DNGN_STONE_STAIRS_UP_I
                            && grd[count_x][count_y] <= DNGN_ROCK_STAIRS_UP)
                        {
                            found++;
                            if (one_chance_in( found ))
                            {
                                x_pos = count_x;
                                y_pos = count_y;
                            }
                        }
                    }
                }
            }
            if (!found)
            {
                // Still not found? Look for any clear terrain:
                for (count_x = 0; count_x < GXM; count_x++)
                {
                    for (count_y = 0; count_y < GYM; count_y++)
                    {
                        if (grd[count_x][count_y] >= DNGN_FLOOR)
                        {
                            found++;
                            if (one_chance_in( found ))
                            {
                                x_pos = count_x;
                                y_pos = count_y;
                            }
                        }
                    }
                }
            }
        }
        // If still not found, the level is very buggy.
        ASSERT( found );
        you.x_pos = x_pos;
        you.y_pos = y_pos;

[4.3098971]

[4.3104402]

        place_player_on_stair(old_branch, stair_taken);

Replacement in crawl-ref/source/files.cc at line 989 [4.3084589]
B:BD[4.3104987] → [4.3104987:3105039]
```
            || you.level_type == LEVEL_PANDEMONIUM)
```
[4.3104987]
[4.3105039]
```
         || you.level_type == LEVEL_PANDEMONIUM)
```

Deletion in crawl-ref/source/files.cc at line 1004 [4.3084589]

B:BD[4.3108935] → [4.3108935:3109096]


    // Sanity forcing of monster inventory items (required?)
    for (i = 0; i < MAX_MONSTERS; i++)
    {
        if (menv[i].type == -1)
            continue;

Replacement in crawl-ref/source/files.cc at line 1005 [4.3084589]

B:BD[4.3109097] → [4.3109097:3109415]

        for (j = 0; j < NUM_MONSTER_SLOTS; j++)
        {
            if (menv[i].inv[j] == NON_ITEM)
                continue;
            /* items carried by monsters shouldn't be linked */
            if (mitm[menv[i].inv[j]].link != NON_ITEM)
                mitm[menv[i].inv[j]].link = NON_ITEM;
        }
    }

[4.3109097]

[4.3109415]

    sanity_test_monster_inventory();

Replacement in crawl-ref/source/files.cc at line 1009 [4.3084589]

B:BD[4.3109509] → [4.3109509:3110331]

    {
        for (count_x = 0; count_x < GXM; count_x++)
        {
            for (count_y = 0; count_y < GYM; count_y++)
            {
                if (grd[count_x][count_y] >= DNGN_STONE_STAIRS_UP_I
                    && grd[count_x][count_y] <= DNGN_ROCK_STAIRS_UP)
                {
                    if (one_chance_in( you.mutation[MUT_PANDEMONIUM] ? 5 : 50 ))
                        grd[count_x][count_y] = DNGN_EXIT_PANDEMONIUM;
                    else
                        grd[count_x][count_y] = DNGN_FLOOR;
                }
                if (grd[count_x][count_y] >= DNGN_ENTER_LABYRINTH
                    && grd[count_x][count_y] <= DNGN_ROCK_STAIRS_DOWN)
                {
                    grd[count_x][count_y] = DNGN_TRANSIT_PANDEMONIUM;
                }
            }
        }
    }

[4.3109509]

[4.3110331]

        fixup_pandemonium_stairs();

Replacement in crawl-ref/source/files.cc at line 1019 [4.3084589]

B:BD[4.3110618] → [4.3110618:3110695]

        val = ((you.species != SP_CENTAUR) ? player_movement_speed() : 15);

[4.3110618]

[4.3110695]

        int timeval = ((you.species != SP_CENTAUR) ? player_movement_speed()
                                                   : 15);

Replacement in crawl-ref/source/files.cc at line 1024 [4.3084589]
B:BD[4.3110776] → [4.3110776:3110798]
```
            val /= 2;
```
[4.3110776]
[4.3110798]
```
            timeval /= 2;
```

Replacement in crawl-ref/source/files.cc at line 1026 [4.3084589]

B:BD[4.3110799] → [4.3110799:3110874]

        val -= (stepdown_value( check_stealth(), 50, 50, 150, 150 ) / 10);

[4.3110799]

[4.3110874]

        timeval -= (stepdown_value( check_stealth(), 50, 50, 150, 150 ) / 10);

Replacement in crawl-ref/source/files.cc at line 1029 [4.3084589]

B:BD[4.3110897] → [3.20427:20486]

        mprf(MSGCH_DIAGNOSTICS, "arrival time: %d", val );

[4.3110897]

[4.3111000]

        mprf(MSGCH_DIAGNOSTICS, "arrival time: %d", timeval );

Replacement in crawl-ref/source/files.cc at line 1032 [4.3084589]
B:BD[4.3111008] → [4.3111008:3111029]
```
        if (val > 0)
```
[4.3111008]
[4.3111029]
```
        if (timeval > 0)
```
Replacement in crawl-ref/source/files.cc at line 1034 [4.3084589]
B:BD[4.3111039] → [4.3111039:3111073]
```
            you.time_taken = val;
```
[4.3111039]
[4.3111073]
```
            you.time_taken = timeval;
```