fiddlerwoaroof/crawl - Change R25VQ2MUGGDTO5UZR2DPO5XUYSA3LB6RIEBGLJ6CD75T2GED2ZNAC

Fix closing/opening doors not prompting if there are several adjacent

doors. Also, confusion is now handled more consistently.

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

Created by j-p-e-g on July 14, 2009

R25VQ2MUGGDTO5UZR2DPO5XUYSA3LB6RIEBGLJ6CD75T2GED2ZNAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/player.cc at line 438 [5.962854]

B:BD[4.2970] → [4.2970:3006]

B:BD[4.3006] → [6.3113:3147]

    // Bats can't close/open doors.
    return !player_in_bat_form();

[4.2970]

[7.2159]

    // Bats and pigs can't open/close doors.
    return (you.attribute[ATTR_TRANSFORMATION] != TRAN_BAT
            && you.attribute[ATTR_TRANSFORMATION] != TRAN_PIG);

Replacement in crawl-ref/source/acr.cc at line 2931 [5.4397395]

B:BD[8.3406] → [9.8460:8535]

// Opens doors and handles some aspects of untrapping. If either move_x or

[8.3406]

[9.8535]

// Handles some aspects of untrapping. Returns false if the target is a
// closed door that will need to be opened.
static bool _untrap_target(const coord_def move, bool check_confused)
{
    const coord_def target = you.pos() + move;
    monsters* mon = monster_at(target);
    if (mon && player_can_hit_monster(mon))
    {
        if (mons_is_caught(mon) && mons_friendly(mon)
            && player_can_open_doors() && !you.confused())
        {
            const std::string prompt =
                make_stringf("Do you want to try to take the net off %s?",
                             mon->name(DESC_NOCAP_THE).c_str());
            if (yesno(prompt.c_str(), true, 'n'))
            {
                remove_net_from(mon);
                return (true);
            }
        }
        you.turn_is_over = true;
        you_attack(mon->mindex(), true);
        if (you.berserk_penalty != NO_BERSERK_PENALTY)
            you.berserk_penalty = 0;
        return (true);
    }
    if (find_trap(target) && grd(target) != DNGN_UNDISCOVERED_TRAP)
    {
        if (!you.confused())
        {
            if (!player_can_open_doors())
            {
                mpr("You can't disarm traps in your present form.");
                return (true);
            }
            if (env.cgrid(target) != EMPTY_CLOUD)
            {
                mpr("You can't get to that trap right now.");
                return (true);
            }
        }
        // If you're confused, you may attempt it and stumble into the trap.
        disarm_trap(target);
        return (true);
    }
    const dungeon_feature_type feat = grd(target);
    if (!grid_is_closed_door(feat) || you.confused())
    {
        switch (feat)
        {
        case DNGN_OPEN_DOOR:
            _close_door(move); // for convenience
            return (true);
        default:
            mpr("You swing at nothing.");
            make_hungry(3, true);
            you.turn_is_over = true;
            return (true);
        }
    }
    // Else it's a closed door and needs further handling.
    return (false);
}
// Opens doors and . If either move_x or

Deletion in crawl-ref/source/acr.cc at line 3009 [5.4397395]
B:BD[10.5906] → [10.5906:5907]
B:BD[10.5907] → [4.7453:7487]
∅:D[4.7487] → [11.3335:3422]
B:BD[11.3335] → [11.3335:3422]
```
    if (!player_can_open_doors())
    {
        mpr("You can't open doors in your present form.");
        return;
    }
```

Replacement in crawl-ref/source/acr.cc at line 3017 [5.4397395]

B:BD[5.4464655] → [8.3410:3462]

B:BD[8.3462] → [12.3972:4035]

    // If there's only one door to open, don't ask.
    if ((!check_confused || !you.confused()) && move.origin())

[5.4464655]

[8.3547]

    // The player used Ctrl + dir or a variant thereof.
    if (!move.origin())

Replacement in crawl-ref/source/acr.cc at line 3020 [5.4397395]

B:BD[8.3553] → [3.6691:6818]

        if (_check_adjacent(DNGN_CLOSED_DOOR, move) == 0
            && _check_adjacent(DNGN_DETECTED_SECRET_DOOR, move) == 0)

[8.3553]

[8.3621]

        if (check_confused && you.confused() && !one_chance_in(3))

Replacement in crawl-ref/source/acr.cc at line 3022 [5.4397395]

B:BD[8.3631] → [8.3631:3696]

            mpr("There's nothing to open.");
            return;

[8.3631]

[8.3696]

            do
            {
                move.x = random2(3) - 1;
                move.y = random2(3) - 1;
            }
            while (move.origin());

Insertion in crawl-ref/source/acr.cc at line 3029 [5.4397395]

[8.3706]

        if (_untrap_target(move, check_confused))
            return;

Replacement in crawl-ref/source/acr.cc at line 3033 [5.4397395]

B:BD[8.3713] → [12.4036:4099]

    if (check_confused && you.confused() && !one_chance_in(3))

[8.3713]

[13.1279467]

    // If we get here, the player either hasn't picked a direction yet
    // or the chosen direction actually contains a closed door.
    if (!player_can_open_doors())

Replacement in crawl-ref/source/acr.cc at line 3038 [5.4397395]

B:BD[13.1279473] → [14.107003:107069]

        move.x = random2(3) - 1;
        move.y = random2(3) - 1;

[13.1279473]

[13.1279539]

        mpr("You can't open doors in your present form.");
        return;

Deletion in crawl-ref/source/acr.cc at line 3043 [5.4397395]
B:BD[14.107090] → [14.107090:107141]
```
    door_move.delta = move;
    coord_def doorpos;
```
Replacement in crawl-ref/source/acr.cc at line 3044 [5.4397395]
B:BD[5.4464710] → [14.107142:107166]
```
    if (!move.origin())
```
[5.4464710]
[5.4464736]
```
    // The player hasn't picked a direction yet.
    if (move.origin())
```

Replacement in crawl-ref/source/acr.cc at line 3047 [5.4397395]

B:BD[5.4464742] → [14.107167:107203]

∅:D[14.107203] → [5.4464831:4464832]

B:BD[5.4464831] → [5.4464831:4464832]

B:BD[5.4464832] → [15.15321:15366]

        doorpos = you.pos() + move;
        monsters* mon = monster_at(doorpos);

[5.4464742]

[5.4464870]

        const int num = _check_adjacent(DNGN_CLOSED_DOOR, move)
                        + _check_adjacent(DNGN_DETECTED_SECRET_DOOR, move);

Replacement in crawl-ref/source/acr.cc at line 3050 [5.4397395]
B:BD[5.4464871] → [15.15367:15415]
```
        if (mon && player_can_hit_monster(mon))
```
[5.4464871]
[5.4464951]
```
        if (num == 0)
```

Replacement in crawl-ref/source/acr.cc at line 3052 [5.4397395]

B:BD[5.4464961] → [15.15416:15453]

∅:D[15.15453] → [16.27110:27124]

B:BD[16.27110] → [16.27110:27124]

B:BD[16.27124] → [15.15454:15645]

∅:D[15.15645] → [16.27323:27396]

B:BD[16.27323] → [16.27323:27396]

B:BD[16.27396] → [15.15646:15688]

∅:D[15.15688] → [16.27445:27507]

B:BD[16.27445] → [16.27445:27507]

B:BD[5.4465005] → [13.1279547:1279584]

B:BD[13.1279584] → [15.15689:15734]

∅:D[15.15734] → [5.4465039:4465141]

∅:D[17.17681] → [5.4465039:4465141]

∅:D[14.107289] → [5.4465039:4465141]

∅:D[13.1279584] → [5.4465039:4465141]

B:BD[5.4465039] → [5.4465039:4465141]

            if (mons_is_caught(mon))
            {
                const std::string prompt =
                    make_stringf("Do you want to try to take the net off %s?",
                                 mon->name(DESC_NOCAP_THE).c_str());
                if (yesno(prompt.c_str(), true, 'n'))
                {
                    remove_net_from(mon);
                    return;
                }
            }
            you.turn_is_over = true;
            you_attack(mon->mindex(), true);
            if (you.berserk_penalty != NO_BERSERK_PENALTY)
                you.berserk_penalty = 0;

[5.4464961]

[5.4465141]

            mpr("There's nothing to open nearby.");

Replacement in crawl-ref/source/acr.cc at line 3056 [5.4397395]

B:BD[5.4465172] → [18.28403:28477]

        if (find_trap(doorpos) && grd(doorpos) != DNGN_UNDISCOVERED_TRAP)

[5.4465172]

[5.4465253]

        // If there's only one door to open, don't ask.
        if (num == 1)
            door_move.delta = move;
        else

Replacement in crawl-ref/source/acr.cc at line 3061 [5.4397395]

B:BD[5.4465263] → [14.107390:107441]

∅:D[14.107441] → [5.4465313:4465389]

B:BD[5.4465313] → [5.4465313:4465389]

            if (env.cgrid(doorpos) != EMPTY_CLOUD)
            {
                mpr("You can't get to that trap right now.");

[5.4465263]

[5.4465389]

            mpr("Which direction? ", MSGCH_PROMPT);
            direction(door_move, DIR_DIR);
            if (!door_move.isValid)

Deletion in crawl-ref/source/acr.cc at line 3066 [5.4397395]
B:BD[5.4465413] → [5.4465413:4465428]
B:BD[5.4465428] → [18.28478:28512]
∅:D[18.28512] → [5.4465464:4465484]
B:BD[5.4465464] → [5.4465464:4465484]
```
            }
            disarm_trap(doorpos);
            return;
```

Insertion in crawl-ref/source/acr.cc at line 3069 [5.4397395]

[19.17993]

[5.4465512]

        door_move.delta = move;
    if (check_confused && you.confused() && !one_chance_in(3))

Replacement in crawl-ref/source/acr.cc at line 3073 [5.4397395]

B:BD[5.4465518] → [2.5219:5306]

        mpr("Which direction? ", MSGCH_PROMPT);
        direction(door_move, DIR_DIR);

[5.4465518]

[14.107442]

        do
        {
            door_move.delta.x = random2(3) - 1;
            door_move.delta.y = random2(3) - 1;
        }
        while (door_move.delta.origin());
    }
    ASSERT(door_move.isValid);

Replacement in crawl-ref/source/acr.cc at line 3082 [5.4397395]

∅:D[14.107443] → [5.4465606:4465658]

B:BD[5.4465606] → [5.4465606:4465658]

        if (!door_move.isValid)
            return;

[14.107443]

[5.4465658]

    // We got a valid direction.
    const coord_def doorpos = you.pos() + door_move.delta;
    const dungeon_feature_type feat = (in_bounds(doorpos) ? grd(doorpos)
                                                          : DNGN_UNSEEN);

Replacement in crawl-ref/source/acr.cc at line 3087 [5.4397395]

B:BD[5.4465659] → [14.107444:107491]

∅:D[14.107491] → [20.322:323]

B:BD[5.4465760] → [20.322:323]

B:BD[20.323] → [19.17994:18036]

B:BD[19.18036] → [14.107492:107554]

B:BD[14.107554] → [3.6819:6859]

        doorpos = you.pos() + door_move.delta;
        const dungeon_feature_type feat =
            in_bounds(doorpos) ? grd(doorpos) : DNGN_UNSEEN;
        if (!grid_is_closed_door(feat))

[5.4465659]

[20.390]

    if (!grid_is_closed_door(feat))
    {
        if (you.confused())

Replacement in crawl-ref/source/acr.cc at line 3091 [5.4397395]

B:BD[20.400] → [21.65943:65983]

∅:D[21.65983] → [22.4387:4491]

B:BD[22.4387] → [22.4387:4491]

B:BD[22.4491] → [23.3853:3946]

∅:D[23.3946] → [22.4568:4582]

B:BD[22.4568] → [22.4568:4582]

∅:D[22.4582] → [20.445:479]

B:BD[20.445] → [20.445:479]

            switch (feat)
            {
            case DNGN_OPEN_DOOR:
                mpr("It's already open!"); break;
            default:
                mpr("There isn't anything that you can open there!");
                break;
            }
            // Don't lose a turn.

[20.400]

[20.479]

            mpr("You swing at nothing.");
            make_hungry(3, true);
            you.turn_is_over = true;

Insertion in crawl-ref/source/acr.cc at line 3096 [5.4397395]

[20.509]

[5.4465760]

        switch (feat)
        {
        case DNGN_OPEN_DOOR:
            mpr("It's already open!");
            break;
        default:
            mpr("There isn't anything that you can open there!");
            break;
        }
        // Don't lose a turn.
        return;

Replacement in crawl-ref/source/acr.cc at line 3109 [5.4397395]

B:BD[5.4465767] → [3.6860:6903]

∅:D[3.6903] → [5.4465808:4465814]

∅:D[14.107597] → [5.4465808:4465814]

B:BD[5.4465808] → [5.4465808:4465814]

B:BD[5.4465814] → [24.3241:3279]

B:BD[24.3279] → [14.107598:107654]

∅:D[14.107654] → [25.3665:3723]

B:BD[25.3665] → [25.3665:3723]

∅:D[25.3723] → [22.4658:4750]

B:BD[22.4658] → [22.4658:4750]

    if (grid_is_closed_door(grd(doorpos)))
    {
        std::set<coord_def> all_door;
        find_connected_range(doorpos, DNGN_CLOSED_DOOR,
                             DNGN_SECRET_DOOR, all_door);
        const char *adj, *noun;
        get_door_description(all_door.size(), &adj, &noun);

[5.4465767]

[19.18037]

    // Finally, open the closed door!
    std::set<coord_def> all_door;
    find_connected_range(doorpos, DNGN_CLOSED_DOOR, DNGN_SECRET_DOOR, all_door);
    const char *adj, *noun;
    get_door_description(all_door.size(), &adj, &noun);

Replacement in crawl-ref/source/acr.cc at line 3115 [5.4397395]

B:BD[19.18038] → [14.107655:107756]

        int skill = you.dex +
            (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;

[19.18038]

[5.4465903]

    int skill = you.dex
                + (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;

Replacement in crawl-ref/source/acr.cc at line 3118 [5.4397395]

B:BD[5.4465904] → [26.2997:3048]

B:BD[26.3048] → [27.25083:25136]

B:BD[27.25136] → [28.12772:12809]

∅:D[28.12809] → [22.4818:4875]

B:BD[22.4818] → [22.4818:4875]

∅:D[24.3476] → [26.3141:3172]

∅:D[22.4889] → [26.3141:3172]

B:BD[26.3141] → [26.3141:3172]

B:BD[26.3172] → [29.4309:4412]

B:BD[29.4412] → [30.65381:65419]

∅:D[29.4461] → [26.3280:3304]

∅:D[30.65419] → [26.3280:3304]

B:BD[26.3280] → [26.3280:3304]

B:BD[26.3304] → [30.65420:65483]

∅:D[26.3378] → [5.4465973:4465983]

∅:D[30.65483] → [5.4465973:4465983]

B:BD[5.4465973] → [5.4465973:4465983]

B:BD[5.4465983] → [29.4462:4564]

B:BD[29.4564] → [30.65484:65518]

∅:D[29.4609] → [5.4466092:4466102]

∅:D[30.65518] → [5.4466092:4466102]

B:BD[5.4466092] → [5.4466092:4466102]

        if (you.duration[DUR_BERSERKER])
        {
            // XXX: Better flavour for larger doors?
            if (silenced(you.pos()))
                mprf("The %s%s flies open!", adj, noun);
            else
            {
                mprf(MSGCH_SOUND, "The %s%s flies open with a bang!",
                     adj, noun);
                noisy(15, you.pos());
            }
        }
        else if (one_chance_in(skill) && !silenced(you.pos()))
        {
            mprf(MSGCH_SOUND, "As you open the %s%s, it creaks loudly!",
                 adj, noun);
            noisy(10, you.pos());
        }

[5.4465904]

[5.4466102]

    if (you.duration[DUR_BERSERKER])
    {
        // XXX: Better flavour for larger doors?
        if (silenced(you.pos()))
            mprf("The %s%s flies open!", adj, noun);

Replacement in crawl-ref/source/acr.cc at line 3125 [5.4397395]

B:BD[5.4466125] → [14.107757:107859]

∅:D[14.107859] → [22.5035:5092]

B:BD[24.3746] → [22.5035:5092]

            const char* verb =
                player_is_airborne() ? "reach down and open" : "open";
            mprf( "You %s the %s%s.", verb, adj, noun );

[5.4466125]

[5.4466269]

            mprf(MSGCH_SOUND, "The %s%s flies open with a bang!", adj, noun);
            noisy(15, you.pos());

Insertion in crawl-ref/source/acr.cc at line 3128 [5.4397395]

[5.4466279]

    }
    else if (one_chance_in(skill) && !silenced(you.pos()))
    {
        mprf(MSGCH_SOUND, "As you open the %s%s, it creaks loudly!",
             adj, noun);
        noisy(10, you.pos());
    }
    else
    {
        const char* verb = (player_is_airborne() ? "reach down and open"
                                                 : "open");
        mprf("You %s the %s%s.", verb, adj, noun);
    }

Replacement in crawl-ref/source/acr.cc at line 3142 [5.4397395]

B:BD[5.4466280] → [25.3724:3758]

B:BD[25.3758] → [31.3823:3864]

∅:D[25.3758] → [24.3797:3901]

∅:D[31.3864] → [24.3797:3901]

B:BD[5.4466280] → [24.3797:3901]

        bool seen_secret = false;
        std::vector<coord_def> excludes;
        for (std::set<coord_def>::iterator i = all_door.begin();
             i != all_door.end(); ++i)

[5.4466280]

[24.3901]

    bool seen_secret = false;
    std::vector<coord_def> excludes;
    for (std::set<coord_def>::iterator i = all_door.begin();
         i != all_door.end(); ++i)
    {
        const coord_def& dc = *i;
        // Even if some of the door is out of LOS, we want the entire
        // door to be updated.  Hitting this case requires a really big
        // door!
        if (is_terrain_seen(dc))

Replacement in crawl-ref/source/acr.cc at line 3153 [5.4397395]

B:BD[24.3911] → [24.3911:3949]

B:BD[24.3995] → [32.2733:2904]

B:BD[32.2962] → [32.2962:2999]

B:BD[32.2999] → [33.2781:2795]

B:BD[33.2795] → [14.107860:107912]

            const coord_def& dc = *i;
            // Even if some of the door is out of LOS, we want the entire
            // door to be updated.  Hitting this case requires a really big
            // door!
            if (is_terrain_seen(dc))
            {
                set_envmap_obj(dc, DNGN_OPEN_DOOR);

[24.3911]

[33.2796]

            set_envmap_obj(dc, DNGN_OPEN_DOOR);

Replacement in crawl-ref/source/acr.cc at line 3155 [5.4397395]

B:BD[33.2812] → [34.4993:5051]

                env.tile_bk_bg(dc) = TILE_DNGN_OPEN_DOOR;

[33.2812]

[33.2881]

            env.tile_bk_bg(dc) = TILE_DNGN_OPEN_DOOR;

Replacement in crawl-ref/source/acr.cc at line 3157 [5.4397395]

B:BD[33.2888] → [30.65519:65584]

∅:D[30.65584] → [25.3832:3938]

B:BD[25.3832] → [25.3832:3938]

B:BD[25.3938] → [30.65585:65644]

∅:D[30.65644] → [25.4005:4223]

B:BD[25.4005] → [25.4005:4223]

                if (!seen_secret && grd(dc) == DNGN_SECRET_DOOR)
                {
                    seen_secret = true;
                    dungeon_feature_type secret
                        = grid_secret_door_appearance(dc);
                    mprf("That %s was a secret door!",
                         feature_description(secret, NUM_TRAPS, false,
                                             DESC_PLAIN, false).c_str());
                }

[33.2888]

            if (!seen_secret && grd(dc) == DNGN_SECRET_DOOR)
            {
                seen_secret = true;
                dungeon_feature_type secret
                    = grid_secret_door_appearance(dc);
                mprf("That %s was a secret door!",
                     feature_description(secret, NUM_TRAPS, false,
                                         DESC_PLAIN, false).c_str());

Deletion in crawl-ref/source/acr.cc at line 3166 [5.4397395]

B:BD[33.2902] → [14.107913:107951]

B:BD[14.107951] → [31.3865:3938]

            grd(dc) = DNGN_OPEN_DOOR;
            if (is_excluded(dc))
                excludes.push_back(dc);

Replacement in crawl-ref/source/acr.cc at line 3167 [5.4397395]

B:BD[31.3948] → [31.3948:4148]

∅:D[33.2902] → [24.3995:4005]

∅:D[32.3059] → [24.3995:4005]

∅:D[31.4148] → [24.3995:4005]

∅:D[25.4270] → [24.3995:4005]

∅:D[14.107951] → [24.3995:4005]

B:BD[24.3995] → [24.3995:4005]

∅:D[24.4005] → [13.1279585:1279618]

B:BD[5.4466318] → [13.1279585:1279618]

        if (!excludes.empty())
        {
            mark_all_excludes_non_updated();
            for (unsigned int i = 0; i < excludes.size(); ++i)
                update_exclusion_los(excludes[i]);
        }
        you.turn_is_over = true;

[31.3948]

[5.4466348]

        grd(dc) = DNGN_OPEN_DOOR;
        if (is_excluded(dc))
            excludes.push_back(dc);

Replacement in crawl-ref/source/acr.cc at line 3171 [5.4397395]
B:BD[5.4466354] → [14.107952:108043]
∅:D[23.4046] → [5.4466354:4466363]
∅:D[35.27553] → [5.4466354:4466363]
∅:D[14.108043] → [5.4466354:4466363]
B:BD[5.4466354] → [5.4466354:4466363]
```
    else if (grd(doorpos) == DNGN_OPEN_DOOR)
        _close_door(move); // for convenience
    else
```
[5.4466354]
[5.4466363]
```
    if (!excludes.empty())
```

Replacement in crawl-ref/source/acr.cc at line 3174 [5.4397395]

B:BD[5.4466369] → [5.4466369:4466437]

B:BD[5.4466437] → [13.1279619:1279652]

        mpr("You swing at nothing.");
        make_hungry(3, true);
        you.turn_is_over = true;

[5.4466369]

[5.4466467]

        mark_all_excludes_non_updated();
        for (unsigned int i = 0; i < excludes.size(); ++i)
            update_exclusion_los(excludes[i]);

Insertion in crawl-ref/source/acr.cc at line 3178 [5.4397395]
[5.4466473]
[23.4047]
```
    you.turn_is_over = true;
```
Replacement in crawl-ref/source/acr.cc at line 3184 [5.4397395]
B:BD[5.4466637] → [6.6314:6344]
```
    if (player_in_bat_form())
```
[5.4466637]
[11.3480]
```
    if (!player_can_open_doors())
```
Deletion in crawl-ref/source/acr.cc at line 3197 [5.4397395]
B:BD[14.108105] → [14.108105:108128]
```
    coord_def doorpos;
```

Replacement in crawl-ref/source/acr.cc at line 3198 [5.4397395]

B:BD[8.3715] → [8.3715:3768]

B:BD[8.3768] → [12.4100:4142]

    // If there's only one door to close, don't ask.
    if (!you.confused() && move.origin())

[8.3715]

[8.3824]

    // The player hasn't yet told us a direction.
    if (move.origin())

Insertion in crawl-ref/source/acr.cc at line 3201 [5.4397395]
[8.3830]
[14.108180]
```
        // If there's only one door to close, don't ask.
```

Replacement in crawl-ref/source/acr.cc at line 3205 [5.4397395]

B:BD[8.3929] → [8.3929:3975]

            mpr("There's nothing to close.");

[8.3929]

[8.3975]

            mpr("There's nothing to close nearby.");

Replacement in crawl-ref/source/acr.cc at line 3208 [5.4397395]

B:BD[8.4005] → [14.108238:108282]

        else if (num == 1 && move.origin())

[8.4005]

[8.4055]

        else if (num == 1)
        {
            door_move.delta = move;
        }
        else

Replacement in crawl-ref/source/acr.cc at line 3214 [5.4397395]

B:BD[8.4065] → [8.4065:4140]

            mpr("You can't close doors on yourself!");
            return;

[8.4065]

[8.4140]

            mpr("Which direction? ", MSGCH_PROMPT);
            direction(door_move, DIR_DIR);
            if (!door_move.isValid)
                return;

Insertion in crawl-ref/source/acr.cc at line 3221 [5.4397395]
[8.4156]
[5.4466710]
```
    else
        door_move.delta = move;
```

Replacement in crawl-ref/source/acr.cc at line 3226 [5.4397395]

B:BD[8.4216] → [14.108283:108349]

        move.x = random2(3) - 1;
        move.y = random2(3) - 1;

[8.4216]

[8.4282]

        do
        {
            door_move.delta.x = random2(3) - 1;
            door_move.delta.y = random2(3) - 1;
        }
        while (door_move.delta.origin());

Deletion in crawl-ref/source/acr.cc at line 3233 [5.4397395]
B:BD[8.4288] → [8.4288:4289]
B:BD[8.4289] → [14.108350:108378]
∅:D[14.108378] → [5.4466765:4466766]
B:BD[5.4466765] → [5.4466765:4466766]
B:BD[5.4466766] → [14.108379:108402]
∅:D[36.4225] → [5.4466795:4466801]
∅:D[14.108402] → [5.4466795:4466801]
B:BD[5.4466795] → [5.4466795:4466801]
B:BD[5.4466801] → [2.5307:5394]
```
    door_move.delta = move;
    if (move.origin())
    {
        mpr("Which direction? ", MSGCH_PROMPT);
        direction(door_move, DIR_DIR);
```
Deletion in crawl-ref/source/acr.cc at line 3234 [5.4397395]
∅:D[2.5395] → [5.4466889:4466948]
B:BD[5.4466889] → [5.4466889:4466948]
```
        if (!door_move.isValid)
            return;
    }
```
Deletion in crawl-ref/source/acr.cc at line 3239 [5.4397395]
B:BD[5.4467075] → [5.4467075:4467076]
B:BD[5.4467076] → [14.108438:108481]
```
    doorpos = you.pos() + door_move.delta;
```

Replacement in crawl-ref/source/acr.cc at line 3240 [5.4397395]

B:BD[5.4467166] → [19.18039:18077]

B:BD[19.18077] → [14.108482:108539]

    const dungeon_feature_type feat =
        in_bounds(doorpos) ? grd(doorpos) : DNGN_UNSEEN;

[5.4467166]

[19.18078]

    const coord_def doorpos = you.pos() + door_move.delta;
    const dungeon_feature_type feat = (in_bounds(doorpos) ? grd(doorpos)
                                                          : DNGN_UNSEEN);

Replacement in crawl-ref/source/acr.cc at line 3282 [5.4397395]

B:BD[5.4467687] → [14.108680:108781]

        int skill = you.dex +
            (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;

[5.4467687]

[5.4467776]

        int skill = you.dex
                    + (you.skills[SK_TRAPS_DOORS] + you.skills[SK_STEALTH]) / 2;

Replacement in crawl-ref/source/acr.cc at line 3309 [5.4397395]
∅:D[37.4507] → [22.5633:5690]
B:BD[24.5413] → [22.5633:5690]
```
            mprf( "You %s the %s%s.", verb, adj, noun );
```
[37.4507]
[5.4468143]
```
            mprf("You %s the %s%s.", verb, adj, noun);
```
Insertion in crawl-ref/source/acr.cc at line 3320 [5.4397395]
[32.3100]
[32.3100]
Insertion in crawl-ref/source/acr.cc at line 3342 [5.4397395]
[5.4468230]
[5.4468230]
```
    else if (you.confused())
        _open_door(door_move.delta);
```
Replacement in crawl-ref/source/acr.cc at line 3350 [5.4397395]
∅:D[3.7016] → [22.5754:5802]
B:BD[22.5754] → [22.5754:5802]
```
            mpr("It's already closed!"); break;
```
[3.7016]
[22.5802]
```
            mpr("It's already closed!");
            break;
```

Replacement in crawl-ref/source/acr.cc at line 3353 [5.4397395]

B:BD[22.5819] → [22.5819:5893]

            mpr("There isn't anything that you can close there!"); break;

[22.5819]

[22.5893]

            mpr("There isn't anything that you can close there!");
            break;