fiddlerwoaroof/crawl - Change B7MSPF6X2RLGWN4M6ZZF3WSOPKGYPTTD7LIJVST7DXN27DG6JHNAC

Code cleanup and renaming of static methods, mostly for decks.cc and

dungeon.cc.

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

Created by j-p-e-g on March 31, 2008

B7MSPF6X2RLGWN4M6ZZF3WSOPKGYPTTD7LIJVST7DXN27DG6JHNAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/tile1.cc at line 1649 [21.96318]
B:BD[20.2691] → [20.2691:2734]
```
            if(is_random_artefact( item ))
```
[20.2691]
[20.2734]
```
            if (is_random_artefact( item ))
```
Replacement in crawl-ref/source/tile1.cc at line 1658 [21.96318]
∅:D[22.27587] → [20.3014:3062]
B:BD[20.3014] → [20.3014:3062]
```
            else if(is_random_artefact( item ))
```
[22.27587]
[20.3062]
```
            else if (is_random_artefact( item ))
```
Deletion in crawl-ref/source/tile1.cc at line 3404 [21.96318]
B:BD[23.30416] → [23.30416:30422]
```
    {
```
Replacement in crawl-ref/source/tile1.cc at line 3406 [21.96318]
B:BD[23.30498] → [23.30498:30504]
```
    }
```
[23.30498]
[21.198448]
Deletion in crawl-ref/source/tile1.cc at line 3433 [21.96318]
B:BD[23.30628] → [23.30628:30634]
```
    {
```
Replacement in crawl-ref/source/tile1.cc at line 3435 [21.96318]
B:BD[23.30734] → [23.30734:30740]
```
    }
```
[23.30734]
[21.199005]
Deletion in crawl-ref/source/tile1.cc at line 3740 [21.96318]
B:BD[21.209201] → [21.209201:209207]
```
    {
```
Deletion in crawl-ref/source/tile1.cc at line 3744 [21.96318]
B:BD[21.209641] → [21.209641:209647]
```
    }
```
Deletion in crawl-ref/source/tile1.cc at line 4003 [21.96318]
B:BD[21.217156] → [21.217156:217162]
```
    {
```
Deletion in crawl-ref/source/tile1.cc at line 4004 [21.96318]
B:BD[21.217234] → [21.217234:217240]
```
    }
```
Insertion in crawl-ref/source/spl-cast.cc at line 89 [25.293070]
[24.774]
[24.774]
```
                {
```
Insertion in crawl-ref/source/spl-cast.cc at line 91 [25.293070]
[24.809]
[24.809]
```
                }
```
Replacement in crawl-ref/source/spl-cast.cc at line 93 [25.293070]
B:BD[24.823] → [24.823:836]
```
            
```
[24.823]
[24.836]
Deletion in crawl-ref/source/spl-cast.cc at line 99 [25.293070]
B:BD[24.1084] → [24.1084:1102]
```
                {
```
Replacement in crawl-ref/source/spl-cast.cc at line 113 [25.293070]
B:BD[24.1837] → [24.1837:1855]
```
                }
```
[24.1837]
[24.1855]
```
                    
```

Replacement in crawl-ref/source/spl-cast.cc at line 339 [25.293070]

B:BD[25.300519] → [25.300519:300590]

            && you.inv[you.equip[EQ_WEAPON]].base_type == OBJ_WEAPONS)

[25.300519]

[25.300590]

        && you.inv[you.equip[EQ_WEAPON]].base_type == OBJ_WEAPONS)

Replacement in crawl-ref/source/spl-cast.cc at line 993 [25.293070]

B:BD[25.313145] → [26.2248:2303]

            } while (!spell_typematch(spell, sptype));

[25.313145]

[25.313199]

            }
            while (!spell_typematch(spell, sptype));

Deletion in crawl-ref/source/spl-cast.cc at line 1499 [25.293070]
B:BD[27.435] → [27.435:449]
```
            {
```
Deletion in crawl-ref/source/spl-cast.cc at line 1500 [25.293070]
B:BD[27.525] → [27.525:539]
```
            }
```
Replacement in crawl-ref/source/spl-cast.cc at line 2205 [25.293070]
B:BD[28.6564] → [28.6564:6581]
```
            do {
```
[28.6564]
[28.6581]
```
            do
            {
```

Replacement in crawl-ref/source/spl-cast.cc at line 2208 [25.293070]

B:BD[28.6619] → [28.6619:6662]

            } while ( !one_chance_in(3) );

[28.6619]

[25.348453]

            }
            while ( !one_chance_in(3) );

Insertion in crawl-ref/source/spl-cast.cc at line 3630 [25.293070]
[29.1075]
[29.1149]
```
        
```
Deletion in crawl-ref/source/spl-cast.cc at line 3634 [25.293070]
B:BD[29.1304] → [29.1304:1310]
```
    {
```
Replacement in crawl-ref/source/spl-cast.cc at line 3636 [25.293070]
B:BD[29.1370] → [29.1370:1376]
```
    }
```
[29.1370]
[8.221]

Replacement in crawl-ref/source/monstuff.cc at line 314 [25.1396662]

∅:D[30.933] → [31.9910:9936]

B:BD[32.411840] → [31.9910:9936]

B:BD[31.9936] → [30.934:1000]

        mprf(MSGCH_SOUND,
             grid_item_destruction_message(grd(monster->pos())));

[30.933]

[30.1000]

        mprf(MSGCH_SOUND, grid_item_destruction_message(grd(monster->pos())));

Replacement in crawl-ref/source/monstuff.cc at line 2095 [25.1396662]
B:BD[25.1441454] → [32.420864:420901]
```
                && one_chance_in(3))
```
[25.1441454]
[25.1441497]
```
            && one_chance_in(3))
        {
```
Insertion in crawl-ref/source/monstuff.cc at line 2098 [25.1396662]
[25.1441528]
[32.420902]
```
        }
```

Replacement in crawl-ref/source/monstuff.cc at line 2102 [25.1396662]

B:BD[32.421023] → [33.343:401]

∅:D[33.401] → [32.421081:421139]

B:BD[32.421081] → [32.421081:421139]

        else if ((intel == I_NORMAL && one_chance_in(13))
                || (intel == I_HIGH && one_chance_in(6)))

[32.421023]

[32.421139]

        else if (intel == I_NORMAL && one_chance_in(13)
                 || intel == I_HIGH && one_chance_in(6))
        {

Insertion in crawl-ref/source/monstuff.cc at line 2106 [25.1396662]
[32.421170]
[25.1441538]
```
        }
```
Replacement in crawl-ref/source/monstuff.cc at line 3977 [25.1396662]
∅:D[34.9927] → [32.426571:426631]
B:BD[25.1490919] → [32.426571:426631]
```
            && !mons_class_flag(monster->type, M_CONFUSED))
```
[34.9927]
[25.1490973]
```
             && !mons_class_flag(monster->type, M_CONFUSED))
```
Replacement in crawl-ref/source/monstuff.cc at line 3982 [25.1396662]
B:BD[25.1491063] → [35.7011:7056]
```
            && !monster->ghost->spellcaster)
```
[25.1491063]
[25.1491123]
```
             && !monster->ghost->spellcaster)
```

Replacement in crawl-ref/source/monstuff.cc at line 3987 [25.1396662]

B:BD[25.1491210] → [25.1491210:1491279]

            || (monster->type == MONS_BALL_LIGHTNING && coinflip()))

[25.1491210]

[25.1491279]

             || (monster->type == MONS_BALL_LIGHTNING && coinflip()))

Deletion in crawl-ref/source/monstuff.cc at line 4033 [25.1396662]
∅:D[36.1332] → [25.1493112:1493126]
B:BD[25.1493112] → [25.1493112:1493126]
```
            {
```
Deletion in crawl-ref/source/monstuff.cc at line 4034 [25.1396662]
B:BD[25.1493158] → [25.1493158:1493172]
```
            }
```

Replacement in crawl-ref/source/monstuff.cc at line 5319 [25.1396662]

B:BD[37.4987] → [38.73:117]

B:BD[38.117] → [39.364:472]

                    simple_monster_message(
                        mons, " is incinerated.",
                        MSGCH_MONSTER_DAMAGE, MDAM_DEAD);

[37.4987]

[39.472]

                {
                    simple_monster_message( mons, " is incinerated.",
                                            MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
                }

Replacement in crawl-ref/source/monstuff.cc at line 5324 [25.1396662]

B:BD[39.535] → [39.535:626]

∅:D[39.626] → [38.167:225]

B:BD[38.167] → [38.167:225]

                    simple_monster_message(
                        mons, " falls apart.",
                        MSGCH_MONSTER_DAMAGE, MDAM_DEAD);

[39.535]

[37.5057]

                {
                    simple_monster_message( mons, " falls apart.",
                                            MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
                }

Replacement in crawl-ref/source/monstuff.cc at line 5329 [25.1396662]

B:BD[37.5078] → [38.226:370]

                    simple_monster_message(
                        mons, " drowns.",
                        MSGCH_MONSTER_DAMAGE, MDAM_DEAD);

[37.5078]

[37.5140]

                {
                    simple_monster_message( mons, " drowns.",
                                            MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
                }

Replacement in crawl-ref/source/monstuff.cc at line 6445 [25.1396662]
∅:D[40.1265] → [41.299:353]
B:BD[41.299] → [41.299:353]
```
                  "(use p/t/f to fire at it again.)",
```
[40.1265]
[42.2037]
```
                  "(use p or f to fire at it again.)",
```

Replacement in crawl-ref/source/monspeak.cc at line 48 [25.1558496]

B:BD[43.4755] → [43.4755:4832]

∅:D[43.4832] → [44.6936:6995]

B:BD[44.6936] → [44.6936:6995]

B:BD[44.6995] → [43.4833:5031]

∅:D[43.5031] → [45.861:927]

B:BD[45.861] → [45.861:927]

static std::string try_exact_string(const std::vector<std::string> prefixes,
                                    const std::string key,
                                    bool ignore_hostile  = false,
                                    bool ignore_related  = false,
                                    bool ignore_religion = false,
                                    bool ignore_silenced = false)

[43.4755]

[46.288]

static std::string _try_exact_string(const std::vector<std::string> prefixes,
                                     const std::string key,
                                     bool ignore_hostile  = false,
                                     bool ignore_related  = false,
                                     bool ignore_religion = false,
                                     bool ignore_silenced = false)

Replacement in crawl-ref/source/monspeak.cc at line 98 [25.1558496]
∅:D[15.2581] → [43.6016:6073]
B:BD[43.6016] → [43.6016:6073]
```
            msg = try_exact_string(prefixes, key, true);
```
[15.2581]
[43.6073]
```
            msg = _try_exact_string(prefixes, key, true);
```

Replacement in crawl-ref/source/monspeak.cc at line 102 [25.1558496]

B:BD[15.2647] → [15.2647:2721]

                msg = try_exact_string(prefixes, key, true, false, true);

[15.2647]

[15.2721]

                msg = _try_exact_string(prefixes, key, true, false, true);

Replacement in crawl-ref/source/monspeak.cc at line 104 [25.1558496]

B:BD[15.2766] → [15.2766:2833]

                msg = try_exact_string(prefixes, key, true, true);

[15.2766]

[15.2833]

                msg = _try_exact_string(prefixes, key, true, true);

Replacement in crawl-ref/source/monspeak.cc at line 107 [25.1558496]

∅:D[15.2908] → [43.6189:6258]

B:BD[43.6189] → [43.6189:6258]

            msg = try_exact_string(prefixes, key, true, true, true);

[15.2908]

[43.6258]

            msg = _try_exact_string(prefixes, key, true, true, true);

Replacement in crawl-ref/source/monspeak.cc at line 111 [25.1558496]

∅:D[15.2962] → [43.6415:6490]

B:BD[43.6415] → [43.6415:6490]

            msg = try_exact_string(prefixes, key, true, true, true, true);

[15.2962]

[44.7223]

            msg = _try_exact_string(prefixes, key, true, true, true, true);

Replacement in crawl-ref/source/monspeak.cc at line 116 [25.1558496]

B:BD[46.538] → [43.6510:6707]

static std::string get_speak_string(const std::vector<std::string> prefixes,
                                    const std::string key,
                                    const monsters *monster)

[46.538]

[43.6707]

static std::string _get_speak_string(const std::vector<std::string> prefixes,
                                     const std::string key,
                                     const monsters *monster)

Replacement in crawl-ref/source/monspeak.cc at line 120 [25.1558496]

B:BD[43.6709] → [43.6709:6764]

    std::string msg = try_exact_string(prefixes, key);

[43.6709]

[47.2694]

    std::string msg = _try_exact_string(prefixes, key);

Replacement in crawl-ref/source/monspeak.cc at line 183 [25.1558496]

B:BD[44.8719] → [44.8719:8786]

static std::string player_ghost_speak_str(const monsters *monster,

[44.8719]

[44.8786]

static std::string _player_ghost_speak_str(const monsters *monster,

Insertion in crawl-ref/source/monspeak.cc at line 308 [25.1558496]
[44.11153]
[44.11153]
```
    {
```

Replacement in crawl-ref/source/monspeak.cc at line 310 [25.1558496]

B:BD[44.11203] → [44.11203:11260]

        msg = player_ghost_speak_str(monster, prefixes);

[44.11203]

[44.11260]

        msg = _player_ghost_speak_str(monster, prefixes);
    }

Insertion in crawl-ref/source/monspeak.cc at line 313 [25.1558496]
[44.11314]
[44.11314]
```
    {
```

Replacement in crawl-ref/source/monspeak.cc at line 316 [25.1558496]

B:BD[44.11421] → [44.11421:11492]

        msg = get_speak_string(prefixes, "pandemonium lord", monster);

[44.11421]

[44.11492]

        msg = _get_speak_string(prefixes, "pandemonium lord", monster);
    }

Replacement in crawl-ref/source/monspeak.cc at line 319 [25.1558496]

B:BD[44.11501] → [44.11501:11579]

        msg = get_speak_string(prefixes, monster->name(DESC_PLAIN), monster);

[44.11501]

[44.11579]

        msg = _get_speak_string(prefixes, monster->name(DESC_PLAIN), monster);

Replacement in crawl-ref/source/monspeak.cc at line 325 [25.1558496]
B:BD[48.2951] → [43.8302:8343]
```
        msg = get_speak_string(prefixes,
```
[48.2951]
[43.8343]
```
        msg = _get_speak_string(prefixes,
```

Replacement in crawl-ref/source/monspeak.cc at line 359 [25.1558496]

B:BD[44.12206] → [44.12206:12262]

        msg = get_speak_string(prefixes, key, monster);

[44.12206]

[25.1567092]

        msg = _get_speak_string(prefixes, key, monster);

Insertion in crawl-ref/source/monspeak.cc at line 361 [25.1558496]
[25.1567098]
[44.12263]
```
    
```

Replacement in crawl-ref/source/monspeak.cc at line 412 [25.1558496]

∅:D[43.8767] → [44.13738:13815]

B:BD[44.13738] → [44.13738:13815]

        msg = get_speak_string(prefixes, get_mon_shape_str(shape), monster);

[43.8767]

[43.8768]

        msg = _get_speak_string(prefixes, get_mon_shape_str(shape), monster);

Replacement in crawl-ref/source/monspeak.cc at line 433 [25.1558496]

B:BD[44.14356] → [44.14356:14507]

            msg = get_speak_string(prefixes,
                                   get_mon_shape_str(shape),
                                   monster);

[44.14356]

[25.1571816]

            msg = _get_speak_string(prefixes,
                                    get_mon_shape_str(shape),
                                    monster);

Replacement in crawl-ref/source/monspeak.cc at line 442 [25.1558496]

B:BD[44.14729] → [44.14729:14895]

                msg2 = get_speak_string(prefixes,
                                        get_mon_shape_str(shape),
                                        monster);

[44.14729]

[43.9016]

                msg2 = _get_speak_string(prefixes,
                                         get_mon_shape_str(shape),
                                         monster);

Replacement in crawl-ref/source/monspeak.cc at line 463 [25.1558496]

B:BD[44.15258] → [44.15258:15409]

            msg = get_speak_string(prefixes,
                                   get_mon_shape_str(shape),
                                   monster);

[44.15258]

[25.1573812]

            msg = _get_speak_string(prefixes,
                                    get_mon_shape_str(shape),
                                    monster);

Replacement in crawl-ref/source/dungeon.cc at line 110 [25.3429798]

B:BD[25.3431462] → [49.1577:1644]

B:BD[49.1644] → [50.360:387]

∅:D[50.387] → [49.1644:1711]

B:BD[49.1644] → [49.1644:1711]

static void build_dungeon_level(int level_number, int level_type);
static void reset_level();
static bool valid_dungeon_level(int level_number, int level_type);

[25.3431462]

[49.1711]

static void _build_dungeon_level(int level_number, int level_type);
static void _reset_level();
static bool _valid_dungeon_level(int level_number, int level_type);

Replacement in crawl-ref/source/dungeon.cc at line 114 [25.3429798]

B:BD[49.1712] → [51.7477:7590]

∅:D[51.7590] → [25.3431543:3431616]

B:BD[25.3431543] → [25.3431543:3431616]

B:BD[25.3431616] → [51.7591:7886]

B:BD[51.7886] → [52.409:464]

B:BD[52.464] → [53.2393:2439]

∅:D[52.544] → [54.380:659]

∅:D[53.2439] → [54.380:659]

∅:D[51.7942] → [54.380:659]

B:BD[25.3431797] → [54.380:659]

∅:D[54.659] → [25.3432028:3432251]

B:BD[25.3432028] → [25.3432028:3432251]

B:BD[25.3432251] → [51.7943:8066]

B:BD[51.8066] → [55.30393:30497]

∅:D[56.3395] → [25.3432306:3432371]

∅:D[51.8112] → [25.3432306:3432371]

∅:D[55.30497] → [25.3432306:3432371]

B:BD[25.3432306] → [25.3432306:3432371]

B:BD[25.3432371] → [57.800:834]

B:BD[57.834] → [55.30498:30667]

∅:D[58.479] → [25.3432477:3432522]

∅:D[59.3049] → [25.3432477:3432522]

∅:D[55.30667] → [25.3432477:3432522]

∅:D[60.147878] → [25.3432477:3432522]

B:BD[25.3432477] → [25.3432477:3432522]

B:BD[25.3432522] → [61.6286:6338]

∅:D[61.6338] → [62.4463:4492]

B:BD[25.3432522] → [62.4463:4492]

B:BD[62.4492] → [63.310:358]

∅:D[63.358] → [25.3432555:3432602]

∅:D[64.1320] → [25.3432555:3432602]

∅:D[62.4523] → [25.3432555:3432602]

B:BD[25.3432555] → [25.3432555:3432602]

B:BD[25.3432602] → [62.4524:4577]

B:BD[62.4577] → [51.8113:8354]

∅:D[51.8354] → [25.3432815:3432896]

B:BD[25.3432815] → [25.3432815:3432896]

B:BD[25.3432896] → [51.8355:8433]

∅:D[51.8433] → [25.3433150:3433266]

B:BD[25.3433150] → [25.3433150:3433266]

B:BD[25.3433266] → [51.8434:8490]

B:BD[51.8490] → [65.282:648]

static bool find_in_area(int sx, int sy, int ex, int ey,
                         dungeon_feature_type feature);
static bool make_box(int room_x1, int room_y1, int room_x2, int room_y2,
                     dungeon_feature_type floor=DNGN_UNSEEN,
                     dungeon_feature_type wall=DNGN_UNSEEN,
                     dungeon_feature_type avoid=DNGN_UNSEEN);
static void replace_area(int sx, int sy, int ex, int ey,
                         dungeon_feature_type replace,
                         dungeon_feature_type feature,
                         unsigned mmask = 0);
static builder_rc_type builder_by_type(int level_number, char level_type);
static builder_rc_type builder_by_branch(int level_number);
static builder_rc_type builder_normal(int level_number, char level_type, spec_room &s);
static builder_rc_type builder_basic(int level_number);
static void builder_extras(int level_number, int level_type);
static void builder_items(int level_number, char level_type, int items_wanted);
static void builder_monsters(int level_number, char level_type, int mon_wanted);
static void place_specific_stair(dungeon_feature_type stair,
                                 const std::string &tag = "",
                                 int dl = 0,
                                 bool vault_only = false);
static void place_branch_entrances(int dlevel, char level_type);
static void place_extra_vaults();
static void place_minivaults(const std::string &tag = "",
                             int fewest = -1, int most = -1,
                             bool force = false);
static void place_traps( int level_number );
static void place_fog_machines( int level_number );
static void prepare_swamp();
static void prepare_shoals( int level_number );
static void prepare_water( int level_number );
static void check_doors();
static void hide_doors();
static void make_trail(int xs, int xr, int ys, int yr,int corrlength,
                       int intersect_chance,
                       int no_corr, dungeon_feature_type begin,
                       dungeon_feature_type end=DNGN_UNSEEN);
static bool make_room(int sx,int sy,int ex,int ey,int max_doors, int doorlevel);
static void place_pool(dungeon_feature_type pool_type, unsigned char pool_x1,
                       unsigned char pool_y1, unsigned char pool_x2,
                       unsigned char pool_y2);
static void many_pools(dungeon_feature_type pool_type);
static bool join_the_dots(const coord_def &from, const coord_def &to,
                          unsigned mmask, bool early_exit = false);
static bool join_the_dots_rigorous(const coord_def &from,
                                   const coord_def &to,
                                   unsigned mapmask,
                                   bool early_exit = false);

[49.1712]

[25.3433315]

static bool _find_in_area(int sx, int sy, int ex, int ey,
                          dungeon_feature_type feature);
static bool _make_box(int room_x1, int room_y1, int room_x2, int room_y2,
                      dungeon_feature_type floor=DNGN_UNSEEN,
                      dungeon_feature_type wall=DNGN_UNSEEN,
                      dungeon_feature_type avoid=DNGN_UNSEEN);
static void _replace_area(int sx, int sy, int ex, int ey,
                          dungeon_feature_type replace,
                          dungeon_feature_type feature,
                          unsigned mmask = 0);
static builder_rc_type _builder_by_type(int level_number, char level_type);
static builder_rc_type _builder_by_branch(int level_number);
static builder_rc_type _builder_normal(int level_number, char level_type,
                                       spec_room &s);
static builder_rc_type _builder_basic(int level_number);
static void _builder_extras(int level_number, int level_type);
static void _builder_items(int level_number, char level_type, int items_wanted);
static void _builder_monsters(int level_number, char level_type, int mon_wanted);
static void _place_specific_stair(dungeon_feature_type stair,
                                  const std::string &tag = "",
                                  int dl = 0, bool vault_only = false);
static void _place_branch_entrances(int dlevel, char level_type);
static void _place_extra_vaults();
static void _place_minivaults(const std::string &tag = "",
                              int fewest = -1, int most = -1,
                              bool force = false);
static void _place_traps( int level_number );
static void _place_fog_machines( int level_number );
static void _prepare_swamp();
static void _prepare_shoals( int level_number );
static void _prepare_water( int level_number );
static void _check_doors();
static void _hide_doors();
static void _make_trail(int xs, int xr, int ys, int yr,int corrlength,
                        int intersect_chance,
                        int no_corr, dungeon_feature_type begin,
                        dungeon_feature_type end=DNGN_UNSEEN);
static bool _make_room(int sx,int sy,int ex,int ey,int max_doors, int doorlevel);
static void _place_pool(dungeon_feature_type pool_type, unsigned char pool_x1,
                        unsigned char pool_y1, unsigned char pool_x2,
                        unsigned char pool_y2);
static void _many_pools(dungeon_feature_type pool_type);
static bool _join_the_dots(const coord_def &from, const coord_def &to,
                           unsigned mmask, bool early_exit = false);
static bool _join_the_dots_rigorous(const coord_def &from,
                                    const coord_def &to,
                                    unsigned mapmask,
                                    bool early_exit = false);

Replacement in crawl-ref/source/dungeon.cc at line 163 [25.3429798]

B:BD[25.3433316] → [51.8491:8615]

static void build_river(dungeon_feature_type river_type); //mv
static void build_lake(dungeon_feature_type lake_type); //mv

[25.3433316]

[25.3433465]

static void _build_river(dungeon_feature_type river_type); //mv
static void _build_lake(dungeon_feature_type lake_type); //mv

Replacement in crawl-ref/source/dungeon.cc at line 166 [25.3429798]

B:BD[25.3433466] → [25.3433466:3433532]

B:BD[25.3433532] → [62.4578:4605]

B:BD[62.4605] → [55.30668:30725]

∅:D[55.30725] → [62.4606:4672]

B:BD[25.3433621] → [62.4606:4672]

∅:D[62.4672] → [25.3433699:3433766]

B:BD[25.3433699] → [25.3433699:3433766]

B:BD[25.3433766] → [51.8616:8685]

∅:D[51.8685] → [62.4673:4695]

B:BD[25.3433828] → [62.4673:4695]

∅:D[62.4695] → [25.3433854:3433892]

B:BD[25.3433854] → [25.3433854:3433892]

B:BD[25.3433892] → [51.8686:8796]

B:BD[51.8796] → [66.7548:7598]

∅:D[66.7598] → [25.3433973:3434020]

∅:D[51.8796] → [25.3433973:3434020]

∅:D[55.30770] → [25.3433973:3434020]

B:BD[25.3433973] → [25.3433973:3434020]

B:BD[25.3434020] → [51.8797:8908]

∅:D[51.8908] → [25.3434093:3434259]

B:BD[25.3434093] → [25.3434093:3434259]

static void spotty_level(bool seeded, int iterations, bool boxy);
static void bigger_room();
static void plan_main(int level_number, int force_plan);
static char plan_1();
static char plan_2();
static char plan_3();
static char plan_4(char forbid_x1, char forbid_y1, char forbid_x2,
                   char forbid_y2, dungeon_feature_type force_wall);
static char plan_5();
static char plan_6(int level_number);
static bool octa_room(spec_room &sr, int oblique_max,
                      dungeon_feature_type type_floor);
static void portal_vault_level(int level_number);
static void labyrinth_level(int level_number);
static void box_room(int bx1, int bx2, int by1, int by2,
                     dungeon_feature_type wall_type);
static int box_room_doors( int bx1, int bx2, int by1, int by2, int new_doors);
static void city_level(int level_number);
static void diamond_rooms(int level_number);

[25.3433466]

[67.282]

static void _spotty_level(bool seeded, int iterations, bool boxy);
static void _bigger_room();
static void _plan_main(int level_number, int force_plan);
static char _plan_1();
static char _plan_2();
static char _plan_3();
static char _plan_4(char forbid_x1, char forbid_y1, char forbid_x2,
                    char forbid_y2, dungeon_feature_type force_wall);
static char _plan_5();
static char _plan_6(int level_number);
static bool _octa_room(spec_room &sr, int oblique_max,
                       dungeon_feature_type type_floor);
static void _portal_vault_level(int level_number);
static void _labyrinth_level(int level_number);
static void _box_room(int bx1, int bx2, int by1, int by2,
                      dungeon_feature_type wall_type);
static int  _box_room_doors( int bx1, int bx2, int by1, int by2, int new_doors);
static void _city_level(int level_number);
static void _diamond_rooms(int level_number);

Replacement in crawl-ref/source/dungeon.cc at line 186 [25.3429798]

B:BD[67.283] → [67.283:453]

static void pick_float_exits(vault_placement &place,
                             std::vector<coord_def> &targets);
static void connect_vault(const vault_placement &vp);

[67.283]

[25.3434259]

static void _pick_float_exits(vault_placement &place,
                              std::vector<coord_def> &targets);
static void _connect_vault(const vault_placement &vp);

Replacement in crawl-ref/source/dungeon.cc at line 191 [25.3429798]

B:BD[25.3434285] → [55.30771:30830]

∅:D[55.30830] → [68.165:229]

B:BD[25.3434328] → [68.165:229]

∅:D[68.229] → [25.3434511:3434692]

B:BD[25.3434511] → [25.3434511:3434692]

B:BD[25.3434845] → [25.3434845:3434885]

B:BD[25.3434885] → [51.8909:9087]

∅:D[51.9087] → [25.3434997:3435091]

∅:D[32.948798] → [25.3434997:3435091]

B:BD[25.3434997] → [25.3434997:3435091]

static void place_shops(int level_number, int nshops = 0);
static object_class_type item_in_shop(unsigned char shop_type);
static bool treasure_area(int level_number, unsigned char ta1_x,
                          unsigned char ta2_x, unsigned char ta1_y,
                          unsigned char ta2_y);
static void big_room(int level_number);
static void chequerboard(spec_room &sr, dungeon_feature_type target,
                         dungeon_feature_type floor1,
                         dungeon_feature_type floor2);
static void roguey_level(int level_number, spec_room &sr);
static void morgue(spec_room &sr);

[25.3434285]

[25.3435091]

static void _place_shops(int level_number, int nshops = 0);
static object_class_type _item_in_shop(unsigned char shop_type);
static bool _treasure_area(int level_number, unsigned char ta1_x,
                           unsigned char ta2_x, unsigned char ta1_y,
                           unsigned char ta2_y);

Replacement in crawl-ref/source/dungeon.cc at line 198 [25.3429798]

B:BD[25.3435117] → [25.3435117:3435248]

B:BD[25.3435248] → [32.948799:948855]

static void special_room(int level_number, spec_room &sr);
static void specr_2(spec_room &sr);
static void beehive(spec_room &sr);
static void jelly_pit(int level_number, spec_room &sr);

[25.3435117]

[25.3435248]

static void _special_room(int level_number, spec_room &sr);
static void _specr_2(spec_room &sr);
static void _big_room(int level_number);
static void _chequerboard(spec_room &sr, dungeon_feature_type target,
                          dungeon_feature_type floor1,
                          dungeon_feature_type floor2);
static void _roguey_level(int level_number, spec_room &sr);
static void _morgue(spec_room &sr);
static void _beehive(spec_room &sr);
static void _jelly_pit(int level_number, spec_room &sr);

Replacement in crawl-ref/source/dungeon.cc at line 210 [25.3429798]

B:BD[25.3435268] → [69.3177:3359]

B:BD[69.3359] → [70.2419:2475]

B:BD[70.2475] → [71.339:401]

∅:D[71.401] → [70.2475:2554]

B:BD[70.2475] → [70.2475:2554]

∅:D[70.2554] → [72.1001:1133]

∅:D[69.3416] → [72.1001:1133]

B:BD[56.3550] → [72.1001:1133]

B:BD[72.1133] → [69.3417:3474]

B:BD[69.3474] → [70.2555:2632]

B:BD[70.2632] → [71.402:455]

∅:D[71.455] → [70.2632:2702]

B:BD[70.2632] → [70.2632:2702]

∅:D[72.1191] → [63.359:423]

∅:D[70.2702] → [63.359:423]

∅:D[69.3552] → [63.359:423]

B:BD[56.3683] → [63.359:423]

B:BD[63.423] → [69.3553:3631]

B:BD[69.3631] → [71.456:582]

∅:D[63.485] → [73.5402:5444]

∅:D[71.582] → [73.5402:5444]

∅:D[52.610] → [73.5402:5444]

B:BD[25.3435394] → [73.5402:5444]

∅:D[73.5444] → [60.147927:148001]

B:BD[60.147927] → [60.147927:148001]

B:BD[60.148001] → [74.4217:4295]

∅:D[74.4295] → [75.10086:10233]

B:BD[25.3435533] → [75.10086:10233]

static bool build_secondary_vault(int level_number, int vault,
                                  int rune_subst = -1,
                                  bool generating_level = true,
                                  bool clobber = false,
                                  bool make_no_exits = false,
                                  const coord_def &where = coord_def(-1, -1));
static bool build_vaults(int level_number, int vault_number,
                         int rune_subst = -1, bool build_only = false,
                         bool check_vault_place = false,
                         bool generating_level = true, bool clobber = false,
                         bool make_no_exits = false,
                         const coord_def &where = coord_def(-1, -1));
static bool build_minivaults(int level_number, int force_vault,
                             bool level_builder = true, bool clobber = false,
                             bool make_no_exits = false,
                             const coord_def &where = coord_def() );
static int vault_grid( vault_placement &,
                       int level_number, int vx, int vy, int altar_count,
                       FixedVector < object_class_type, 7 > &acq_item_class, 
                       int vgrid, std::vector<coord_def> &targets,
                       int &num_runes, int rune_subst = -1, bool foll = false);

[25.3435268]

[25.3435718]

static bool _build_secondary_vault(int level_number, int vault,
                                   int rune_subst = -1,
                                   bool generating_level = true,
                                   bool clobber = false,
                                   bool make_no_exits = false,
                                   const coord_def &where = coord_def(-1, -1));
static bool _build_vaults(int level_number, int vault_number,
                          int rune_subst = -1, bool build_only = false,
                          bool check_vault_place = false,
                          bool generating_level = true, bool clobber = false,
                          bool make_no_exits = false,
                          const coord_def &where = coord_def(-1, -1));
static bool _build_minivaults(int level_number, int force_vault,
                              bool level_builder = true, bool clobber = false,
                              bool make_no_exits = false,
                              const coord_def &where = coord_def() );
static int _vault_grid( vault_placement &,
                        int level_number, int vx, int vy, int altar_count,
                        FixedVector < object_class_type, 7 > &acq_item_class,
                        int vgrid, std::vector<coord_def> &targets,
                        int &num_runes, int rune_subst = -1, bool foll = false);

Replacement in crawl-ref/source/dungeon.cc at line 232 [25.3429798]

B:BD[25.3435719] → [63.486:538]

B:BD[63.538] → [76.431:503]

static int dgn_random_map_for_place(bool wantmini);
static void dgn_load_colour_grid();
static void dgn_map_colour_fixup();

[25.3435719]

[63.538]

static int  _dgn_random_map_for_place(bool wantmini);
static void _dgn_load_colour_grid();
static void _dgn_map_colour_fixup();

Replacement in crawl-ref/source/dungeon.cc at line 237 [25.3429798]

B:BD[25.3435738] → [62.4696:4768]

B:BD[62.4768] → [77.3882:3910]

static dungeon_feature_type pick_an_altar();
static void place_altar();
static void place_altars();

[25.3435738]

[78.283]

static dungeon_feature_type _pick_an_altar();
static void _place_altar();
static void _place_altars();

Replacement in crawl-ref/source/dungeon.cc at line 244 [25.3429798]
B:BD[66.7618] → [66.7618:7655]
```
static void dgn_set_floor_colours();
```
[66.7618]
[79.821]
```
static void _dgn_set_floor_colours();
```
Replacement in crawl-ref/source/dungeon.cc at line 256 [25.3429798]
B:BD[80.6205] → [50.497:533]
```
static bool use_random_maps = true;
```
[80.6205]
[50.533]
```
static bool use_random_maps  = true;
```
Replacement in crawl-ref/source/dungeon.cc at line 276 [25.3429798]
B:BD[76.841] → [76.841:873]
```
        dgn_load_colour_grid();
```
[76.841]
[76.873]
```
        _dgn_load_colour_grid();
```
Replacement in crawl-ref/source/dungeon.cc at line 281 [25.3429798]
B:BD[76.921] → [76.921:953]
```
        dgn_map_colour_fixup();
```
[76.921]
[76.953]
```
        _dgn_map_colour_fixup();
```
Replacement in crawl-ref/source/dungeon.cc at line 309 [25.3429798]
B:BD[50.697] → [50.697:720]
```
        reset_level();
```
[50.697]
[50.720]
```
        _reset_level();
```
Replacement in crawl-ref/source/dungeon.cc at line 316 [25.3429798]
∅:D[50.931] → [49.1821:1876]
∅:D[80.6364] → [49.1821:1876]
B:BD[49.1821] → [49.1821:1876]
B:BD[49.1876] → [81.297:330]
```
        build_dungeon_level(level_number, level_type);
        dgn_set_floor_colours();
```
[50.931]
[80.6365]
```
        _build_dungeon_level(level_number, level_type);
        _dgn_set_floor_colours();
```

Replacement in crawl-ref/source/dungeon.cc at line 324 [25.3429798]

∅:D[50.1033] → [80.6366:6446]

B:BD[80.6366] → [80.6366:6446]

        if (!dgn_level_vetoed && valid_dungeon_level(level_number, level_type))

[50.1033]

[76.1094]

        if (!dgn_level_vetoed && _valid_dungeon_level(level_number, level_type))

Replacement in crawl-ref/source/dungeon.cc at line 326 [25.3429798]
B:BD[76.1104] → [76.1104:1140]
```
            dgn_map_colour_fixup();
```
[76.1104]
[82.1773]
```
            _dgn_map_colour_fixup();
```
Replacement in crawl-ref/source/dungeon.cc at line 361 [25.3429798]
B:BD[83.107815] → [76.1152:1187]
```
static void dgn_load_colour_grid()
```
[83.107815]
[76.1187]
```
static void _dgn_load_colour_grid()
```
Replacement in crawl-ref/source/dungeon.cc at line 374 [25.3429798]
B:BD[76.1550] → [76.1550:1585]
```
static void dgn_map_colour_fixup()
```
[76.1550]
[76.1585]
```
static void _dgn_map_colour_fixup()
```
Replacement in crawl-ref/source/dungeon.cc at line 463 [25.3429798]
∅:D[76.2388] → [77.4131:4182]
∅:D[84.7038] → [77.4131:4182]
B:BD[77.4131] → [77.4131:4182]
```
static void dgn_register_vault(const map_def &map)
```
[76.2388]
[77.4182]
```
static void _dgn_register_vault(const map_def &map)
```

Replacement in crawl-ref/source/dungeon.cc at line 477 [25.3429798]

B:BD[50.1037] → [85.2245:2312]

static inline bool dgn_grid_is_passable(dungeon_feature_type grid)

[50.1037]

[50.1111]

static inline bool _dgn_grid_is_passable(dungeon_feature_type grid)

Replacement in crawl-ref/source/dungeon.cc at line 485 [25.3429798]

B:BD[85.2465] → [86.3425:3487]

static inline bool dgn_square_is_passable(const coord_def &c)

[85.2465]

[86.3487]

static inline bool _dgn_square_is_passable(const coord_def &c)

Replacement in crawl-ref/source/dungeon.cc at line 487 [25.3429798]

B:BD[86.3489] → [87.285:363]

    return (!(dgn_map_mask(c) & MMT_OPAQUE) && dgn_grid_is_passable(grd(c)));

[86.3489]

[86.3551]

    return (!(dgn_map_mask(c) & MMT_OPAQUE) && _dgn_grid_is_passable(grd(c)));

Replacement in crawl-ref/source/dungeon.cc at line 490 [25.3429798]
∅:D[86.3554] → [85.2465:2529]
B:BD[85.2465] → [85.2465:2529]
```
static inline void dgn_point_record_stub(const coord_def &) { }
```
[86.3554]
[85.2529]
```
static inline void _dgn_point_record_stub(const coord_def &) { }
```

Replacement in crawl-ref/source/dungeon.cc at line 493 [25.3429798]

B:BD[85.2560] → [19.5963:6160]

static void dgn_fill_zone( const coord_def &c, int zone, point_record &prec,
                           bool (*passable)(const coord_def &)
                               = dgn_square_is_passable)

[85.2560]

[85.2708]

static void _dgn_fill_zone( const coord_def &c, int zone, point_record &prec,
                            bool (*passable)(const coord_def &)
                                = _dgn_square_is_passable)

Replacement in crawl-ref/source/dungeon.cc at line 511 [25.3429798]
B:BD[85.3247] → [85.3247:3290]
```
            dgn_fill_zone(cp, zone, prec);
```
[85.3247]
[85.3290]
```
            _dgn_fill_zone(cp, zone, prec);
```
Replacement in crawl-ref/source/dungeon.cc at line 544 [25.3429798]
B:BD[50.2343] → [50.2343:2385]
```
static int dgn_count_disconnected_zones()
```
[50.2343]
[50.2385]
```
static int _dgn_count_disconnected_zones()
```

Replacement in crawl-ref/source/dungeon.cc at line 552 [25.3429798]

B:BD[55.30953] → [55.30953:31014]

                || !dgn_square_is_passable(coord_def(x, y)))

[55.30953]

[50.2709]

                || !_dgn_square_is_passable(coord_def(x, y)))
            {

Insertion in crawl-ref/source/dungeon.cc at line 555 [25.3429798]
[50.2735]
[50.2735]
```
            }
```

Replacement in crawl-ref/source/dungeon.cc at line 557 [25.3429798]

B:BD[50.2736] → [85.3358:3435]

            dgn_fill_zone(coord_def(x, y), ++nzones, dgn_point_record_stub);

[50.2736]

[50.2790]

            _dgn_fill_zone(coord_def(x, y), ++nzones, _dgn_point_record_stub);

Replacement in crawl-ref/source/dungeon.cc at line 563 [25.3429798]
B:BD[53.2488] → [85.3436:3475]
```
static void fixup_pandemonium_stairs()
```
[53.2488]
[50.2885]
```
static void _fixup_pandemonium_stairs()
```
Replacement in crawl-ref/source/dungeon.cc at line 585 [25.3429798]
∅:D[50.3470] → [53.2488:2556]
B:BD[53.2488] → [53.2488:2556]
```
static void mask_vault(const vault_placement &place, unsigned mask)
```
[50.3470]
[53.2556]
```
static void _mask_vault(const vault_placement &place, unsigned mask)
```
Replacement in crawl-ref/source/dungeon.cc at line 595 [25.3429798]
B:BD[53.2806] → [77.4515:4572]
```
static void register_place(const vault_placement &place)
```
[53.2806]
[53.2866]
```
static void _register_place(const vault_placement &place)
```
Replacement in crawl-ref/source/dungeon.cc at line 597 [25.3429798]
B:BD[53.2868] → [77.4573:4608]
```
    dgn_register_vault(place.map);
```
[53.2868]
[77.4608]
```
    _dgn_register_vault(place.map);
```
Replacement in crawl-ref/source/dungeon.cc at line 599 [25.3429798]
∅:D[77.4613] → [53.2868:2916]
B:BD[53.2868] → [53.2868:2916]
```
    mask_vault(place, MMT_VAULT | MMT_NO_DOOR);
```
[77.4613]
[53.2916]
```
    _mask_vault(place, MMT_VAULT | MMT_NO_DOOR);
```
Replacement in crawl-ref/source/dungeon.cc at line 601 [25.3429798]
B:BD[53.2961] → [53.2961:3001]
```
        mask_vault(place, MMT_NO_MONS);
```
[53.2961]
[80.6637]
```
        _mask_vault(place, MMT_NO_MONS);
```
Replacement in crawl-ref/source/dungeon.cc at line 604 [25.3429798]
B:BD[53.3044] → [53.3044:3084]
```
        mask_vault(place, MMT_NO_ITEM);
```
[53.3044]
[53.3084]
```
        _mask_vault(place, MMT_NO_ITEM);
```
Replacement in crawl-ref/source/dungeon.cc at line 607 [25.3429798]
B:BD[53.3129] → [53.3129:3169]
```
        mask_vault(place, MMT_NO_POOL);
```
[53.3129]
[55.31015]
```
        _mask_vault(place, MMT_NO_POOL);
```
Replacement in crawl-ref/source/dungeon.cc at line 610 [25.3429798]
B:BD[55.31059] → [55.31059:31098]
```
        mask_vault(place, MMT_OPAQUE);
```
[55.31059]
[83.109620]
```
        _mask_vault(place, MMT_OPAQUE);
```
Replacement in crawl-ref/source/dungeon.cc at line 640 [25.3429798]
∅:D[53.3172] → [80.6638:6690]
B:BD[80.6638] → [80.6638:6690]
```
static bool ensure_vault_placed(bool vault_success)
```
[53.3172]
[80.6690]
```
static bool _ensure_vault_placed(bool vault_success)
```
Replacement in crawl-ref/source/dungeon.cc at line 649 [25.3429798]
B:BD[49.1939] → [49.1939:1985]
```
static coord_def find_level_feature(int feat)
```
[49.1939]
[49.1985]
```
static coord_def _find_level_feature(int feat)
```

Replacement in crawl-ref/source/dungeon.cc at line 661 [25.3429798]

B:BD[49.3777] → [49.3777:3839]

static bool has_connected_downstairs_from(const coord_def &c)

[49.2591]

[49.3839]

static bool _has_connected_downstairs_from(const coord_def &c)

Replacement in crawl-ref/source/dungeon.cc at line 673 [25.3429798]
B:BD[49.4130] → [49.4130:4169]
```
static bool is_level_stair_connected()
```
[49.4130]
[25.3436118]
```
static bool _is_level_stair_connected()
```

Replacement in crawl-ref/source/dungeon.cc at line 675 [25.3429798]

B:BD[25.3436120] → [49.4170:4233]

    coord_def up = find_level_feature(DNGN_STONE_STAIRS_UP_I);

[25.3436120]

[49.4233]

    coord_def up = _find_level_feature(DNGN_STONE_STAIRS_UP_I);

Replacement in crawl-ref/source/dungeon.cc at line 677 [25.3429798]
B:BD[49.4255] → [49.4255:4305]
```
        return has_connected_downstairs_from(up);
```
[49.4255]
[49.4305]
```
        return _has_connected_downstairs_from(up);
```

Replacement in crawl-ref/source/dungeon.cc at line 682 [25.3429798]

B:BD[49.4329] → [49.4329:4395]

static bool valid_dungeon_level(int level_number, int level_type)

[49.4329]

[49.4395]

static bool _valid_dungeon_level(int level_number, int level_type)

Replacement in crawl-ref/source/dungeon.cc at line 685 [25.3429798]
B:BD[49.4455] → [49.4455:4498]
```
        return is_level_stair_connected();
```
[49.4455]
[49.4498]
```
        return _is_level_stair_connected();
```
Replacement in crawl-ref/source/dungeon.cc at line 690 [25.3429798]
B:BD[49.4521] → [56.3746:3772]
```
static void reset_level()
```
[49.4521]
[49.4587]
```
static void _reset_level()
```

Replacement in crawl-ref/source/dungeon.cc at line 751 [25.3429798]

B:BD[25.3436987] → [56.4037:4154]

static void build_layout_skeleton(int level_number, int level_type,
                                  spec_room &sr)

[25.3436987]

[56.4154]

static void _build_layout_skeleton(int level_number, int level_type,
                                   spec_room &sr)

Replacement in crawl-ref/source/dungeon.cc at line 754 [25.3429798]

B:BD[56.4156] → [54.660:736]

    builder_rc_type skip_build = builder_by_type(level_number, level_type);

[56.4156]

[54.736]

    builder_rc_type skip_build = _builder_by_type(level_number, level_type);

Replacement in crawl-ref/source/dungeon.cc at line 761 [25.3429798]
B:BD[25.3437140] → [25.3437140:3437194]
```
        skip_build = builder_by_branch(level_number);
```
[25.3437140]
[25.3437194]
```
        skip_build = _builder_by_branch(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 772 [25.3429798]
∅:D[64.1367] → [25.3437440:3437511]
∅:D[62.4863] → [25.3437440:3437511]
B:BD[25.3437440] → [25.3437440:3437511]
```
            skip_build = builder_normal(level_number, level_type, sr);
```
[64.1367]
[25.3437511]
```
            skip_build = _builder_normal(level_number, level_type, sr);
```

Replacement in crawl-ref/source/dungeon.cc at line 776 [25.3429798]

B:BD[25.3437551] → [25.3437551:3437605]

            skip_build = builder_basic(level_number);

[25.3437551]

[80.6961]

            skip_build = _builder_basic(level_number);

Replacement in crawl-ref/source/dungeon.cc at line 778 [25.3429798]
∅:D[54.1004] → [25.3437638:3437696]
∅:D[80.7028] → [25.3437638:3437696]
B:BD[25.3437638] → [25.3437638:3437696]
```
                builder_extras(level_number, level_type);
```
[80.7028]
[25.3437696]
```
                _builder_extras(level_number, level_type);
```
Replacement in crawl-ref/source/dungeon.cc at line 783 [25.3429798]
B:BD[56.4224] → [68.280:326]
```
static int num_items_wanted(int level_number)
```
[56.4224]
[68.326]
```
static int _num_items_wanted(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 792 [25.3429798]
∅:D[68.504] → [54.1005:1048]
B:BD[56.4224] → [54.1005:1048]
```
static int num_mons_wanted(int level_type)
```
[68.504]
[56.4290]
```
static int _num_mons_wanted(int level_type)
```
Replacement in crawl-ref/source/dungeon.cc at line 811 [25.3429798]
B:BD[25.3438391] → [54.1443:1469]
```
static void fixup_walls()
```
[25.3438391]
[54.1469]
```
static void _fixup_walls()
```

Replacement in crawl-ref/source/dungeon.cc at line 843 [25.3429798]

B:BD[25.3440975] → [25.3440975:3441040]

        replace_area(0,0,GXM-1,GYM-1,DNGN_ROCK_WALL,vault_wall);

[25.3440975]

[25.3441040]

        _replace_area(0,0,GXM-1,GYM-1,DNGN_ROCK_WALL,vault_wall);

Replacement in crawl-ref/source/dungeon.cc at line 847 [25.3429798]
B:BD[25.3441047] → [54.1477:1511]
```
static void fixup_branch_stairs()
```
[25.3441047]
[54.1511]
```
static void _fixup_branch_stairs()
```
Replacement in crawl-ref/source/dungeon.cc at line 897 [25.3429798]
B:BD[88.352] → [88.352:389]
```
static void fixup_duplicate_stairs()
```
[88.352]
[88.389]
```
static void _fixup_duplicate_stairs()
```

Replacement in crawl-ref/source/dungeon.cc at line 930 [25.3429798]

B:BD[88.1523] → [88.1523:1628]

        FixedVector<coord_def, max_stairs>& stair_list = (i == 0) ?
            up_stairs : down_stairs;

[88.1523]

[88.1628]

        FixedVector<coord_def, max_stairs>& stair_list = (i == 0) ? up_stairs
                                                                  : down_stairs;

Replacement in crawl-ref/source/dungeon.cc at line 1019 [25.3429798]
B:BD[54.1557] → [50.3537:3591]
```
static void dgn_verify_connectivity(unsigned nvaults)
```
[54.1557]
[50.3591]
```
static void _dgn_verify_connectivity(unsigned nvaults)
```

Replacement in crawl-ref/source/dungeon.cc at line 1025 [25.3429798]

B:BD[50.3766] → [50.3766:3827]

        const int newzones = dgn_count_disconnected_zones();

[50.3766]

[4.329]

        const int newzones = _dgn_count_disconnected_zones();

Replacement in crawl-ref/source/dungeon.cc at line 1052 [25.3429798]
∅:D[50.4468] → [54.1557:1623]
B:BD[54.1557] → [54.1557:1623]
```
static void build_dungeon_level(int level_number, int level_type)
```
[50.4468]
[54.1623]
```
static void _build_dungeon_level(int level_number, int level_type)
```

Replacement in crawl-ref/source/dungeon.cc at line 1056 [25.3429798]

B:BD[54.1663] → [54.1663:1720]

    build_layout_skeleton(level_number, level_type, sr);

[25.3443290]

[54.1720]

    _build_layout_skeleton(level_number, level_type, sr);

Replacement in crawl-ref/source/dungeon.cc at line 1068 [25.3429798]
B:BD[54.2115] → [54.2115:2136]
```
        specr_2(sr);
```
[54.2115]
[54.2136]
```
        _specr_2(sr);
```
Replacement in crawl-ref/source/dungeon.cc at line 1076 [25.3429798]
B:BD[54.2348] → [54.2348:2373]
```
        prepare_swamp();
```
[54.2348]
[64.1368]
```
        _prepare_swamp();
```
Replacement in crawl-ref/source/dungeon.cc at line 1078 [25.3429798]
B:BD[64.1414] → [63.540:580]
```
        prepare_shoals( level_number );
```
[64.1414]
[54.2430]
```
        _prepare_shoals( level_number );
```
Replacement in crawl-ref/source/dungeon.cc at line 1083 [25.3429798]
∅:D[80.7140] → [54.2431:2450]
B:BD[54.2431] → [54.2431:2450]
```
    check_doors();
```
[80.7140]
[54.2450]
```
    _check_doors();
```
Replacement in crawl-ref/source/dungeon.cc at line 1086 [25.3429798]
B:BD[54.2530] → [54.2530:2552]
```
        hide_doors();
```
[54.2530]
[54.2643]
```
        _hide_doors();
```

Replacement in crawl-ref/source/dungeon.cc at line 1089 [25.3429798]

B:BD[54.2892] → [54.2892:3049]

    replace_area( 0,0,GXM-1,GYM-1, DNGN_BUILDER_SPECIAL_WALL, DNGN_ROCK_WALL );
    replace_area( 0,0,GXM-1,GYM-1, DNGN_BUILDER_SPECIAL_FLOOR, DNGN_FLOOR );

[54.2892]

[54.3049]

    _replace_area( 0,0,GXM-1,GYM-1, DNGN_BUILDER_SPECIAL_WALL, DNGN_ROCK_WALL );
    _replace_area( 0,0,GXM-1,GYM-1, DNGN_BUILDER_SPECIAL_FLOOR, DNGN_FLOOR );

Replacement in crawl-ref/source/dungeon.cc at line 1100 [25.3429798]

B:BD[50.4796] → [55.31331:31359]

∅:D[59.3102] → [50.4856:4976]

∅:D[55.31359] → [50.4856:4976]

B:BD[50.4856] → [50.4856:4976]

        place_minivaults();
    place_branch_entrances( level_number, level_type );
    place_extra_vaults();
    dgn_verify_connectivity(nvaults);

[50.4796]

[50.4976]

        _place_minivaults();
    _place_branch_entrances( level_number, level_type );
    _place_extra_vaults();
    _dgn_verify_connectivity(nvaults);

Replacement in crawl-ref/source/dungeon.cc at line 1108 [25.3429798]

B:BD[50.5028] → [61.6339:6408]

    place_traps(level_number);
    place_fog_machines(level_number);

[50.5028]

[50.5118]

    _place_traps(level_number);
    _place_fog_machines(level_number);

Replacement in crawl-ref/source/dungeon.cc at line 1112 [25.3429798]

B:BD[54.3069] → [68.505:582]

    builder_items(level_number, level_type, num_items_wanted(level_number));

[54.3069]

[54.3128]

    _builder_items(level_number, level_type, _num_items_wanted(level_number));

Replacement in crawl-ref/source/dungeon.cc at line 1115 [25.3429798]

B:BD[54.3151] → [54.3151:3228]

    builder_monsters(level_number, level_type, num_mons_wanted(level_type));

[54.3151]

[54.3228]

    _builder_monsters(level_number, level_type, _num_mons_wanted(level_type));

Replacement in crawl-ref/source/dungeon.cc at line 1119 [25.3429798]
∅:D[5.361] → [54.3318:3353]
∅:D[89.668] → [54.3318:3353]
B:BD[54.3318] → [54.3318:3353]
```
        place_shops(level_number);
```
[5.361]
[54.3353]
```
        _place_shops(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 1121 [25.3429798]
B:BD[54.3354] → [54.3354:3400]
```
    fixup_walls();
    fixup_branch_stairs();
```
[54.3354]
[54.3670]
```
    _fixup_walls();
    _fixup_branch_stairs();
```
Replacement in crawl-ref/source/dungeon.cc at line 1124 [25.3429798]
B:BD[54.3671] → [54.3671:3691]
```
    place_altars();
```
[54.3671]
[54.3691]
```
    _place_altars();
```

Replacement in crawl-ref/source/dungeon.cc at line 1128 [25.3429798]

B:BD[25.3443309] → [62.4939:5027]

B:BD[62.5027] → [64.1441:1483]

∅:D[64.1483] → [25.3443387:3443426]

∅:D[62.5070] → [25.3443387:3443426]

B:BD[25.3443387] → [25.3443387:3443426]

    if (!player_in_branch(BRANCH_COCYTUS) &&
        !player_in_branch(BRANCH_SWAMP) &&
        !player_in_branch(BRANCH_SHOALS))
        prepare_water( level_number );

[25.3443309]

[85.4055]

    if (!player_in_branch(BRANCH_COCYTUS)
        && !player_in_branch(BRANCH_SWAMP)
        && !player_in_branch(BRANCH_SHOALS))
    {
        _prepare_water( level_number );
    }

Replacement in crawl-ref/source/dungeon.cc at line 1137 [25.3429798]
B:BD[85.4145] → [85.4145:4181]
```
        fixup_pandemonium_stairs();
```
[85.4145]
[88.4312]
```
        _fixup_pandemonium_stairs();
```
Replacement in crawl-ref/source/dungeon.cc at line 1139 [25.3429798]
B:BD[88.4313] → [88.4313:4343]
```
    fixup_duplicate_stairs();
```
[88.4313]
[25.3443426]
```
    _fixup_duplicate_stairs();
```
Replacement in crawl-ref/source/dungeon.cc at line 1143 [25.3429798]
B:BD[90.11948] → [90.11948:11989]
```
static char fix_black_colour(char incol)
```
[90.11948]
[90.11989]
```
static char _fix_black_colour(char incol)
```

Replacement in crawl-ref/source/dungeon.cc at line 1160 [25.3429798]

B:BD[81.574] → [91.5778:5857]

        env.floor_colour = fix_black_colour((char)mcolour[env.mons_alloc[9]]);

[81.574]

[81.647]

        env.floor_colour = _fix_black_colour((char)mcolour[env.mons_alloc[9]]);

Replacement in crawl-ref/source/dungeon.cc at line 1170 [25.3429798]

B:BD[81.820] → [14.7014:7092]

        env.rock_colour = fix_black_colour((char)mcolour[env.mons_alloc[8]]);

[81.820]

[90.12253]

        env.rock_colour = _fix_black_colour((char)mcolour[env.mons_alloc[8]]);

Replacement in crawl-ref/source/dungeon.cc at line 1173 [25.3429798]
B:BD[90.12256] → [66.8055:8091]
```
static void dgn_set_floor_colours()
```
[90.12256]
[90.12285]
```
static void _dgn_set_floor_colours()
```
Replacement in crawl-ref/source/dungeon.cc at line 1202 [25.3429798]
B:BD[25.3548051] → [62.5155:5181]
```
static void check_doors()
```
[25.3464870]
[25.3548081]
```
static void _check_doors()
```
Replacement in crawl-ref/source/dungeon.cc at line 1228 [25.3429798]
B:BD[25.3548974] → [62.5182:5207]
```
static void hide_doors()
```
[25.3548974]
[25.3549003]
```
static void _hide_doors()
```

Replacement in crawl-ref/source/dungeon.cc at line 1262 [25.3429798]

B:BD[62.5279] → [51.9196:9315]

static void place_ellipse(int x, int y, int a, int b,
                          dungeon_feature_type feat, int margin)

[62.5279]

[25.3550051]

static void _place_ellipse(int x, int y, int a, int b,
                           dungeon_feature_type feat, int margin)

Replacement in crawl-ref/source/dungeon.cc at line 1274 [25.3429798]

B:BD[62.5670] → [92.8078:8201]

static int count_feature_in_box(int x0, int y0, int x1, int y1,
                                dungeon_feature_type feat)

[62.5670]

[62.5786]

static int _count_feature_in_box(int x0, int y0, int x1, int y1,
                                 dungeon_feature_type feat)

Insertion in crawl-ref/source/dungeon.cc at line 1284 [25.3429798]
[19.7015]
[62.5951]
```
        
```

Replacement in crawl-ref/source/dungeon.cc at line 1288 [25.3429798]

B:BD[92.8319] → [92.8319:8450]

static int count_antifeature_in_box(int x0, int y0, int x1, int y1,
                                    dungeon_feature_type feat)

[92.8319]

[92.8450]

static int _count_antifeature_in_box(int x0, int y0, int x1, int y1,
                                     dungeon_feature_type feat)

Replacement in crawl-ref/source/dungeon.cc at line 1291 [25.3429798]

B:BD[92.8452] → [92.8452:8521]

    return (x1-x0)*(y1-y0) - count_feature_in_box(x0,y0,x1,y1,feat);

[92.8452]

[92.8521]

    return (x1-x0)*(y1-y0) - _count_feature_in_box(x0,y0,x1,y1,feat);

Replacement in crawl-ref/source/dungeon.cc at line 1295 [25.3429798]

B:BD[92.8588] → [92.8588:8657]

static int count_neighbours(int x, int y, dungeon_feature_type feat)

[92.8588]

[92.8657]

static int _count_neighbours(int x, int y, dungeon_feature_type feat)

Replacement in crawl-ref/source/dungeon.cc at line 1297 [25.3429798]

B:BD[92.8659] → [92.8659:8718]

    return count_feature_in_box(x-1, y-1, x+2, y+2, feat);

[92.8659]

[62.5970]

    return _count_feature_in_box(x-1, y-1, x+2, y+2, feat);

Replacement in crawl-ref/source/dungeon.cc at line 1300 [25.3429798]

B:BD[62.5973] → [93.165:225]

B:BD[93.225] → [51.9316:9432]

static void replace_in_grid(int x1, int y1, int x2, int y2,
                            dungeon_feature_type oldfeat,
                            dungeon_feature_type newfeat)

[62.5973]

[93.279]

static void _replace_in_grid(int x1, int y1, int x2, int y2,
                             dungeon_feature_type oldfeat,
                             dungeon_feature_type newfeat)

Replacement in crawl-ref/source/dungeon.cc at line 1312 [25.3429798]

B:BD[62.5974] → [94.427:503]

static void connected_flood(int margin, int i, int j, bool taken[GXM][GYM])

[62.5974]

[62.6004]

static void _connected_flood(int margin, int i, int j, bool taken[GXM][GYM])

Replacement in crawl-ref/source/dungeon.cc at line 1323 [25.3429798]

B:BD[94.762] → [94.762:830]

            connected_flood(margin, i + idelta, j + jdelta, taken);

[94.762]

[94.830]

            _connected_flood(margin, i + idelta, j + jdelta, taken);

Replacement in crawl-ref/source/dungeon.cc at line 1327 [25.3429798]
B:BD[94.902] → [94.902:941]
```
static int count_connected(int margin)
```
[94.902]
[94.941]
```
static int _count_connected(int margin)
```

Replacement in crawl-ref/source/dungeon.cc at line 1345 [25.3429798]

B:BD[94.1390] → [94.1390:1441]

                connected_flood(margin,i,j,taken);

[94.1390]

[94.1441]

                _connected_flood(margin,i,j,taken);

Replacement in crawl-ref/source/dungeon.cc at line 1351 [25.3429798]

B:BD[94.1477] → [94.1477:1606]

static void place_base_islands(int margin, int num_islands, int estradius,
                               coord_def centres[10])

[94.1477]

[94.1606]

static void _place_base_islands(int margin, int num_islands, int estradius,
                                coord_def centres[10])

Replacement in crawl-ref/source/dungeon.cc at line 1387 [25.3429798]
B:BD[62.7757] → [62.7757:7789]
```
        } while ( !centre_ok );
```
[62.7757]
[62.7789]
```
        }
        while ( !centre_ok );
```

Replacement in crawl-ref/source/dungeon.cc at line 1391 [25.3429798]

B:BD[62.7852] → [62.7852:7930]

        place_ellipse( centres[i].x, centres[i].y, a, b, DNGN_FLOOR, margin);

[62.7852]

[62.7930]

        _place_ellipse( centres[i].x, centres[i].y, a, b, DNGN_FLOOR, margin);

Replacement in crawl-ref/source/dungeon.cc at line 1395 [25.3429798]
B:BD[94.1612] → [63.581:626]
```
static void prepare_shoals(int level_number)
```
[94.1612]
[94.1642]
```
static void _prepare_shoals(int level_number)
```

Replacement in crawl-ref/source/dungeon.cc at line 1419 [25.3429798]

∅:D[19.7377] → [94.2277:2346]

B:BD[94.2277] → [94.2277:2346]

        place_base_islands(margin, num_islands, estradius, centres);

[19.7377]

[19.7378]

        _place_base_islands(margin, num_islands, estradius, centres);

Replacement in crawl-ref/source/dungeon.cc at line 1421 [25.3429798]

B:BD[19.7384] → [19.7384:7459]

    while ( ++num_tries < 100 && count_connected(margin) != num_islands );

[19.7384]

[19.7459]

    while ( ++num_tries < 100 && _count_connected(margin) != num_islands );

Replacement in crawl-ref/source/dungeon.cc at line 1425 [25.3429798]
B:BD[94.2532] → [94.2532:2578]
```
         num_tries, count_connected(margin));
```
[94.2532]
[94.2578]
```
         num_tries, _count_connected(margin));
```

Replacement in crawl-ref/source/dungeon.cc at line 1433 [25.3429798]

B:BD[19.7510] → [19.7510:7589]

                && count_neighbours(i, j, DNGN_FLOOR) > random2(random2(3)+1))

[19.7510]

[19.7589]

                && _count_neighbours(i, j, DNGN_FLOOR) > random2(random2(3)+1))

Replacement in crawl-ref/source/dungeon.cc at line 1470 [25.3429798]

B:BD[93.649] → [93.649:768]

    replace_in_grid(margin, margin, GXM-margin, GYM-margin,
                    DNGN_SHALLOW_WATER, DNGN_WATER_STUCK);

[93.649]

[93.768]

    _replace_in_grid(margin, margin, GXM-margin, GYM-margin,
                     DNGN_SHALLOW_WATER, DNGN_WATER_STUCK);

Replacement in crawl-ref/source/dungeon.cc at line 1479 [25.3429798]

B:BD[93.1015] → [93.1015:1091]

                    int badness = count_neighbours(x, y, DNGN_WATER_STUCK);

[93.1015]

[93.1091]

                    int badness = _count_neighbours(x, y, DNGN_WATER_STUCK);

Replacement in crawl-ref/source/dungeon.cc at line 1484 [25.3429798]

∅:D[19.7688] → [93.1243:1361]

B:BD[93.1243] → [93.1243:1361]

        replace_in_grid(margin, margin, GXM-margin, GYM-margin,
                        DNGN_LAVA, DNGN_WATER_STUCK);

[19.7688]

[93.1361]

        _replace_in_grid(margin, margin, GXM-margin, GYM-margin,
                         DNGN_LAVA, DNGN_WATER_STUCK);

Replacement in crawl-ref/source/dungeon.cc at line 1487 [25.3429798]

B:BD[93.1367] → [93.1367:1486]

    replace_in_grid(margin, margin, GXM-margin, GYM-margin,
                    DNGN_WATER_STUCK, DNGN_SHALLOW_WATER);

[93.1367]

[62.9155]

    _replace_in_grid(margin, margin, GXM-margin, GYM-margin,
                     DNGN_WATER_STUCK, DNGN_SHALLOW_WATER);

Replacement in crawl-ref/source/dungeon.cc at line 1501 [25.3429798]
∅:D[19.7710] → [63.767:822]
B:BD[63.767] → [63.767:822]
```
            vaultidx = dgn_random_map_for_place(true);
```
[19.7710]
[19.7711]
```
            vaultidx = _dgn_random_map_for_place(true);
```

Replacement in crawl-ref/source/dungeon.cc at line 1506 [25.3429798]

B:BD[94.3417] → [71.583:653]

        build_minivaults( level_number, vaultidx, true, false, false,

[94.3417]

[71.653]

        _build_minivaults( level_number, vaultidx, true, false, false,

Replacement in crawl-ref/source/dungeon.cc at line 1514 [25.3429798]
∅:D[19.7849] → [63.1172:1231]
B:BD[63.1172] → [63.1172:1231]
```
                vaultidx = dgn_random_map_for_place(true);
```
[19.7849]
[19.7850]
```
                vaultidx = _dgn_random_map_for_place(true);
```

Replacement in crawl-ref/source/dungeon.cc at line 1519 [25.3429798]

∅:D[19.7990] → [71.694:812]

B:BD[63.1340] → [71.694:812]

            build_minivaults( level_number, vaultidx, true, false, false,
                              centres[i] );

[19.7990]

[63.1455]

            _build_minivaults( level_number, vaultidx, true, false, false,
                               centres[i] );

Replacement in crawl-ref/source/dungeon.cc at line 1552 [25.3429798]
B:BD[62.9602] → [62.9602:9630]
```
static void prepare_swamp()
```
[62.9602]
[62.9630]
```
static void _prepare_swamp()
```
Replacement in crawl-ref/source/dungeon.cc at line 1583 [25.3429798]
B:BD[25.3551216] → [25.3551216:3551262]
```
static void prepare_water( int level_number )
```
[25.3551216]
[25.3551262]
```
static void _prepare_water( int level_number )
```

Replacement in crawl-ref/source/dungeon.cc at line 1618 [25.3429798]

B:BD[25.3552523] → [51.9686:9798]

static bool find_in_area(int sx, int sy, int ex, int ey,
                         dungeon_feature_type feature)

[25.3552523]

[25.3552603]

static bool _find_in_area(int sx, int sy, int ex, int ey,
                          dungeon_feature_type feature)

Replacement in crawl-ref/source/dungeon.cc at line 1639 [25.3429798]

B:BD[25.3553031] → [25.3553031:3553104]

B:BD[25.3553104] → [51.9799:9945]

static bool make_box(int room_x1, int room_y1, int room_x2, int room_y2,
                     dungeon_feature_type floor,
                     dungeon_feature_type wall,
                     dungeon_feature_type avoid)

[25.3553031]

[25.3553170]

static bool _make_box(int room_x1, int room_y1, int room_x2, int room_y2,
                      dungeon_feature_type floor,
                      dungeon_feature_type wall,
                      dungeon_feature_type avoid)

Replacement in crawl-ref/source/dungeon.cc at line 1647 [25.3429798]

B:BD[25.3553215] → [25.3553215:3553280]

    if (find_in_area(room_x1, room_y1, room_x2, room_y2, avoid))

[25.3553215]

[25.3553280]

    if (_find_in_area(room_x1, room_y1, room_x2, room_y2, avoid))

Replacement in crawl-ref/source/dungeon.cc at line 1679 [25.3429798]

B:BD[32.960584] → [54.3853:3927]

static builder_rc_type builder_by_type(int level_number, char level_type)

[32.960584]

[25.3554050]

static builder_rc_type _builder_by_type(int level_number, char level_type)

Replacement in crawl-ref/source/dungeon.cc at line 1683 [25.3429798]
B:BD[55.31402] → [66.8612:8654]
```
        portal_vault_level(level_number);
```
[55.31402]
[55.31438]
```
        _portal_vault_level(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 1689 [25.3429798]
B:BD[25.3554097] → [25.3554097:3554136]
```
        labyrinth_level(level_number);
```
[25.3554097]
[55.31479]
```
        _labyrinth_level(level_number);
```

Replacement in crawl-ref/source/dungeon.cc at line 1736 [25.3429798]

B:BD[32.961082] → [80.7141:7211]

            ensure_vault_placed( build_vaults(level_number, vault) );

[32.961082]

[25.3555091]

            _ensure_vault_placed( _build_vaults(level_number, vault) );

Replacement in crawl-ref/source/dungeon.cc at line 1740 [25.3429798]
B:BD[25.3555124] → [25.3555124:3555164]
```
            plan_main(level_number, 0);
```
[25.3555124]
[95.148622]
```
            _plan_main(level_number, 0);
```

Replacement in crawl-ref/source/dungeon.cc at line 1743 [25.3429798]

B:BD[32.961216] → [32.961216:961246]

B:BD[32.961246] → [96.1026:1101]

            if (vault == -1) 
                end(1, false, "Failed to build Pandemonium minivault!\n");

[32.961216]

[96.1101]

            // never output because of above assert
//            if (vault == -1)
//                end(1, false, "Failed to build Pandemonium minivault!\n");

Replacement in crawl-ref/source/dungeon.cc at line 1747 [25.3429798]
∅:D[96.1114] → [32.961376:961427]
B:BD[32.961376] → [32.961376:961427]
```
            build_minivaults(level_number, vault);
```
[96.1114]
[25.3555226]
```
            _build_minivaults(level_number, vault);
```
Replacement in crawl-ref/source/dungeon.cc at line 1757 [25.3429798]
B:BD[55.31542] → [66.8655:8704]
```
static void portal_vault_level(int level_number)
```
[55.31542]
[55.31576]
```
static void _portal_vault_level(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 1793 [25.3429798]
∅:D[66.9232] → [97.4030:4061]
B:BD[97.4030] → [97.4030:4061]
```
        } while (vault == -1);
```
[66.9232]
[97.4061]
```
        }
        while (vault == -1);
```

Replacement in crawl-ref/source/dungeon.cc at line 1802 [25.3429798]

B:BD[55.32237] → [66.9289:9355]

        ensure_vault_placed( build_vaults(level_number, vault) );

[55.32237]

[66.9355]

        _ensure_vault_placed( _build_vaults(level_number, vault) );

Replacement in crawl-ref/source/dungeon.cc at line 1805 [25.3429798]

B:BD[55.32243] → [66.9365:9451]

        plan_main(level_number, 0);
        place_minivaults(level_name, 1, 1, true);

[55.32243]

[66.9451]

        _plan_main(level_number, 0);
        _place_minivaults(level_name, 1, 1, true);

Replacement in crawl-ref/source/dungeon.cc at line 1828 [25.3429798]
B:BD[25.3555309] → [56.4633:4688]
```
static int random_portal_vault(const std::string &tag)
```
[25.3555309]
[56.4688]
```
static int _random_portal_vault(const std::string &tag)
```

Replacement in crawl-ref/source/dungeon.cc at line 1833 [25.3429798]

B:BD[56.4736] → [56.4736:4814]

static bool place_portal_vault(int stair, const std::string &tag, int dlevel)

[56.4736]

[56.4814]

static bool _place_portal_vault(int stair, const std::string &tag, int dlevel)

Replacement in crawl-ref/source/dungeon.cc at line 1835 [25.3429798]
B:BD[56.4816] → [56.4816:4864]
```
    const int vault = random_portal_vault(tag);
```
[56.4816]
[56.4864]
```
    const int vault = _random_portal_vault(tag);
```

Replacement in crawl-ref/source/dungeon.cc at line 1839 [25.3429798]

B:BD[56.4910] → [56.4910:4966]

    return build_secondary_vault(dlevel, vault, stair);

[56.4910]

[56.4966]

    return _build_secondary_vault(dlevel, vault, stair);

Replacement in crawl-ref/source/dungeon.cc at line 1842 [25.3429798]
B:BD[56.4969] → [98.2878:2929]
```
static int dgn_random_map_for_place(bool wantmini)
```
[56.4969]
[25.3555462]
```
static int _dgn_random_map_for_place(bool wantmini)
```
Replacement in crawl-ref/source/dungeon.cc at line 1861 [25.3429798]
∅:D[89.849] → [54.4207:4266]
B:BD[95.149175] → [54.4207:4266]
```
static builder_rc_type builder_by_branch(int level_number)
```
[89.849]
[95.149222]
```
static builder_rc_type _builder_by_branch(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 1863 [25.3429798]
B:BD[95.149224] → [98.3129:3184]
```
    const int vault = dgn_random_map_for_place(false);
```
[95.149224]
[95.149283]
```
    const int vault = _dgn_random_map_for_place(false);
```

Replacement in crawl-ref/source/dungeon.cc at line 1867 [25.3429798]

B:BD[32.961873] → [80.7212:7278]

        ensure_vault_placed( build_vaults(level_number, vault) );

[32.961873]

[54.4267]

        _ensure_vault_placed( _build_vaults(level_number, vault) );

Replacement in crawl-ref/source/dungeon.cc at line 1879 [25.3429798]
B:BD[25.3558410] → [25.3558410:3558466]
```
        spotty_level(false, 100 + random2(500), false);
```
[25.3558410]
[54.4351]
```
        _spotty_level(false, 100 + random2(500), false);
```

Replacement in crawl-ref/source/dungeon.cc at line 1888 [25.3429798]

B:BD[60.148092] → [55.32703:32784]

static void place_minivaults(const std::string &tag, int lo, int hi, bool force)

[60.148092]

[60.148145]

static void _place_minivaults(const std::string &tag, int lo, int hi, bool force)

Replacement in crawl-ref/source/dungeon.cc at line 1906 [25.3429798]

B:BD[55.33180] → [55.33180:33233]

            build_minivaults(you.your_level, vault);

[55.33180]

[55.33233]

                
            _build_minivaults(you.your_level, vault);

Replacement in crawl-ref/source/dungeon.cc at line 1918 [25.3429798]

B:BD[99.7481] → [55.33251:33304]

            build_minivaults(you.your_level, vault);

[99.7481]

[99.7532]

            _build_minivaults(you.your_level, vault);

Replacement in crawl-ref/source/dungeon.cc at line 1926 [25.3429798]

B:BD[60.148305] → [98.3323:3381]

        const int vault = dgn_random_map_for_place(true);

[60.148305]

[60.148366]

        const int vault = _dgn_random_map_for_place(true);

Replacement in crawl-ref/source/dungeon.cc at line 1938 [25.3429798]
B:BD[58.1459] → [55.33417:33466]
```
        build_minivaults(you.your_level, vault);
```
[58.1459]
[58.1460]
```
        _build_minivaults(you.your_level, vault);
```

Replacement in crawl-ref/source/dungeon.cc at line 1947 [25.3429798]

B:BD[25.3559610] → [54.4439:4565]

static builder_rc_type builder_normal(int level_number, char level_type,
                                      spec_room &sr)

[25.3559610]

[25.3559687]

static builder_rc_type _builder_normal(int level_number, char level_type,
                                       spec_room &sr)

Replacement in crawl-ref/source/dungeon.cc at line 1955 [25.3429798]
B:BD[25.3559771] → [98.3382:3432]
```
    int vault = dgn_random_map_for_place(false); 
```
[25.3559771]
[32.962295]
```
    int vault = _dgn_random_map_for_place(false);
```

Replacement in crawl-ref/source/dungeon.cc at line 1978 [25.3429798]

B:BD[25.3559817] → [80.7279:7345]

        ensure_vault_placed( build_vaults(level_number, vault) );

[25.3559817]

[54.4566]

        _ensure_vault_placed( _build_vaults(level_number, vault) );

Replacement in crawl-ref/source/dungeon.cc at line 1984 [25.3429798]
B:BD[25.3560002] → [32.962687:962721]
```
        city_level(level_number);
```
[25.3560002]
[54.4594]
```
        _city_level(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 1991 [25.3429798]
B:BD[25.3560227] → [25.3560227:3560265]
```
            city_level(level_number);
```
[25.3560227]
[25.3560265]
```
            _city_level(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 1993 [25.3429798]
B:BD[25.3560278] → [25.3560278:3560318]
```
            plan_main(level_number, 4);
```
[25.3560278]
[54.4622]
```
            _plan_main(level_number, 4);
```
Replacement in crawl-ref/source/dungeon.cc at line 2001 [25.3429798]
B:BD[25.3560437] → [25.3560437:3560485]
```
            spotty_level(false, 0, coinflip());
```
[25.3560437]
[54.4650]
```
            _spotty_level(false, 0, coinflip());
```
Replacement in crawl-ref/source/dungeon.cc at line 2007 [25.3429798]
B:BD[25.3560559] → [25.3560559:3560586]
```
            bigger_room();
```
[25.3560559]
[54.4682]
```
            _bigger_room();
```
Replacement in crawl-ref/source/dungeon.cc at line 2014 [25.3429798]
B:BD[25.3560698] → [25.3560698:3560734]
```
        plan_main(level_number, 0);
```
[25.3560698]
[99.7692]
```
        _plan_main(level_number, 0);
```
Replacement in crawl-ref/source/dungeon.cc at line 2026 [25.3429798]
B:BD[25.3561028] → [25.3561028:3561068]
```
        roguey_level(level_number, sr);
```
[25.3561028]
[99.7723]
```
        _roguey_level(level_number, sr);
```
Replacement in crawl-ref/source/dungeon.cc at line 2034 [25.3429798]
B:BD[25.3561405] → [25.3561405:3561447]
```
                city_level(level_number);
```
[25.3561405]
[25.3561447]
```
                _city_level(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 2036 [25.3429798]
B:BD[25.3561464] → [25.3561464:3561508]
```
                plan_main(level_number, 4);
```
[25.3561464]
[25.3561508]
```
                _plan_main(level_number, 4);
```
Replacement in crawl-ref/source/dungeon.cc at line 2044 [25.3429798]
B:BD[25.3561714] → [25.3561714:3561754]
```
        special_room(level_number, sr);
```
[25.3561714]
[25.3561754]
```
        _special_room(level_number, sr);
```
Replacement in crawl-ref/source/dungeon.cc at line 2050 [25.3429798]
B:BD[32.963225] → [54.4806:4861]
```
static builder_rc_type builder_basic(int level_number)
```
[32.963225]
[25.3561869]
```
static builder_rc_type _builder_basic(int level_number)
```

Replacement in crawl-ref/source/dungeon.cc at line 2059 [25.3429798]

B:BD[25.3562159] → [25.3562159:3562298]

    make_trail( 35, 30, 35, 20, corrlength, intersect_chance, no_corr,
                DNGN_STONE_STAIRS_DOWN_I, DNGN_STONE_STAIRS_UP_I );

[25.3562159]

[25.3562298]

    _make_trail( 35, 30, 35, 20, corrlength, intersect_chance, no_corr,
                 DNGN_STONE_STAIRS_DOWN_I, DNGN_STONE_STAIRS_UP_I );

Replacement in crawl-ref/source/dungeon.cc at line 2062 [25.3429798]

B:BD[25.3562299] → [25.3562299:3562440]

    make_trail( 10, 15, 10, 15, corrlength, intersect_chance, no_corr,
                DNGN_STONE_STAIRS_DOWN_II, DNGN_STONE_STAIRS_UP_II );

[25.3562299]

[25.3562440]

    _make_trail( 10, 15, 10, 15, corrlength, intersect_chance, no_corr,
                 DNGN_STONE_STAIRS_DOWN_II, DNGN_STONE_STAIRS_UP_II );

Replacement in crawl-ref/source/dungeon.cc at line 2065 [25.3429798]

B:BD[25.3562441] → [25.3562441:3562568]

    make_trail(50,20,10,15,corrlength,intersect_chance,no_corr,
        DNGN_STONE_STAIRS_DOWN_III, DNGN_STONE_STAIRS_UP_III);

[25.3562441]

[25.3562568]

    _make_trail( 50, 20, 10, 15, corrlength, intersect_chance, no_corr,
                 DNGN_STONE_STAIRS_DOWN_III, DNGN_STONE_STAIRS_UP_III);

Replacement in crawl-ref/source/dungeon.cc at line 2070 [25.3429798]

B:BD[25.3562601] → [25.3562601:3562676]

B:BD[25.3562676] → [19.8676:8722]

        make_trail( 10, 20, 40, 20, corrlength, intersect_chance, no_corr,
                    DNGN_ESCAPE_HATCH_DOWN );

[25.3562601]

[25.3562721]

        _make_trail( 10, 20, 40, 20, corrlength, intersect_chance, no_corr,
                     DNGN_ESCAPE_HATCH_DOWN );

Replacement in crawl-ref/source/dungeon.cc at line 2076 [25.3429798]

B:BD[25.3562760] → [25.3562760:3562835]

B:BD[25.3562835] → [19.8723:8767]

        make_trail( 50, 20, 40, 20, corrlength, intersect_chance, no_corr,
                    DNGN_ESCAPE_HATCH_UP );

[25.3562760]

[25.3562878]

        _make_trail( 50, 20, 40, 20, corrlength, intersect_chance, no_corr,
                     DNGN_ESCAPE_HATCH_UP );

Replacement in crawl-ref/source/dungeon.cc at line 2082 [25.3429798]
B:BD[25.3562933] → [25.3562933:3562965]
```
        big_room(level_number);
```
[25.3562933]
[25.3562965]
```
        _big_room(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 2085 [25.3429798]
B:BD[25.3563021] → [25.3563021:3563058]
```
        diamond_rooms(level_number);
```
[25.3563021]
[25.3563058]
```
        _diamond_rooms(level_number);
```
Replacement in crawl-ref/source/dungeon.cc at line 2107 [25.3429798]
B:BD[25.3563645] → [25.3563645:3563703]
```
        if (!make_room(sx,sy,ex,ey,max_doors, doorlevel))
```
[25.3563645]
[25.3563703]
```
        if (!_make_room(sx,sy,ex,ey,max_doors, doorlevel))
```
Replacement in crawl-ref/source/dungeon.cc at line 2131 [25.3429798]
B:BD[25.3564112] → [25.3564112:3564170]
```
        if (!make_room(sx,sy,ex,ey,max_doors, doorlevel))
```
[25.3564112]
[25.3564170]
```
        if (!_make_room(sx,sy,ex,ey,max_doors, doorlevel))
```
Replacement in crawl-ref/source/dungeon.cc at line 2147 [25.3429798]
B:BD[25.3564346] → [25.3564346:3564409]
```
static void builder_extras( int level_number, int level_type )
```
[25.3564346]
[25.3564409]
```
static void _builder_extras( int level_number, int level_type )
```

Replacement in crawl-ref/source/dungeon.cc at line 2153 [25.3429798]

∅:D[19.8774] → [55.33494:33558]

B:BD[55.33494] → [55.33494:33558]

B:BD[55.33697] → [55.33697:33747]

        place_specific_stair(DNGN_ENTER_LABYRINTH, "lab_entry",
                             level_number, true);

[19.8774]

[19.8775]

        _place_specific_stair(DNGN_ENTER_LABYRINTH, "lab_entry",
                              level_number, true);

Replacement in crawl-ref/source/dungeon.cc at line 2159 [25.3429798]

B:BD[25.3564795] → [2.340:445]

        many_pools( level_number < 11 || coinflip() ?
                    DNGN_DEEP_WATER : DNGN_LAVA );

[25.3564795]

[25.3564861]

        _many_pools( level_number < 11 || coinflip() ?
                     DNGN_DEEP_WATER : DNGN_LAVA );

Replacement in crawl-ref/source/dungeon.cc at line 2181 [25.3429798]
B:BD[25.3565401] → [25.3565401:3565440]
```
            build_river( river_type );
```
[25.3565401]
[25.3565440]
```
            _build_river( river_type );
```
Replacement in crawl-ref/source/dungeon.cc at line 2183 [25.3429798]
B:BD[25.3565455] → [25.3565455:3565493]
```
            build_lake( river_type );
```
[25.3565455]
[25.3565493]
```
            _build_lake( river_type );
```
Replacement in crawl-ref/source/dungeon.cc at line 2190 [25.3429798]
B:BD[25.3565617] → [25.3565617:3565656]
```
            build_river( river_type );
```
[25.3565617]
[25.3565656]
```
            _build_river( river_type );
```
Replacement in crawl-ref/source/dungeon.cc at line 2192 [25.3429798]
B:BD[25.3565671] → [25.3565671:3565709]
```
            build_lake( river_type );
```
[25.3565671]
[25.3565709]
```
            _build_lake( river_type );
```
Replacement in crawl-ref/source/dungeon.cc at line 2196 [25.3429798]
B:BD[25.3565764] → [25.3565764:3565799]
```
        build_river( river_type );
```
[25.3565764]
[25.3565799]
```
        _build_river( river_type );
```

Replacement in crawl-ref/source/dungeon.cc at line 2199 [25.3429798]

B:BD[25.3565857] → [25.3565857:3565925]

        build_lake( (river_type != DNGN_SHALLOW_WATER) ? river_type

[25.3565857]

[25.3565925]

        _build_lake( (river_type != DNGN_SHALLOW_WATER) ? river_type

Replacement in crawl-ref/source/dungeon.cc at line 2223 [25.3429798]
∅:D[19.9523] → [25.3566032:3566074]
B:BD[25.3566032] → [25.3566032:3566074]
```
static void place_traps(int level_number)
```
[19.9523]
[25.3566074]
```
static void _place_traps(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 2270 [25.3429798]
B:BD[25.3567580] → [61.6633:6682]
```
static void place_fog_machines(int level_number)
```
[25.3567580]
[61.6682]
```
static void _place_fog_machines(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 2305 [25.3429798]
∅:D[61.7482] → [51.10518:10580]
B:BD[25.3567580] → [51.10518:10580]
```
static void place_specific_feature(dungeon_feature_type feat)
```
[61.7482]
[25.3567634]
```
static void _place_specific_feature(dungeon_feature_type feat)
```

Replacement in crawl-ref/source/dungeon.cc at line 2319 [25.3429798]

B:BD[25.3567830] → [51.10581:10699]

B:BD[51.10699] → [55.33748:33843]

static void place_specific_stair(dungeon_feature_type stair,
                                 const std::string &tag,
                                 int dlevel,
                                 bool vault_only)

[25.3567830]

[56.5121]

static void _place_specific_stair(dungeon_feature_type stair,
                                  const std::string &tag,
                                  int dlevel,
                                  bool vault_only)

Replacement in crawl-ref/source/dungeon.cc at line 2324 [25.3429798]

B:BD[56.5123] → [55.33844:33909]

    if ((tag.empty() || !place_portal_vault(stair, tag, dlevel))

[56.5123]

[55.33909]

    if ((tag.empty() || !_place_portal_vault(stair, tag, dlevel))

Replacement in crawl-ref/source/dungeon.cc at line 2327 [25.3429798]
∅:D[55.33939] → [56.5187:5226]
B:BD[56.5187] → [56.5187:5226]
```
        place_specific_feature(stair);
```
[55.33939]
[55.33940]
```
        _place_specific_feature(stair);
```
Replacement in crawl-ref/source/dungeon.cc at line 2331 [25.3429798]
B:BD[25.3567831] → [57.1031:1064]
```
static void place_extra_vaults()
```
[25.3567831]
[57.1064]
```
static void _place_extra_vaults()
```

Replacement in crawl-ref/source/dungeon.cc at line 2344 [25.3429798]

∅:D[72.1862] → [57.1219:1296]

B:BD[57.1219] → [57.1219:1296]

        if (vault != -1 && build_secondary_vault(you.your_level, vault, -1))

[72.1862]

[57.1296]

        if (vault != -1 && _build_secondary_vault(you.your_level, vault, -1))

Replacement in crawl-ref/source/dungeon.cc at line 2349 [25.3429798]
∅:D[57.1335] → [25.3567831:3567895]
B:BD[25.3567831] → [25.3567831:3567895]
```
static void place_branch_entrances(int dlevel, char level_type)
```
[57.1335]
[25.3567895]
```
static void _place_branch_entrances(int dlevel, char level_type)
```

Replacement in crawl-ref/source/dungeon.cc at line 2360 [25.3429798]

B:BD[25.3568144] → [56.5229:5302]

            place_specific_stair(DNGN_ENTER_HELL, "hell_entry", dlevel);

[25.3568144]

[25.3568195]

            _place_specific_stair(DNGN_ENTER_HELL, "hell_entry", dlevel);

Replacement in crawl-ref/source/dungeon.cc at line 2364 [25.3429798]

B:BD[25.3568308] → [56.5303:5382]

            place_specific_stair(DNGN_ENTER_PANDEMONIUM, "pan_entry", dlevel);

[25.3568308]

[25.3568366]

            _place_specific_stair(DNGN_ENTER_PANDEMONIUM, "pan_entry", dlevel);

Replacement in crawl-ref/source/dungeon.cc at line 2368 [25.3429798]

B:BD[25.3568474] → [56.5383:5458]

            place_specific_stair(DNGN_ENTER_ABYSS, "abyss_entry", dlevel);

[25.3568474]

[25.3568526]

            _place_specific_stair(DNGN_ENTER_ABYSS, "abyss_entry", dlevel);

Replacement in crawl-ref/source/dungeon.cc at line 2400 [25.3429798]

B:BD[56.5615] → [19.10188:10268]

            place_specific_stair( branches[i].entry_stairs, entry_tag, dlevel);

[56.5615]

[100.13197]

            _place_specific_stair( branches[i].entry_stairs, entry_tag, dlevel);

Replacement in crawl-ref/source/dungeon.cc at line 2405 [25.3429798]

B:BD[25.3570456] → [25.3570456:3570528]

B:BD[25.3570528] → [51.10745:10904]

static void make_trail(int xs, int xr, int ys, int yr, int corrlength, 
                       int intersect_chance, int no_corr,
                       dungeon_feature_type begin, 
                       dungeon_feature_type end)

[25.3570456]

[25.3570650]

static void _make_trail(int xs, int xr, int ys, int yr, int corrlength,
                        int intersect_chance, int no_corr,
                        dungeon_feature_type begin,
                        dungeon_feature_type end)

Replacement in crawl-ref/source/dungeon.cc at line 2564 [25.3429798]
B:BD[25.3574210] → [25.3574210:3574250]
```
static int good_door_spot(int x, int y)
```
[25.3574210]
[25.3574250]
```
static int _good_door_spot(int x, int y)
```

Replacement in crawl-ref/source/dungeon.cc at line 2576 [25.3429798]

B:BD[25.3574462] → [25.3574462:3574542]

static bool make_room(int sx,int sy,int ex,int ey,int max_doors, int doorlevel)

[25.3574462]

[25.3574542]

static bool _make_room(int sx,int sy,int ex,int ey,int max_doors, int doorlevel)

Replacement in crawl-ref/source/dungeon.cc at line 2585 [25.3429798]

B:BD[25.3574691] → [25.3574691:3574779]

        find_door += good_door_spot(rx,sy);
        find_door += good_door_spot(rx,ey);

[25.3574691]

[25.3574779]

        find_door += _good_door_spot(rx,sy);
        find_door += _good_door_spot(rx,ey);

Replacement in crawl-ref/source/dungeon.cc at line 2592 [25.3429798]

B:BD[25.3574874] → [25.3574874:3574962]

        find_door += good_door_spot(sx,ry);
        find_door += good_door_spot(ex,ry);

[25.3574874]

[25.3574962]

        find_door += _good_door_spot(sx,ry);
        find_door += _good_door_spot(ex,ry);

Replacement in crawl-ref/source/dungeon.cc at line 2596 [25.3429798]

B:BD[25.3574969] → [25.3574969:3575129]

    diag_door += good_door_spot(sx,sy);
    diag_door += good_door_spot(ex,sy);
    diag_door += good_door_spot(sx,ey);
    diag_door += good_door_spot(ex,ey);

[25.3574969]

[25.3575129]

    diag_door += _good_door_spot(sx,sy);
    diag_door += _good_door_spot(ex,sy);
    diag_door += _good_door_spot(sx,ey);
    diag_door += _good_door_spot(ex,ey);

Replacement in crawl-ref/source/dungeon.cc at line 2608 [25.3429798]
B:BD[25.3575340] → [25.3575340:3575401]
```
    if (find_in_area(sx,sy,ex,ey,DNGN_BUILDER_SPECIAL_WALL))
```
[25.3575340]
[25.3575401]
```
    if (_find_in_area(sx,sy,ex,ey,DNGN_BUILDER_SPECIAL_WALL))
```
Replacement in crawl-ref/source/dungeon.cc at line 2667 [25.3429798]
B:BD[101.2629] → [101.2629:2661]
```
static int pick_unique(int lev)
```
[101.2629]
[101.2661]
```
static int _pick_unique(int lev)
```
Replacement in crawl-ref/source/dungeon.cc at line 2697 [25.3429798]
B:BD[89.1086] → [89.1086:1146]
```
static int place_uniques(int level_number, char level_type)
```
[89.1086]
[25.3577127]
```
static int _place_uniques(int level_number, char level_type)
```

Replacement in crawl-ref/source/dungeon.cc at line 2722 [25.3429798]

B:BD[89.1677] → [89.1677:1731]

            which_unique = pick_unique(level_number);

[89.1677]

[89.1731]

            which_unique = _pick_unique(level_number);

Replacement in crawl-ref/source/dungeon.cc at line 2745 [25.3429798]

B:BD[25.3577578] → [68.712:771]

∅:D[68.771] → [89.2297:2365]

B:BD[89.2297] → [89.2297:2365]

static int place_monster_vector(std::vector<int> montypes,
                                int level_number, int num_to_place)

[25.3577578]

[89.2365]

static int _place_monster_vector(std::vector<int> montypes,
                                 int level_number, int num_to_place)

Replacement in crawl-ref/source/dungeon.cc at line 2763 [25.3429798]

B:BD[25.3579422] → [89.2776:2846]

static void place_aquatic_monsters(int level_number, char level_type)

[25.3579422]

[89.2846]

static void _place_aquatic_monsters(int level_number, char level_type)

Replacement in crawl-ref/source/dungeon.cc at line 2787 [25.3429798]

B:BD[25.3580350] → [68.907:967]

B:BD[68.967] → [19.10981:11104]

        place_monster_vector(swimming_things, level_number,
                             std::min(random2avg(9, 2)
                               + (random2(lava_spaces) / 10), 15));

[25.3580350]

[25.3580855]

        _place_monster_vector(swimming_things, level_number,
                              std::min(random2avg(9, 2)
                                + (random2(lava_spaces) / 10), 15));

Replacement in crawl-ref/source/dungeon.cc at line 2814 [25.3429798]

B:BD[89.3429] → [68.968:1028]

B:BD[68.1028] → [19.11105:11229]

        place_monster_vector(swimming_things, level_number,
                             std::min(random2avg(9, 2)
                               + (random2(water_spaces) / 10), 15));

[89.3429]

[89.3623]

        _place_monster_vector(swimming_things, level_number,
                              std::min(random2avg(9, 2)
                                + (random2(water_spaces) / 10), 15));

Replacement in crawl-ref/source/dungeon.cc at line 2821 [25.3429798]

B:BD[89.3633] → [89.3633:3713]

static void builder_monsters(int level_number, char level_type, int mon_wanted)

[89.3633]

[89.3713]

static void _builder_monsters(int level_number, char level_type, int mon_wanted)

Replacement in crawl-ref/source/dungeon.cc at line 2837 [25.3429798]
B:BD[25.3581559] → [89.4082:4127]
```
    place_uniques(level_number, level_type);
```
[25.3581559]
[25.3581621]
```
    _place_uniques(level_number, level_type);
```

Replacement in crawl-ref/source/dungeon.cc at line 2840 [25.3429798]

B:BD[102.829] → [102.829:887]

        place_aquatic_monsters(level_number, level_type);

[102.829]

[102.887]

        _place_aquatic_monsters(level_number, level_type);

Replacement in crawl-ref/source/dungeon.cc at line 2851 [25.3429798]

B:BD[25.3582001] → [25.3582001:3582080]

static void builder_items(int level_number, char level_type, int items_wanted)

[25.3582001]

[25.3582080]

static void _builder_items(int level_number, char level_type, int items_wanted)

Replacement in crawl-ref/source/dungeon.cc at line 2915 [25.3429798]
B:BD[25.3584041] → [25.3584041:3584076]
```
static void specr_2(spec_room &sr)
```
[25.3584041]
[25.3584076]
```
static void _specr_2(spec_room &sr)
```

Replacement in crawl-ref/source/dungeon.cc at line 3019 [25.3429798]

B:BD[32.964931] → [19.11474:11685]

static void fill_monster_pit( spec_room &sr, FixedVector<pit_mons_def,
                              MAX_PIT_MONSTERS> &pit_list, int density,
                              int lord_type, int lordx, int lordy )

[32.964931]

[32.965135]

static void _fill_monster_pit( spec_room &sr, FixedVector<pit_mons_def,
                               MAX_PIT_MONSTERS> &pit_list, int density,
                               int lord_type, int lordx, int lordy )

Replacement in crawl-ref/source/dungeon.cc at line 3084 [25.3429798]
∅:D[32.967126] → [25.3586222:3586280]
B:BD[25.3586222] → [25.3586222:3586280]
```
static void special_room(int level_number, spec_room &sr)
```
[32.967126]
[25.3586280]
```
static void _special_room(int level_number, spec_room &sr)
```

Replacement in crawl-ref/source/dungeon.cc at line 3107 [25.3429798]

B:BD[25.3586983] → [25.3586983:3587105]

    make_box( room_x1, room_y1, room_x2, room_y2, 
              DNGN_BUILDER_SPECIAL_FLOOR, DNGN_BUILDER_SPECIAL_WALL );

[25.3586983]

[25.3587105]

    _make_box( room_x1, room_y1, room_x2, room_y2,
               DNGN_BUILDER_SPECIAL_FLOOR, DNGN_BUILDER_SPECIAL_WALL );

Replacement in crawl-ref/source/dungeon.cc at line 3272 [25.3429798]
B:BD[25.3592541] → [25.3592541:3592562]
```
        beehive(sr);
```
[25.3592541]
[25.3592562]
```
        _beehive(sr);
```
Replacement in crawl-ref/source/dungeon.cc at line 3276 [25.3429798]
B:BD[25.3592601] → [25.3592601:3592621]
```
        morgue(sr);
```
[25.3592601]
[32.967354]
```
        _morgue(sr);
```
Replacement in crawl-ref/source/dungeon.cc at line 3280 [25.3429798]
B:BD[32.967396] → [32.967396:967433]
```
        jelly_pit(level_number, sr);
```
[32.967396]
[25.3592621]
```
        _jelly_pit(level_number, sr);
```
Replacement in crawl-ref/source/dungeon.cc at line 3286 [25.3429798]
B:BD[25.3592731] → [25.3592731:3592766]
```
static void beehive(spec_room &sr)
```
[25.3592731]
[25.3592766]
```
static void _beehive(spec_room &sr)
```

Replacement in crawl-ref/source/dungeon.cc at line 3367 [25.3429798]

∅:D[19.12841] → [52.611:662]

B:BD[25.3594024] → [52.611:662]

B:BD[52.662] → [69.3887:3997]

static bool safe_minivault_place(int v1x, int v1y,
                                 const vault_placement &place,
                                 bool clobber)

[19.12841]

[52.726]

static bool _safe_minivault_place(int v1x, int v1y,
                                  const vault_placement &place,
                                  bool clobber)

Replacement in crawl-ref/source/dungeon.cc at line 3400 [25.3429798]

B:BD[52.1243] → [52.1243:1367]

static bool connected_minivault_place(int v1x, int v1y,
                                      const vault_placement &place)

[52.1243]

[52.1367]

static bool _connected_minivault_place(int v1x, int v1y,
                                       const vault_placement &place)

Replacement in crawl-ref/source/dungeon.cc at line 3421 [25.3429798]

B:BD[52.1809] → [52.1809:1872]

B:BD[52.1872] → [69.4662:4729]

static bool find_minivault_place(const vault_placement &place,
                                 int &v1x, int &v1y, bool clobber)

[52.1809]

[52.1925]

static bool _find_minivault_place(const vault_placement &place,
                                  int &v1x, int &v1y, bool clobber)

Replacement in crawl-ref/source/dungeon.cc at line 3434 [25.3429798]

B:BD[52.2351] → [69.4730:4793]

        if (!safe_minivault_place( v1x, v1y, place, clobber ))

[52.2351]

[52.2405]

        if (!_safe_minivault_place( v1x, v1y, place, clobber ))

Replacement in crawl-ref/source/dungeon.cc at line 3437 [25.3429798]

B:BD[52.2428] → [52.2428:2484]

        if (connected_minivault_place(v1x, v1y, place))

[52.2428]

[52.2484]

        if (_connected_minivault_place(v1x, v1y, place))

Replacement in crawl-ref/source/dungeon.cc at line 3443 [25.3429798]

B:BD[52.2540] → [63.1466:1530]

B:BD[63.1530] → [69.4794:4858]

B:BD[69.4858] → [71.813:886]

static bool build_minivaults(int level_number, int force_vault,
                             bool building_level, bool clobber,
                             bool make_no_exits, const coord_def &where)

[52.2540]

[25.3594088]

static bool _build_minivaults(int level_number, int force_vault,
                              bool building_level, bool clobber,
                              bool make_no_exits, const coord_def &where)

Replacement in crawl-ref/source/dungeon.cc at line 3459 [25.3429798]

B:BD[50.5307] → [50.5307:5359]

        dgn_zones = dgn_count_disconnected_zones();

[50.5307]

[50.5359]

        dgn_zones = _dgn_count_disconnected_zones();

Replacement in crawl-ref/source/dungeon.cc at line 3474 [25.3429798]

B:BD[63.1673] → [69.4859:4921]

    else if (!find_minivault_place(place, v1x, v1y, clobber))

[63.1673]

[52.2653]

    else if (!_find_minivault_place(place, v1x, v1y, clobber))

Replacement in crawl-ref/source/dungeon.cc at line 3486 [25.3429798]
B:BD[53.3672] → [77.4991:5018]
```
    register_place(place);
```
[53.3672]
[52.2756]
```
    _register_place(place);
```

Replacement in crawl-ref/source/dungeon.cc at line 3501 [25.3429798]

∅:D[103.1698] → [60.148773:148818]

∅:D[69.4984] → [60.148773:148818]

B:BD[25.3597009] → [60.148773:148818]

B:BD[60.148818] → [104.6134:6245]

∅:D[104.6245] → [73.5503:5557]

B:BD[60.148892] → [73.5503:5557]

B:BD[73.5557] → [104.6246:6310]

∅:D[67.587] → [60.148893:148944]

∅:D[103.1751] → [60.148893:148944]

∅:D[104.6310] → [60.148893:148944]

B:BD[95.149835] → [60.148893:148944]

            altar_count = vault_grid( place,
                                      level_number, vx, vy,
                                      altar_count,
                                      acq_item_class,
                                      feat, target_connections,
                                      num_runes );

[69.4984]

[69.4985]

            altar_count = _vault_grid( place,
                                       level_number, vx, vy,
                                       altar_count,
                                       acq_item_class,
                                       feat, target_connections,
                                       num_runes );

Replacement in crawl-ref/source/dungeon.cc at line 3522 [25.3429798]

B:BD[71.992] → [71.992:1049]

            pick_float_exits(place, target_connections);

[71.992]

[67.712]

            _pick_float_exits(place, target_connections);

Replacement in crawl-ref/source/dungeon.cc at line 3525 [25.3429798]
B:BD[71.1091] → [71.1091:1125]
```
            connect_vault(place);
```
[71.1091]
[71.1125]
```
            _connect_vault(place);
```

Replacement in crawl-ref/source/dungeon.cc at line 3531 [25.3429798]

B:BD[95.149837] → [95.149837:150004]

static void build_rooms(const dgn_region_list &excluded,
                        const std::vector<coord_def> &connections_needed,
                        int nrooms)

[95.149837]

[95.150004]

static void _build_rooms(const dgn_region_list &excluded,
                         const std::vector<coord_def> &connections_needed,
                         int nrooms)

Replacement in crawl-ref/source/dungeon.cc at line 3566 [25.3429798]

B:BD[95.150629] → [53.3784:3857]

            if (join_the_dots(c, myroom.random_edge_point(), MMT_VAULT))

[95.150629]

[105.230]

            if (_join_the_dots(c, myroom.random_edge_point(), MMT_VAULT))

Replacement in crawl-ref/source/dungeon.cc at line 3593 [25.3429798]

B:BD[95.151535] → [95.151535:151648]

        replace_area(myroom.pos.x, myroom.pos.y, end.x, end.y,
                     DNGN_ROCK_WALL, DNGN_FLOOR);

[95.151535]

[95.151648]

        _replace_area(myroom.pos.x, myroom.pos.y, end.x, end.y,
                      DNGN_ROCK_WALL, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 3598 [25.3429798]

B:BD[95.151709] → [19.13531:13721]

            join_the_dots_rigorous( myroom.random_edge_point(),
                                    rom[which_room - 1].random_edge_point(),
                                    MMT_VAULT );

[95.151709]

[95.151865]

            _join_the_dots_rigorous( myroom.random_edge_point(),
                                     rom[which_room - 1].random_edge_point(),
                                     MMT_VAULT );

Replacement in crawl-ref/source/dungeon.cc at line 3610 [25.3429798]

B:BD[95.151963] → [106.160:224]

static int away_from_edge(int x, int left_edge, int right_edge)

[95.151963]

[106.224]

static int _away_from_edge(int x, int left_edge, int right_edge)

Replacement in crawl-ref/source/dungeon.cc at line 3620 [25.3429798]

∅:D[106.368] → [56.5803:5863]

B:BD[95.151963] → [56.5803:5863]

∅:D[73.5657] → [107.674:726]

∅:D[56.5863] → [107.674:726]

B:BD[107.674] → [107.674:726]

static coord_def dig_away_dir(const vault_placement &place,
                              const coord_def &pos)

[106.368]

[95.152041]

static coord_def _dig_away_dir(const vault_placement &place,
                               const coord_def &pos)

Replacement in crawl-ref/source/dungeon.cc at line 3658 [25.3429798]

B:BD[19.13732] → [19.13732:13862]

            dig_dir.x = away_from_edge(pos.x, MAPGEN_BORDER * 2,
                                       GXM - MAPGEN_BORDER * 2);

[19.13732]

[19.13862]

            dig_dir.x = _away_from_edge(pos.x, MAPGEN_BORDER * 2,
                                        GXM - MAPGEN_BORDER * 2);

Replacement in crawl-ref/source/dungeon.cc at line 3669 [25.3429798]

B:BD[19.13883] → [19.13883:14013]

            dig_dir.y = away_from_edge(pos.y, MAPGEN_BORDER * 2,
                                       GYM - MAPGEN_BORDER * 2);

[19.13883]

[19.14013]

            dig_dir.y = _away_from_edge(pos.y, MAPGEN_BORDER * 2,
                                        GYM - MAPGEN_BORDER * 2);

Replacement in crawl-ref/source/dungeon.cc at line 3679 [25.3429798]

B:BD[107.752] → [73.5658:5730]

static void dig_away_from(vault_placement &place, const coord_def &pos)

[107.752]

[107.830]

static void _dig_away_from(vault_placement &place, const coord_def &pos)

Replacement in crawl-ref/source/dungeon.cc at line 3681 [25.3429798]
B:BD[107.832] → [107.832:882]
∅:D[107.882] → [95.152446:152474]
B:BD[95.152446] → [95.152446:152474]
```
    coord_def dig_dir = dig_away_dir(place, pos);
    coord_def dig_at = pos;
```
[107.832]
[95.152474]
```
    coord_def dig_dir = _dig_away_dir(place, pos);
    coord_def dig_at  = pos;
```

Replacement in crawl-ref/source/dungeon.cc at line 3721 [25.3429798]

B:BD[95.152922] → [19.14112:14228]

static void dig_vault_loose( vault_placement &place,
                             std::vector<coord_def> &targets )

[95.152922]

[95.153022]

static void _dig_vault_loose( vault_placement &place,
                              std::vector<coord_def> &targets )

Replacement in crawl-ref/source/dungeon.cc at line 3725 [25.3429798]
B:BD[95.153082] → [19.14229:14272]
```
         dig_away_from(place, targets[i]);
```
[95.153082]
[95.153124]
```
         _dig_away_from(place, targets[i]);
```
Replacement in crawl-ref/source/dungeon.cc at line 3728 [25.3429798]
B:BD[95.153127] → [108.165:207]
```
static bool grid_needs_exit(int x, int y)
```
[95.153127]
[108.207]
```
static bool _grid_needs_exit(int x, int y)
```

Replacement in crawl-ref/source/dungeon.cc at line 3735 [25.3429798]

B:BD[108.280] → [53.3888:4002]

static bool map_grid_is_on_edge(const vault_placement &place,
                                const coord_def &c)

[108.280]

[53.4002]

static bool _map_grid_is_on_edge(const vault_placement &place,
                                 const coord_def &c)

Replacement in crawl-ref/source/dungeon.cc at line 3748 [25.3429798]

B:BD[53.4212] → [53.4212:4349]

static void pick_internal_float_exits(const vault_placement &place,
                                      std::vector<coord_def> &exits)

[53.4212]

[53.4349]

static void _pick_internal_float_exits(const vault_placement &place,
                                       std::vector<coord_def> &exits)

Replacement in crawl-ref/source/dungeon.cc at line 3753 [25.3429798]

∅:D[70.4567] → [53.4488:4590]

B:BD[53.4488] → [53.4488:4590]

            if (grid_needs_exit(x, y)
                && map_grid_is_on_edge(place, coord_def(x, y)))

[70.4567]

[53.4590]

            if (_grid_needs_exit(x, y)
                && _map_grid_is_on_edge(place, coord_def(x, y)))

Replacement in crawl-ref/source/dungeon.cc at line 3760 [25.3429798]

∅:D[108.280] → [73.5760:5813]

∅:D[53.4673] → [73.5760:5813]

B:BD[95.153127] → [73.5760:5813]

∅:D[73.5813] → [95.153186:153248]

B:BD[95.153186] → [95.153186:153248]

static void pick_float_exits(vault_placement &place,
                             std::vector<coord_def> &targets)

[53.4673]

[95.153248]

static void _pick_float_exits(vault_placement &place,
                              std::vector<coord_def> &targets)

Replacement in crawl-ref/source/dungeon.cc at line 3766 [25.3429798]
B:BD[95.153358] → [70.4636:4681]
```
        if (grid_needs_exit(place.pos.x, y))
```
[95.153358]
[70.4681]
```
        if (_grid_needs_exit(place.pos.x, y))
```

Replacement in crawl-ref/source/dungeon.cc at line 3768 [25.3429798]

B:BD[70.4748] → [70.4748:4812]

        if (grid_needs_exit(place.pos.x + place.size.x - 1, y))

[70.4748]

[19.14304]

        if (_grid_needs_exit(place.pos.x + place.size.x - 1, y))

Replacement in crawl-ref/source/dungeon.cc at line 3777 [25.3429798]
B:BD[95.153679] → [70.4991:5036]
```
        if (grid_needs_exit(x, place.pos.y))
```
[95.153679]
[70.5036]
```
        if (_grid_needs_exit(x, place.pos.y))
```
Replacement in crawl-ref/source/dungeon.cc at line 3780 [25.3429798]
∅:D[19.14339] → [70.5103:5167]
B:BD[70.5103] → [70.5103:5167]
```
        if (grid_needs_exit(x, place.pos.y + place.size.y - 1))
```
[19.14339]
[19.14340]
```
        if (_grid_needs_exit(x, place.pos.y + place.size.y - 1))
```
Replacement in crawl-ref/source/dungeon.cc at line 3787 [25.3429798]
B:BD[53.4675] → [53.4675:4729]
```
    pick_internal_float_exits(place, possible_exits);
```
[53.4675]
[25.3597362]
```
    _pick_internal_float_exits(place, possible_exits);
```

Replacement in crawl-ref/source/dungeon.cc at line 3811 [25.3429798]

B:BD[95.154273] → [56.5864:6010]

static std::vector<coord_def> external_connection_points(
    const vault_placement &place,
    const std::vector<coord_def> &target_connections)

[95.154273]

[56.6010]

static std::vector<coord_def> _external_connection_points(
                               const vault_placement &place,
                               const std::vector<coord_def> &target_connections)

Replacement in crawl-ref/source/dungeon.cc at line 3824 [25.3429798]

B:BD[56.6434] → [56.6434:6502]

        ex_connection_points.push_back(p + dig_away_dir(place, p));

[56.6434]

[56.6502]

        ex_connection_points.push_back(p + _dig_away_dir(place, p));

Replacement in crawl-ref/source/dungeon.cc at line 3830 [25.3429798]

B:BD[56.6547] → [53.4730:4789]

static coord_def find_random_grid(int grid, unsigned mask)

[56.6547]

[56.6922]

static coord_def _find_random_grid(int grid, unsigned mask)

Replacement in crawl-ref/source/dungeon.cc at line 3845 [25.3429798]
B:BD[56.7308] → [56.7308:7361]
```
static void connect_vault(const vault_placement &vp)
```
[56.7308]
[56.7361]
```
static void _connect_vault(const vault_placement &vp)
```

Replacement in crawl-ref/source/dungeon.cc at line 3847 [25.3429798]

B:BD[56.7363] → [56.7363:7438]

    std::vector<coord_def> exc = external_connection_points(vp, vp.exits);

[56.7363]

[56.7489]

    std::vector<coord_def> exc = _external_connection_points(vp, vp.exits);

Replacement in crawl-ref/source/dungeon.cc at line 3851 [25.3429798]

B:BD[56.7586] → [53.4843:4916]

        const coord_def floor = find_random_grid(DNGN_FLOOR, MMT_VAULT);

[56.7586]

[56.7656]

        const coord_def floor = _find_random_grid(DNGN_FLOOR, MMT_VAULT);

Replacement in crawl-ref/source/dungeon.cc at line 3856 [25.3429798]
B:BD[56.7714] → [53.4917:4967]
```
        join_the_dots(p, floor, MMT_VAULT, true);
```
[56.7714]
[69.5378]
```
        _join_the_dots(p, floor, MMT_VAULT, true);
```

Replacement in crawl-ref/source/dungeon.cc at line 3860 [25.3429798]

B:BD[69.5387] → [69.5387:5459]

static dungeon_feature_type dgn_find_rune_subst(const std::string &tag)

[69.5387]

[69.5459]

static dungeon_feature_type _dgn_find_rune_subst(const std::string &tag)

Replacement in crawl-ref/source/dungeon.cc at line 3892 [25.3429798]

B:BD[69.6326] → [69.6326:6404]

static dungeon_feature_type dgn_find_rune_subst_tags(const std::string &tags)

[69.6326]

[69.6404]

static dungeon_feature_type _dgn_find_rune_subst_tags(const std::string &tags)

Replacement in crawl-ref/source/dungeon.cc at line 3897 [25.3429798]

B:BD[69.6530] → [69.6530:6603]

        const dungeon_feature_type feat = dgn_find_rune_subst(words[i]);

[69.6530]

[69.6603]

        const dungeon_feature_type feat = _dgn_find_rune_subst(words[i]);

Replacement in crawl-ref/source/dungeon.cc at line 3935 [25.3429798]
B:BD[109.4509] → [109.4509:4536]
```
            reset_level();
```
[109.4509]
[109.4536]
```
            _reset_level();
```

Replacement in crawl-ref/source/dungeon.cc at line 3949 [25.3429798]

B:BD[19.14394] → [19.14394:14535]

        did_map = build_minivaults(you.your_level, map, generating_level,
                                   clobber, make_no_exits, where);

[19.14394]

[19.14535]

        did_map = _build_minivaults(you.your_level, map, generating_level,
                                    clobber, make_no_exits, where);

Replacement in crawl-ref/source/dungeon.cc at line 3956 [25.3429798]

B:BD[69.7068] → [69.7068:7204]

B:BD[69.7204] → [71.1249:1379]

            rune_subst = dgn_find_rune_subst_tags(mdef->tags);
        did_map = build_secondary_vault(you.your_level, map, rune_subst,
                                        generating_level, clobber,
                                        make_no_exits, where);

[69.7068]

[69.7272]

            rune_subst = _dgn_find_rune_subst_tags(mdef->tags);
        did_map = _build_secondary_vault(you.your_level, map, rune_subst,
                                         generating_level, clobber,
                                         make_no_exits, where);

Replacement in crawl-ref/source/dungeon.cc at line 3998 [25.3429798]

B:BD[56.7898] → [69.7917:8053]

B:BD[69.8053] → [71.1380:1501]

static bool build_secondary_vault(int level_number, int vault,
                                  int rune_subst, bool generating_level,
                                  bool clobber, bool no_exits,
                                  const coord_def &where)

[56.7898]

[56.7977]

static bool _build_secondary_vault(int level_number, int vault,
                                   int rune_subst, bool generating_level,
                                   bool clobber, bool no_exits,
                                   const coord_def &where)

Replacement in crawl-ref/source/dungeon.cc at line 4003 [25.3429798]

B:BD[56.7979] → [69.8102:8168]

B:BD[69.8168] → [71.1502:1568]

    if (build_vaults(level_number, vault, rune_subst, true, true,
                     generating_level, clobber, no_exits, where))

[56.7979]

[56.8040]

    if (_build_vaults(level_number, vault, rune_subst, true, true,
                      generating_level, clobber, no_exits, where))

Replacement in crawl-ref/source/dungeon.cc at line 4007 [25.3429798]
B:BD[56.8123] → [56.8123:8150]
```
        connect_vault(vp);
```
[56.8123]
[56.8150]
```
        _connect_vault(vp);
```

Replacement in crawl-ref/source/dungeon.cc at line 4014 [25.3429798]

B:BD[56.8203] → [56.8203:8279]

B:BD[56.8279] → [69.8218:8283]

B:BD[69.8283] → [70.6058:6120]

B:BD[70.6120] → [71.1569:1638]

static bool build_vaults(int level_number, int force_vault, int rune_subst,
                         bool build_only, bool check_collisions,
                         bool generating_level, bool clobber,
                         bool make_no_exits, const coord_def &where)

[56.8203]

[25.3597423]

static bool _build_vaults(int level_number, int force_vault, int rune_subst,
                          bool build_only, bool check_collisions,
                          bool generating_level, bool clobber,
                          bool make_no_exits, const coord_def &where)

Replacement in crawl-ref/source/dungeon.cc at line 4035 [25.3429798]

B:BD[50.5411] → [50.5411:5463]

        dgn_zones = dgn_count_disconnected_zones();

[50.5411]

[50.5463]

        dgn_zones = _dgn_count_disconnected_zones();

Replacement in crawl-ref/source/dungeon.cc at line 4063 [25.3429798]

∅:D[69.8533] → [60.148945:149064]

∅:D[56.8687] → [60.148945:149064]

B:BD[25.3599198] → [60.148945:149064]

B:BD[60.149064] → [73.5885:5939]

∅:D[73.5939] → [95.154322:154433]

B:BD[25.3599339] → [95.154322:154433]

B:BD[95.154433] → [56.8688:8789]

            altar_count = vault_grid( place,
                                      level_number, vx, vy, altar_count, 
                                      acq_item_class,
                                      vgrid[vy][vx],
                                      target_connections,
                                      num_runes,
                                      rune_subst );

[69.8533]

[69.8534]

            altar_count = _vault_grid( place,
                                       level_number, vx, vy, altar_count,
                                       acq_item_class,
                                       vgrid[vy][vx],
                                       target_connections,
                                       num_runes,
                                       rune_subst );

Replacement in crawl-ref/source/dungeon.cc at line 4084 [25.3429798]
∅:D[70.6464] → [77.5019:5046]
∅:D[104.6539] → [77.5019:5046]
∅:D[69.9053] → [77.5019:5046]
B:BD[25.3599495] → [77.5019:5046]
```
    register_place(place);
```
[70.6464]
[79.1737]
```
    _register_place(place);
```
Replacement in crawl-ref/source/dungeon.cc at line 4087 [25.3429798]
B:BD[95.154493] → [95.154493:154546]
```
        pick_float_exits(place, target_connections);
```
[95.154493]
[25.3600231]
```
        _pick_float_exits(place, target_connections);
```
Replacement in crawl-ref/source/dungeon.cc at line 4125 [25.3429798]
B:BD[32.969978] → [32.969978:970031]
```
        plan_4(v1x, v1y, v2x, v2y, DNGN_METAL_WALL);
```
[32.969978]
[25.3603055]
```
        _plan_4(v1x, v1y, v2x, v2y, DNGN_METAL_WALL);
```

Replacement in crawl-ref/source/dungeon.cc at line 4140 [25.3429798]

B:BD[56.9171] → [56.9171:9238]

            external_connection_points(place, target_connections);

[56.9171]

[95.155139]

            _external_connection_points(place, target_connections);

Replacement in crawl-ref/source/dungeon.cc at line 4142 [25.3429798]

B:BD[95.155148] → [107.2489:2558]

        build_rooms(excluded_regions, ex_connection_points, nrooms);

[95.155148]

[25.3603467]

        _build_rooms(excluded_regions, ex_connection_points, nrooms);

Replacement in crawl-ref/source/dungeon.cc at line 4145 [25.3429798]
B:BD[95.155284] → [95.155284:155336]
```
        dig_vault_loose(place, target_connections);
```
[95.155284]
[25.3603603]
```
        _dig_vault_loose(place, target_connections);
```

Replacement in crawl-ref/source/dungeon.cc at line 4200 [25.3429798]

B:BD[75.10235] → [110.516:575]

∅:D[110.575] → [75.10295:10357]

B:BD[75.10295] → [75.10295:10357]

static void dgn_place_item_explicit(const item_spec &spec,
                                     int x, int y, int level)

[75.10235]

[75.10357]

static void _dgn_place_item_explicit(const item_spec &spec,
                                      int x, int y, int level)

Replacement in crawl-ref/source/dungeon.cc at line 4236 [25.3429798]
B:BD[111.1350] → [110.576:630]
```
static void dgn_place_multiple_items(item_list &list,
```
[111.1350]
[111.1405]
```
static void _dgn_place_multiple_items(item_list &list,
```

Replacement in crawl-ref/source/dungeon.cc at line 4241 [25.3429798]

B:BD[111.1539] → [110.631:695]

        dgn_place_item_explicit(list.get_item(i), x, y, level);

[111.1539]

[75.10756]

        _dgn_place_item_explicit(list.get_item(i), x, y, level);

Replacement in crawl-ref/source/dungeon.cc at line 4244 [25.3429798]

B:BD[60.149118] → [110.696:757]

static void dgn_place_item_explicit(int index, int x, int y,

[60.149118]

[73.6087]

static void _dgn_place_item_explicit(int index, int x, int y,

Replacement in crawl-ref/source/dungeon.cc at line 4260 [25.3429798]
B:BD[73.6344] → [110.758:806]
```
    dgn_place_item_explicit(spec, x, y, level);
```
[73.6344]
[75.10808]
```
    _dgn_place_item_explicit(spec, x, y, level);
```

Replacement in crawl-ref/source/dungeon.cc at line 4263 [25.3429798]

B:BD[112.10878] → [112.10878:11098]

static void dgn_give_mon_spec_items(mons_spec &mspec,
                                    const int mindex,
                                    const int mid,
                                    const int monster_level)

[112.10878]

[112.11098]

static void _dgn_give_mon_spec_items(mons_spec &mspec,
                                     const int mindex,
                                     const int mid,
                                     const int monster_level)

Replacement in crawl-ref/source/dungeon.cc at line 4396 [25.3429798]

B:BD[112.13800] → [112.13800:13876]

                dgn_give_mon_spec_items(mspec, mindex, mid, monster_level);

[112.13800]

[113.1229]

                _dgn_give_mon_spec_items(mspec, mindex, mid, monster_level);

Replacement in crawl-ref/source/dungeon.cc at line 4403 [25.3429798]

B:BD[110.1137] → [19.15377:15522]

static bool dgn_place_monster( const vault_placement &place, mons_spec &mspec,
                               int monster_level, int vx, int vy)

[110.1137]

[110.1273]

static bool _dgn_place_monster( const vault_placement &place, mons_spec &mspec,
                                int monster_level, int vx, int vy)

Replacement in crawl-ref/source/dungeon.cc at line 4412 [25.3429798]

B:BD[114.912] → [19.15710:15897]

static bool dgn_place_one_monster( const vault_placement &place,
                                   mons_list &mons, int monster_level,
                                   int vx, int vy)

[114.912]

[114.1046]

static bool _dgn_place_one_monster( const vault_placement &place,
                                    mons_list &mons, int monster_level,
                                    int vx, int vy)

Replacement in crawl-ref/source/dungeon.cc at line 4419 [25.3429798]

B:BD[112.13946] → [112.13946:14013]

        if (dgn_place_monster(place, spec, monster_level, vx, vy))

[112.13946]

[114.1233]

        if (_dgn_place_monster(place, spec, monster_level, vx, vy))

Replacement in crawl-ref/source/dungeon.cc at line 4425 [25.3429798]
B:BD[60.150638] → [115.165:206]
```
static monster_type random_evil_statue()
```
[60.150638]
[115.206]
```
static monster_type _random_evil_statue()
```

Replacement in crawl-ref/source/dungeon.cc at line 4485 [25.3429798]

B:BD[116.11587] → [116.11587:11662]

            (rawfeat == 'C') ? pick_an_altar() :   // f(x) elsewhere {dlb}

[116.11587]

[116.11662]

            (rawfeat == 'C') ? _pick_an_altar() :   // f(x) elsewhere {dlb}

Replacement in crawl-ref/source/dungeon.cc at line 4500 [25.3429798]

B:BD[25.3605130] → [73.6551:6598]

∅:D[73.6598] → [60.150692:150812]

B:BD[60.150692] → [60.150692:150812]

B:BD[60.150812] → [74.4541:4619]

∅:D[74.4619] → [75.11482:11516]

B:BD[25.3605269] → [75.11482:11516]

∅:D[75.11516] → [95.155487:155543]

B:BD[95.155487] → [95.155487:155543]

B:BD[95.155543] → [56.9582:9621]

B:BD[56.9621] → [75.11517:11596]

static int vault_grid( vault_placement &place,
                       int level_number,
                       int vx, int vy,
                       int altar_count,
                       FixedVector < object_class_type, 7 > &acq_item_class, 
                       int vgrid,
                       std::vector<coord_def> &targets,
                       int &num_runes,
                       int rune_subst,
                       bool following )

[25.3605130]

[25.3605452]

static int _vault_grid( vault_placement &place,
                        int level_number,
                        int vx, int vy,
                        int altar_count,
                        FixedVector < object_class_type, 7 > &acq_item_class,
                        int vgrid,
                        std::vector<coord_def> &targets,
                        int &num_runes,
                        int rune_subst,
                        bool following )

Replacement in crawl-ref/source/dungeon.cc at line 4524 [25.3429798]

B:BD[75.11892] → [75.11892:12151]

            altar_count = vault_grid( place, level_number, vx, vy,
                                      altar_count, acq_item_class,
                                      f.glyph, targets, num_runes,
                                      rune_subst, true );

[75.11892]

[75.12151]

            altar_count = _vault_grid( place, level_number, vx, vy,
                                       altar_count, acq_item_class,
                                       f.glyph, targets, num_runes,
                                       rune_subst, true );

Replacement in crawl-ref/source/dungeon.cc at line 4543 [25.3429798]

B:BD[114.1341] → [110.1577:1643]

        dgn_place_one_monster(place, mons, level_number, vx, vy);

[114.1341]

[75.12642]

        _dgn_place_one_monster(place, mons, level_number, vx, vy);

Replacement in crawl-ref/source/dungeon.cc at line 4546 [25.3429798]

B:BD[111.1652] → [110.1644:1707]

        dgn_place_multiple_items(items, vx, vy, level_number);

[111.1652]

[75.12749]

        _dgn_place_multiple_items(items, vx, vy, level_number);

Replacement in crawl-ref/source/dungeon.cc at line 4554 [25.3429798]

B:BD[115.465] → [115.465:537]

        place_monster( not_used, random_evil_statue(), 30, BEH_HOSTILE,

[115.465]

[115.537]

        place_monster( not_used, _random_evil_statue(), 30, BEH_HOSTILE,

Replacement in crawl-ref/source/dungeon.cc at line 4586 [25.3429798]
∅:D[117.3308] → [25.3606694:3606774]
∅:D[51.11732] → [25.3606694:3606774]
B:BD[25.3606694] → [25.3606694:3606774]
```
                   (vgrid == 'C') ? pick_an_altar() :   // f(x) elsewhere {dlb}
```
[117.3308]
[115.598]
```
                   (vgrid == 'C') ? _pick_an_altar() :   // f(x) elsewhere {dlb}
```

Replacement in crawl-ref/source/dungeon.cc at line 4720 [25.3429798]

B:BD[60.151435] → [110.1708:1783]

        dgn_place_item_explicit(vgrid - 'd', vx, vy, place, level_number);

[60.151429]

[60.151517]

        _dgn_place_item_explicit(vgrid - 'd', vx, vy, place, level_number);

Replacement in crawl-ref/source/dungeon.cc at line 4751 [25.3429798]

B:BD[25.3611393] → [110.1784:1861]

        dgn_place_monster(place, monster_type_thing, monster_level, vx, vy);

[25.3611393]

[25.3611526]

        _dgn_place_monster(place, monster_type_thing, monster_level, vx, vy);

Replacement in crawl-ref/source/dungeon.cc at line 4759 [25.3429798]

B:BD[25.3611703] → [19.17562:17750]

static void replace_area( int sx, int sy, int ex, int ey,
                          dungeon_feature_type replace,
                          dungeon_feature_type feature, unsigned mapmask)

[25.3611703]

[25.3611810]

static void _replace_area( int sx, int sy, int ex, int ey,
                           dungeon_feature_type replace,
                           dungeon_feature_type feature, unsigned mapmask)

Replacement in crawl-ref/source/dungeon.cc at line 4797 [25.3429798]

B:BD[65.1154] → [19.17839:17958]

static void jtd_init_surrounds(coord_set &coords, unsigned mapmask,
                               const coord_def &c)

[65.1154]

[65.1302]

static void _jtd_init_surrounds(coord_set &coords, unsigned mapmask,
                                const coord_def &c)

Replacement in crawl-ref/source/dungeon.cc at line 4818 [25.3429798]

B:BD[65.1798] → [65.1798:1852]

B:BD[65.1852] → [19.17977:18126]

static bool join_the_dots_pathfind(coord_set &coords,
                                   const coord_def &from, const coord_def &to,
                                   unsigned mapmask, bool early_exit)

[65.1798]

[65.2071]

static bool _join_the_dots_pathfind(coord_set &coords,
                                    const coord_def &from, const coord_def &to,
                                    unsigned mapmask, bool early_exit)

Replacement in crawl-ref/source/dungeon.cc at line 4831 [25.3429798]

B:BD[65.2276] → [65.2276:2327]

        jtd_init_surrounds(coords, mapmask, curr);

[65.2276]

[65.2327]

        _jtd_init_surrounds(coords, mapmask, curr);

Replacement in crawl-ref/source/dungeon.cc at line 4858 [25.3429798]

B:BD[65.2880] → [65.2880:3099]

static bool join_the_dots_rigorous(const coord_def &from,
                                   const coord_def &to,
                                   unsigned mapmask,
                                   bool early_exit)

[65.2880]

[65.3099]

static bool _join_the_dots_rigorous(const coord_def &from,
                                    const coord_def &to,
                                    unsigned mapmask,
                                    bool early_exit)

Replacement in crawl-ref/source/dungeon.cc at line 4867 [25.3429798]

B:BD[65.3237] → [19.18141:18273]

    const bool found = join_the_dots_pathfind(coords, from, to, mapmask,
                                              early_exit);

[65.3237]

[65.3331]

    const bool found = _join_the_dots_pathfind(coords, from, to, mapmask,
                                               early_exit);

Replacement in crawl-ref/source/dungeon.cc at line 4873 [25.3429798]

B:BD[65.3355] → [19.18274:18407]

static bool join_the_dots( const coord_def &from, const coord_def &to,
                           unsigned mapmask, bool early_exit)

[65.3355]

[95.156016]

static bool _join_the_dots( const coord_def &from, const coord_def &to,
                            unsigned mapmask, bool early_exit)

Replacement in crawl-ref/source/dungeon.cc at line 4936 [25.3429798]

B:BD[25.3613632] → [51.11942:12020]

∅:D[51.12020] → [25.3613703:3613818]

B:BD[25.3613703] → [25.3613703:3613818]

static void place_pool(dungeon_feature_type pool_type, unsigned char pool_x1,
                       unsigned char pool_y1, unsigned char pool_x2,
                       unsigned char pool_y2)

[25.3613632]

[25.3613818]

static void _place_pool(dungeon_feature_type pool_type, unsigned char pool_x1,
                        unsigned char pool_y1, unsigned char pool_x2,
                        unsigned char pool_y2)

Replacement in crawl-ref/source/dungeon.cc at line 4989 [25.3429798]
B:BD[25.3615294] → [51.12021:12076]
```
static void many_pools(dungeon_feature_type pool_type)
```
[25.3615294]
[25.3615342]
```
static void _many_pools(dungeon_feature_type pool_type)
```

Replacement in crawl-ref/source/dungeon.cc at line 5007 [25.3429798]

B:BD[25.3615730] → [92.9064:9133]

        if ( count_antifeature_in_box(i, j, k, l, DNGN_FLOOR) == 0 )

[25.3615730]

[25.3615915]

        if ( _count_antifeature_in_box(i, j, k, l, DNGN_FLOOR) == 0 )

Replacement in crawl-ref/source/dungeon.cc at line 5009 [25.3429798]
B:BD[25.3615925] → [92.9134:9181]
```
            place_pool(pool_type, i, j, k, l);
```
[25.3615925]
[92.9181]
```
            _place_pool(pool_type, i, j, k, l);
```
Replacement in crawl-ref/source/dungeon.cc at line 5016 [25.3429798]
B:BD[25.3634590] → [62.9897:9941]
```
static dungeon_feature_type pick_an_altar()
```
[25.3634590]
[25.3634621]
```
static dungeon_feature_type _pick_an_altar()
```
Replacement in crawl-ref/source/dungeon.cc at line 5108 [25.3429798]
B:BD[25.3637712] → [77.5047:5074]
```
static void place_altars()
```
[25.3637712]
[77.5074]
```
static void _place_altars()
```
Replacement in crawl-ref/source/dungeon.cc at line 5125 [25.3429798]
B:BD[77.5432] → [77.5432:5459]
```
            place_altar();
```
[77.5432]
[77.5459]
```
            _place_altar();
```
Replacement in crawl-ref/source/dungeon.cc at line 5132 [25.3429798]
∅:D[77.5560] → [62.9942:9968]
B:BD[25.3637712] → [62.9942:9968]
```
static void place_altar()
```
[77.5560]
[25.3637742]
```
static void _place_altar()
```

Replacement in crawl-ref/source/dungeon.cc at line 5139 [25.3429798]

B:BD[25.3637873] → [92.9327:9466]

        const int numfloors = count_feature_in_box(px-2, py-2, px+3, py+3,
                                                   DNGN_FLOOR);

[25.3637873]

[92.9466]

        const int numfloors = _count_feature_in_box(px-2, py-2, px+3, py+3,
                                                    DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5142 [25.3429798]

B:BD[92.9494] → [92.9494:9793]

            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_ROCK_WALL) +
            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_CLOSED_DOOR) +
            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_SECRET_DOOR) +
            count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_FLOOR);

[92.9494]

[25.3637948]

            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_ROCK_WALL) +
            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_CLOSED_DOOR) +
            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_SECRET_DOOR) +
            _count_feature_in_box(px-2, py-2, px+3, py+3, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5166 [25.3429798]
∅:D[19.18630] → [92.10220:10259]
B:BD[25.3638751] → [92.10220:10259]
```
        grd[px][py] = pick_an_altar();
```
[19.18630]
[92.10259]
```
        grd[px][py] = _pick_an_altar();
```
Replacement in crawl-ref/source/dungeon.cc at line 5171 [25.3429798]
B:BD[25.3638887] → [55.34074:34128]
```
static void place_shops(int level_number, int nshops)
```
[25.3638887]
[25.3638929]
```
static void _place_shops(int level_number, int nshops)
```

Replacement in crawl-ref/source/dungeon.cc at line 5217 [25.3429798]

B:BD[87.616] → [84.7470:7528]

            place_specific_stair(DNGN_ENTER_PORTAL_VAULT,

[87.616]

[19.18713]

            _place_specific_stair(DNGN_ENTER_PORTAL_VAULT,

Replacement in crawl-ref/source/dungeon.cc at line 5229 [25.3429798]
B:BD[25.3639973] → [118.286:336]
```
static bool need_varied_selection(shop_type shop)
```
[25.3639973]
[118.336]
```
static bool _need_varied_selection(shop_type shop)
```
Replacement in crawl-ref/source/dungeon.cc at line 5296 [25.3429798]
B:BD[118.480] → [118.480:529]
```
    if (need_varied_selection(env.shop[i].type))
```
[118.480]
[118.529]
```
    if (_need_varied_selection(env.shop[i].type))
```

Replacement in crawl-ref/source/dungeon.cc at line 5330 [25.3429798]

B:BD[32.972040] → [32.972040:972115]

            orb = items( 1, item_in_shop(env.shop[i].type), subtype, true,

[32.972040]

[119.53905]

            orb = items( 1, _item_in_shop(env.shop[i].type), subtype, true,

Replacement in crawl-ref/source/dungeon.cc at line 5335 [25.3429798]

B:BD[118.655] → [118.655:731]

            if (orb != NON_ITEM && need_varied_selection(env.shop[i].type))

[118.655]

[118.731]

            if (orb != NON_ITEM && _need_varied_selection(env.shop[i].type))

Replacement in crawl-ref/source/dungeon.cc at line 5364 [25.3429798]

B:BD[118.1134] → [118.1134:1214]

        if (need_varied_selection(env.shop[i].type) && !is_artefact(mitm[orb]))

[118.1134]

[118.1214]

        if (_need_varied_selection(env.shop[i].type) && !is_artefact(mitm[orb]))

Replacement in crawl-ref/source/dungeon.cc at line 5390 [25.3429798]
B:BD[25.3643027] → [68.1420:1483]
```
static object_class_type item_in_shop(unsigned char shop_type)
```
[25.3643027]
[25.3643086]
```
static object_class_type _item_in_shop(unsigned char shop_type)
```
Replacement in crawl-ref/source/dungeon.cc at line 5431 [25.3429798]
B:BD[25.3643886] → [25.3643886:3643951]
```
static void spotty_level(bool seeded, int iterations, bool boxy)
```
[25.3643886]
[25.3643951]
```
static void _spotty_level(bool seeded, int iterations, bool boxy)
```
Replacement in crawl-ref/source/dungeon.cc at line 5523 [25.3429798]
B:BD[25.3646942] → [62.9969:9995]
```
static void bigger_room()
```
[25.3646942]
[25.3646972]
```
static void _bigger_room()
```
Replacement in crawl-ref/source/dungeon.cc at line 5534 [25.3429798]
B:BD[25.3647197] → [25.3647197:3647230]
```
    many_pools(DNGN_DEEP_WATER);
```
[25.3647197]
[25.3647230]
```
    _many_pools(DNGN_DEEP_WATER);
```
Replacement in crawl-ref/source/dungeon.cc at line 5539 [25.3429798]
B:BD[25.3647294] → [25.3647294:3647338]
```
            build_river( DNGN_DEEP_WATER );
```
[25.3647294]
[25.3647338]
```
            _build_river( DNGN_DEEP_WATER );
```
Replacement in crawl-ref/source/dungeon.cc at line 5541 [25.3429798]
B:BD[25.3647351] → [25.3647351:3647394]
```
            build_lake( DNGN_DEEP_WATER );
```
[25.3647351]
[25.3647394]
```
            _build_lake( DNGN_DEEP_WATER );
```

Replacement in crawl-ref/source/dungeon.cc at line 5549 [25.3429798]

B:BD[25.3647528] → [19.19157:19377]

            place_specific_stair( static_cast<dungeon_feature_type>(
                                   j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                               : DNGN_STONE_STAIRS_UP_I)) );

[25.3647528]

[25.3647676]

            _place_specific_stair( static_cast<dungeon_feature_type>(
                                    j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                                  : DNGN_STONE_STAIRS_UP_I)) );

Replacement in crawl-ref/source/dungeon.cc at line 5556 [25.3429798]
B:BD[25.3647776] → [55.34516:34572]
```
static void plan_main(int level_number, int force_plan)
```
[25.3647776]
[25.3647833]
```
static void _plan_main(int level_number, int force_plan)
```

Replacement in crawl-ref/source/dungeon.cc at line 5571 [25.3429798]

B:BD[25.3648241] → [25.3648241:3648385]

B:BD[25.3648385] → [51.12479:12551]

∅:D[51.12551] → [25.3648447:3648688]

B:BD[25.3648447] → [25.3648447:3648688]

    do_stairs = ((force_plan == 1) ? plan_1() :
                 (force_plan == 2) ? plan_2() :
                 (force_plan == 3) ? plan_3() :
                 (force_plan == 4) ? plan_4(0, 0, 0, 0, NUM_FEATURES) :
                 (force_plan == 5) ? (one_chance_in(9) ? plan_5()
                                                       : plan_3()) :
                 (force_plan == 6) ? plan_6(level_number)
                                   : plan_3());

[25.3648241]

[25.3648688]

    do_stairs = ((force_plan == 1) ? _plan_1() :
                 (force_plan == 2) ? _plan_2() :
                 (force_plan == 3) ? _plan_3() :
                 (force_plan == 4) ? _plan_4(0, 0, 0, 0, NUM_FEATURES) :
                 (force_plan == 5) ? (one_chance_in(9) ? _plan_5()
                                                       : _plan_3()) :
                 (force_plan == 6) ? _plan_6(level_number)
                                   : _plan_3());

Replacement in crawl-ref/source/dungeon.cc at line 5581 [25.3429798]
B:BD[25.3648731] → [25.3648731:3648774]
```
        spotty_level(true, 0, coinflip());
```
[25.3648731]
[25.3648774]
```
        _spotty_level(true, 0, coinflip());
```

Replacement in crawl-ref/source/dungeon.cc at line 5590 [25.3429798]

B:BD[25.3648966] → [19.19457:19689]

                place_specific_stair( static_cast<dungeon_feature_type>(
                                       j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                                   : DNGN_STONE_STAIRS_UP_I)) );

[25.3648966]

[25.3649122]

                _place_specific_stair( static_cast<dungeon_feature_type>(
                                       j + ((i == 0)? DNGN_STONE_STAIRS_DOWN_I
                                                    : DNGN_STONE_STAIRS_UP_I)));

Replacement in crawl-ref/source/dungeon.cc at line 5597 [25.3429798]

B:BD[25.3649180] → [25.3649180:3649247]

        replace_area(0,0,GXM-1,GYM-1,DNGN_ROCK_WALL,special_grid);

[25.3649180]

[25.3649247]

        _replace_area(0, 0, GXM-1, GYM-1, DNGN_ROCK_WALL, special_grid);

Replacement in crawl-ref/source/dungeon.cc at line 5600 [25.3429798]
B:BD[25.3649299] → [62.9996:10017]
```
static char plan_1()
```
[25.3649299]
[25.3649324]
```
static char _plan_1()
```

Replacement in crawl-ref/source/dungeon.cc at line 5606 [25.3429798]

B:BD[25.3649474] → [25.3649474:3649613]

B:BD[25.3649613] → [19.19690:19736]

∅:D[19.19736] → [25.3649650:3649789]

B:BD[25.3649650] → [25.3649650:3649789]

B:BD[25.3649789] → [19.19737:19783]

    replace_area(10, 10, (GXM - 10), (10 + width), DNGN_ROCK_WALL, DNGN_FLOOR);
    replace_area(10, (60 - width), (GXM - 10), (GYM - 10),
                 DNGN_ROCK_WALL, DNGN_FLOOR);
    replace_area(10, 10, (10 + width), (GYM - 10), DNGN_ROCK_WALL, DNGN_FLOOR);
    replace_area((60 - width), 10, (GXM - 10), (GYM - 10),
                 DNGN_ROCK_WALL, DNGN_FLOOR);

[25.3649474]

[25.3649826]

    _replace_area(10, 10, (GXM - 10), (10 + width), DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area(10, (60 - width), (GXM - 10), (GYM - 10),
                  DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area(10, 10, (10 + width), (GYM - 10), DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area((60 - width), 10, (GXM - 10), (GYM - 10),
                  DNGN_ROCK_WALL, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5624 [25.3429798]

B:BD[25.3650159] → [25.3650159:3650226]

B:BD[25.3650226] → [19.19784:19834]

∅:D[19.19834] → [25.3650274:3650341]

B:BD[25.3650274] → [25.3650274:3650341]

B:BD[25.3650341] → [19.19835:19885]

        replace_area(10, (35 - width2), (GXM - 10), (35 + width2),
                     DNGN_ROCK_WALL, DNGN_FLOOR);
        replace_area((40 - width2), 10, (40 + width2), (GYM - 10),
                     DNGN_ROCK_WALL, DNGN_FLOOR);

[25.3650159]

[25.3650389]

        _replace_area(10, (35 - width2), (GXM - 10), (35 + width2),
                      DNGN_ROCK_WALL, DNGN_FLOOR);
        _replace_area((40 - width2), 10, (40 + width2), (GYM - 10),
                      DNGN_ROCK_WALL, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5659 [25.3429798]
∅:D[51.12986] → [25.3651311:3651363]
B:BD[25.3651311] → [25.3651311:3651363]
```
            octa_room(sr, oblique_max, floor_type);
```
[51.12986]
[25.3651363]
```
            _octa_room(sr, oblique_max, floor_type);
```
Replacement in crawl-ref/source/dungeon.cc at line 5668 [25.3429798]
B:BD[25.3651512] → [62.10018:10039]
```
static char plan_2()
```
[25.3651512]
[25.3651537]
```
static char _plan_2()
```

Replacement in crawl-ref/source/dungeon.cc at line 5672 [25.3429798]

B:BD[25.3651610] → [25.3651610:3651673]

B:BD[25.3651673] → [19.19886:19932]

∅:D[19.19932] → [25.3651746:3651809]

B:BD[25.3651746] → [25.3651746:3651809]

B:BD[25.3651809] → [19.19933:19979]

    replace_area(10, (35 - width2), (GXM - 10), (35 + width2),
                 DNGN_ROCK_WALL, DNGN_FLOOR);
    replace_area((40 - width2), 10, (40 + width2), (GYM - 10),
                 DNGN_ROCK_WALL, DNGN_FLOOR);

[25.3651610]

[25.3651882]

    _replace_area(10, (35 - width2), (GXM - 10), (35 + width2),
                  DNGN_ROCK_WALL, DNGN_FLOOR);
    _replace_area((40 - width2), 10, (40 + width2), (GYM - 10),
                  DNGN_ROCK_WALL, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5680 [25.3429798]
B:BD[25.3651971] → [62.10040:10061]
```
static char plan_3()
```
[25.3651971]
[25.3651996]
```
static char _plan_3()
```

Replacement in crawl-ref/source/dungeon.cc at line 5703 [25.3429798]

B:BD[25.3652667] → [120.315:674]

        if (exclusive && count_antifeature_in_box(romx1[which_room] - 1,
                                                  romy1[which_room] - 1,
                                                  romx2[which_room] + 1,
                                                  romy2[which_room] + 1,
                                                  DNGN_ROCK_WALL))

[25.3652667]

[19.19980]

        if (exclusive && _count_antifeature_in_box(romx1[which_room] - 1,
                                                   romy1[which_room] - 1,
                                                   romx2[which_room] + 1,
                                                   romy2[which_room] + 1,
                                                   DNGN_ROCK_WALL))

Replacement in crawl-ref/source/dungeon.cc at line 5712 [25.3429798]

B:BD[25.3653185] → [25.3653185:3653263]

B:BD[25.3653263] → [92.10444:10513]

        replace_area(romx1[which_room], romy1[which_room], romx2[which_room],
                     romy2[which_room], DNGN_ROCK_WALL, DNGN_FLOOR);

[25.3653185]

[25.3653330]

        _replace_area(romx1[which_room], romy1[which_room], romx2[which_room],
                      romy2[which_room], DNGN_ROCK_WALL, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5727 [25.3429798]

B:BD[25.3653798] → [95.156862:157150]

B:BD[95.157150] → [53.5518:5558]

            join_the_dots( coord_def(rx1 + random2( rx2 - rx1 ),
                                     ry1 + random2( ry2 - ry1 )),
                           coord_def(prev_rx1 + random2(prev_rx2 - prev_rx1),
                                     prev_ry1 + random2(prev_ry2 - prev_ry1)),
                           MMT_VAULT );

[25.3653798]

[25.3654089]

            _join_the_dots( coord_def(rx1 + random2( rx2 - rx1 ),
                                      ry1 + random2( ry2 - ry1 )),
                            coord_def(prev_rx1 + random2(prev_rx2 - prev_rx1),
                                      prev_ry1 + random2(prev_ry2 - prev_ry1)),
                            MMT_VAULT );

Replacement in crawl-ref/source/dungeon.cc at line 5757 [25.3429798]

B:BD[25.3654704] → [95.157199:157541]

B:BD[95.157541] → [53.5559:5603]

                join_the_dots( coord_def( rx1 + random2( rx2 - rx1 ),
                                          ry1 + random2( ry2 - ry1 ) ),
                               coord_def(
                                   prev_rx1 + random2( prev_rx2 - prev_rx1 ),
                                   prev_ry1 + random2( prev_ry2 - prev_ry1 ) ),
                               MMT_VAULT );

[25.3654704]

[25.3655015]

                _join_the_dots( coord_def( rx1 + random2( rx2 - rx1 ),
                                           ry1 + random2( ry2 - ry1 ) ),
                                coord_def(
                                    prev_rx1 + random2( prev_rx2 - prev_rx1 ),
                                    prev_ry1 + random2( prev_ry2 - prev_ry1 ) ),
                                MMT_VAULT );

Replacement in crawl-ref/source/dungeon.cc at line 5770 [25.3429798]

B:BD[25.3655109] → [25.3655109:3655176]

B:BD[25.3655176] → [51.12987:13055]

static char plan_4(char forbid_x1, char forbid_y1, char forbid_x2,
                   char forbid_y2, dungeon_feature_type force_wall)

[25.3655109]

[25.3655246]

static char _plan_4(char forbid_x1, char forbid_y1, char forbid_x2,
                    char forbid_y2, dungeon_feature_type force_wall)

Replacement in crawl-ref/source/dungeon.cc at line 5800 [25.3429798]

B:BD[25.3656235] → [25.3656235:3656313]

    replace_area(10, 10, (GXM - 10), (GYM - 10), DNGN_ROCK_WALL, DNGN_FLOOR);

[25.3656235]

[25.3656313]

    _replace_area(10, 10, (GXM - 10), (GYM - 10), DNGN_ROCK_WALL, DNGN_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 5827 [25.3429798]

B:BD[25.3656995] → [92.10735:10813]

        if (count_antifeature_in_box(b1x-1, b1y-1, b2x+1, b2y+1, DNGN_FLOOR))

[25.3656995]

[92.10813]

        if (_count_antifeature_in_box(b1x-1, b1y-1, b2x+1, b2y+1, DNGN_FLOOR))

Replacement in crawl-ref/source/dungeon.cc at line 5847 [25.3429798]

B:BD[25.3657864] → [25.3657864:3657931]

            replace_area(b1x, b1y, b2x, b2y, DNGN_FLOOR, drawing);

[25.3657864]

[25.3657931]

            _replace_area(b1x, b1y, b2x, b2y, DNGN_FLOOR, drawing);

Replacement in crawl-ref/source/dungeon.cc at line 5849 [25.3429798]

B:BD[25.3657989] → [25.3657989:3658048]

            box_room(b1x, b2x - 1, b1y, b2y - 1, drawing);

[25.3657989]

[25.3658085]

            _box_room(b1x, b2x - 1, b1y, b2y - 1, drawing);

Replacement in crawl-ref/source/dungeon.cc at line 5868 [25.3429798]
B:BD[25.3658571] → [25.3658571:3658616]
```
        octa_room(sr, oblique_max, feature);
```
[25.3658571]
[25.3658616]
```
        _octa_room(sr, oblique_max, feature);
```
Replacement in crawl-ref/source/dungeon.cc at line 5874 [25.3429798]
B:BD[25.3658686] → [62.10062:10083]
```
static char plan_5()
```
[25.3658686]
[25.3658711]
```
static char _plan_5()
```
Replacement in crawl-ref/source/dungeon.cc at line 5880 [25.3429798]
B:BD[25.3658844] → [95.157594:157617]
```
        join_the_dots(
```
[25.3658844]
[95.157617]
```
        _join_the_dots(
```
Replacement in crawl-ref/source/dungeon.cc at line 5887 [25.3429798]
B:BD[25.3659057] → [25.3659057:3659102]
```
        spotty_level(true, 100, coinflip());
```
[25.3659057]
[25.3659102]
```
        _spotty_level(true, 100, coinflip());
```
Replacement in crawl-ref/source/dungeon.cc at line 5892 [25.3429798]
B:BD[25.3659166] → [25.3659166:3659203]
```
static char plan_6(int level_number)
```
[25.3659166]
[25.3659203]
```
static char _plan_6(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 5902 [25.3429798]
B:BD[25.3659382] → [25.3659382:3659417]
```
    octa_room(sr, 14, DNGN_FLOOR);
```
[25.3659382]
[25.3659417]
```
    _octa_room(sr, 14, DNGN_FLOOR);
```

Replacement in crawl-ref/source/dungeon.cc at line 5904 [25.3429798]

B:BD[25.3659418] → [25.3659418:3660048]

    replace_area(23, 23, 26, 26, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(23, 47, 26, 50, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(55, 23, 58, 26, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(55, 47, 58, 50, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(39, 20, 43, 23, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(39, 50, 43, 53, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(20, 30, 23, 33, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(20, 40, 23, 43, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(58, 30, 61, 33, DNGN_FLOOR, DNGN_STONE_WALL);
    replace_area(58, 40, 61, 43, DNGN_FLOOR, DNGN_STONE_WALL);

[25.3659418]

[25.3660048]

    _replace_area(23, 23, 26, 26, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(23, 47, 26, 50, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(55, 23, 58, 26, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(55, 47, 58, 50, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(39, 20, 43, 23, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(39, 50, 43, 53, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(20, 30, 23, 33, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(20, 40, 23, 43, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(58, 30, 61, 33, DNGN_FLOOR, DNGN_STONE_WALL);
    _replace_area(58, 40, 61, 43, DNGN_FLOOR, DNGN_STONE_WALL);

Replacement in crawl-ref/source/dungeon.cc at line 5945 [25.3429798]

B:BD[25.3661134] → [51.13238:13347]

static bool octa_room(spec_room &sr, int oblique_max,
                      dungeon_feature_type type_floor)

[25.3661134]

[25.3661214]

static bool _octa_room(spec_room &sr, int oblique_max,
                       dungeon_feature_type type_floor)

Deletion in crawl-ref/source/dungeon.cc at line 5963 [25.3429798]
B:BD[25.3661634] → [25.3661634:3661644]
```
        {
```
Deletion in crawl-ref/source/dungeon.cc at line 5965 [25.3429798]
B:BD[25.3661730] → [25.3661730:3661740]
```
        }
```

Replacement in crawl-ref/source/dungeon.cc at line 6000 [25.3429798]

B:BD[78.635] → [52.2934:3095]

static void find_maze_neighbours(const coord_def &c,
                                 const dgn_region &region,
                                 coord_list &ns)

[78.635]

[78.704]

static void _find_maze_neighbours(const coord_def &c,
                                  const dgn_region &region,
                                  coord_list &ns)

Replacement in crawl-ref/source/dungeon.cc at line 6025 [25.3429798]

B:BD[78.1368] → [52.3134:3214]

static void labyrinth_maze_recurse(const coord_def &c, const dgn_region &where)

[78.1368]

[78.1423]

static void _labyrinth_maze_recurse(const coord_def &c, const dgn_region &where)

Replacement in crawl-ref/source/dungeon.cc at line 6028 [25.3429798]
B:BD[78.1452] → [52.3215:3263]
```
    find_maze_neighbours(c, where, neighbours);
```
[78.1452]
[25.3662593]
```
    _find_maze_neighbours(c, where, neighbours);
```

Replacement in crawl-ref/source/dungeon.cc at line 6042 [25.3429798]

B:BD[52.3448] → [52.3448:3495]

            labyrinth_maze_recurse(nc, where);

[52.3448]

[52.3495]

            _labyrinth_maze_recurse(nc, where);

Replacement in crawl-ref/source/dungeon.cc at line 6048 [25.3429798]
B:BD[78.2014] → [52.3545:3588]
```
        labyrinth_maze_recurse(*i, where);
```
[78.2014]
[78.2334]
```
        _labyrinth_maze_recurse(*i, where);
```

Replacement in crawl-ref/source/dungeon.cc at line 6051 [25.3429798]

B:BD[78.2337] → [52.3589:3659]

static void labyrinth_build_maze(coord_def &e, const dgn_region &lab)

[78.2337]

[78.2384]

static void _labyrinth_build_maze(coord_def &e, const dgn_region &lab)

Replacement in crawl-ref/source/dungeon.cc at line 6053 [25.3429798]
B:BD[78.2386] → [52.3660:3713]
```
    labyrinth_maze_recurse(lab.random_point(), lab);
```
[78.2386]
[78.2437]
```
    _labyrinth_maze_recurse(lab.random_point(), lab);
```
Replacement in crawl-ref/source/dungeon.cc at line 6062 [25.3429798]
B:BD[78.2517] → [78.2517:2573]
```
static void labyrinth_place_items(const coord_def &end)
```
[78.2517]
[78.2573]
```
static void _labyrinth_place_items(const coord_def &end)
```
Replacement in crawl-ref/source/dungeon.cc at line 6092 [25.3429798]
B:BD[78.3668] → [78.3668:3723]
```
static void labyrinth_place_exit(const coord_def &end)
```
[78.3668]
[78.3723]
```
static void _labyrinth_place_exit(const coord_def &end)
```
Replacement in crawl-ref/source/dungeon.cc at line 6094 [25.3429798]
B:BD[78.3725] → [78.3725:3757]
```
    labyrinth_place_items(end);
```
[78.3725]
[78.3757]
```
    _labyrinth_place_items(end);
```

Replacement in crawl-ref/source/dungeon.cc at line 6099 [25.3429798]

B:BD[52.3750] → [52.3750:3822]

static void init_minivault_placement(int vault, vault_placement &place)

[52.3750]

[52.3822]

static void _init_minivault_placement(int vault, vault_placement &place)

Replacement in crawl-ref/source/dungeon.cc at line 6105 [25.3429798]

B:BD[121.588] → [121.588:769]

B:BD[121.769] → [53.5630:5683]

∅:D[53.5683] → [121.840:978]

B:BD[121.840] → [121.840:978]

static void change_walls_from_centre(const dgn_region &region,
                                     const coord_def &centre,
                                     bool  rectangular,
                                     unsigned mmask,
                                     dungeon_feature_type wall,
                                     const std::vector<dist_feat> &ldist)

[121.588]

[121.978]

static void _change_walls_from_centre(const dgn_region &region,
                                      const coord_def &centre,
                                      bool  rectangular,
                                      unsigned mmask,
                                      dungeon_feature_type wall,
                                      const std::vector<dist_feat> &ldist)

Replacement in crawl-ref/source/dungeon.cc at line 6148 [25.3429798]

B:BD[121.2246] → [121.2246:2422]

B:BD[121.2493] → [121.2493:2599]

static void change_walls_from_centre(const dgn_region &region,
                                     const coord_def &c,
                                     bool  rectangular,
                                     dungeon_feature_type wall,
                                     ...)

[121.2246]

[121.2599]

static void _change_walls_from_centre(const dgn_region &region,
                                      const coord_def &c,
                                      bool  rectangular,
                                      dungeon_feature_type wall,
                                      ...)

Replacement in crawl-ref/source/dungeon.cc at line 6169 [25.3429798]

B:BD[121.2950] → [53.5743:5821]

    change_walls_from_centre(region, c, rectangular, MMT_VAULT, wall, ldist);

[121.2950]

[122.2021]

    _change_walls_from_centre(region, c, rectangular, MMT_VAULT, wall, ldist);

Replacement in crawl-ref/source/dungeon.cc at line 6172 [25.3429798]
B:BD[122.2024] → [123.704:761]
```
static void place_extra_lab_minivaults(int level_number)
```
[122.2024]
[123.761]
```
static void _place_extra_lab_minivaults(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 6182 [25.3429798]
B:BD[123.1011] → [123.1011:1063]
```
        if (!build_minivaults(level_number, vault))
```
[123.1011]
[123.1063]
```
        if (!_build_minivaults(level_number, vault))
```

Replacement in crawl-ref/source/dungeon.cc at line 6188 [25.3429798]

B:BD[124.1308] → [124.1308:1421]

static bool has_vault_in_radius(const coord_def &pos, int radius,
                                unsigned mask)

[124.1308]

[124.1421]

static bool _has_vault_in_radius(const coord_def &pos, int radius,
                                 unsigned mask)

Replacement in crawl-ref/source/dungeon.cc at line 6208 [25.3429798]

B:BD[124.1919] → [124.1919:1986]

static coord_def labyrinth_find_entry_point(const dgn_region &reg,

[124.1919]

[124.1986]

static coord_def _labyrinth_find_entry_point(const dgn_region &reg,

Replacement in crawl-ref/source/dungeon.cc at line 6222 [25.3429798]

B:BD[124.2340] → [124.2340:2394]

        if (has_vault_in_radius(place, 4, MMT_VAULT))

[124.2340]

[124.2394]

        if (_has_vault_in_radius(place, 4, MMT_VAULT))

Replacement in crawl-ref/source/dungeon.cc at line 6231 [25.3429798]

B:BD[123.1091] → [124.2469:2597]

static void labyrinth_place_entry_point(const dgn_region &region,
                                        const coord_def &pos)

[123.1091]

[124.2597]

static void _labyrinth_place_entry_point(const dgn_region &region,
                                         const coord_def &pos)

Replacement in crawl-ref/source/dungeon.cc at line 6234 [25.3429798]

B:BD[124.2599] → [124.2599:2664]

    const coord_def p = labyrinth_find_entry_point(region, pos);

[124.2599]

[124.2664]

    const coord_def p = _labyrinth_find_entry_point(region, pos);

Replacement in crawl-ref/source/dungeon.cc at line 6239 [25.3429798]
∅:D[123.1091] → [25.3662594:3662640]
∅:D[122.2024] → [25.3662594:3662640]
∅:D[124.2764] → [25.3662594:3662640]
∅:D[78.3869] → [25.3662594:3662640]
∅:D[52.4136] → [25.3662594:3662640]
B:BD[25.3662594] → [25.3662594:3662640]
```
static void labyrinth_level(int level_number)
```
[124.2764]
[25.3662640]
```
static void _labyrinth_level(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 6251 [25.3429798]
B:BD[52.4536] → [52.4536:4584]
```
        init_minivault_placement(vault, place);
```
[52.4530]
[52.4775]
```
        _init_minivault_placement(vault, place);
```
Replacement in crawl-ref/source/dungeon.cc at line 6254 [25.3429798]
B:BD[78.3889] → [52.4781:4817]
```
    labyrinth_build_maze(end, lab);
```
[78.3889]
[78.3969]
```
    _labyrinth_build_maze(end, lab);
```

Replacement in crawl-ref/source/dungeon.cc at line 6256 [25.3429798]

B:BD[78.3970] → [52.4818:4881]

    if (vault == -1 || !build_minivaults(level_number, vault))

[78.3970]

[52.4881]

    if (vault == -1 || !_build_minivaults(level_number, vault))

Replacement in crawl-ref/source/dungeon.cc at line 6259 [25.3429798]
B:BD[52.4907] → [52.4907:4942]
```
        labyrinth_place_exit(end);
```
[52.4907]
[52.4942]
```
        _labyrinth_place_exit(end);
```

Replacement in crawl-ref/source/dungeon.cc at line 6274 [25.3429798]

B:BD[52.5355] → [52.5355:5419]

                        labyrinth_place_items(coord_def(x, y));

[52.5355]

[52.5419]

                        _labyrinth_place_items(coord_def(x, y));

Replacement in crawl-ref/source/dungeon.cc at line 6287 [25.3429798]
B:BD[123.1155] → [123.1155:1201]
```
    place_extra_lab_minivaults(level_number);
```
[123.1155]
[52.5650]
```
    _place_extra_lab_minivaults(level_number);
```

Replacement in crawl-ref/source/dungeon.cc at line 6289 [25.3429798]

B:BD[52.5651] → [53.5822:5913]

∅:D[123.1277] → [121.3366:3509]

∅:D[53.5913] → [121.3366:3509]

B:BD[121.3366] → [121.3366:3509]

    change_walls_from_centre(lab, end, false,
                             DNGN_ROCK_WALL,
                             15 * 15, DNGN_METAL_WALL,
                             34 * 34, DNGN_STONE_WALL,
                             0);

[52.5651]

[124.2765]

    _change_walls_from_centre(lab, end, false,
                              DNGN_ROCK_WALL,
                              15 * 15, DNGN_METAL_WALL,
                              34 * 34, DNGN_STONE_WALL,
                              0);

Replacement in crawl-ref/source/dungeon.cc at line 6295 [25.3429798]
B:BD[124.2766] → [124.2766:2809]
```
    labyrinth_place_entry_point(lab, end);
```
[124.2766]
[52.5827]
```
    _labyrinth_place_entry_point(lab, end);
```
Replacement in crawl-ref/source/dungeon.cc at line 6306 [25.3429798]
B:BD[25.3666679] → [25.3666679:3666713]
```
static bool is_wall(int x, int y)
```
[25.3666679]
[25.3666713]
```
static bool _is_wall(int x, int y)
```
Replacement in crawl-ref/source/dungeon.cc at line 6327 [25.3429798]
B:BD[25.3667009] → [25.3667009:3667053]
```
static int box_room_door_spot(int x, int y)
```
[25.3667009]
[25.3667053]
```
static int _box_room_door_spot(int x, int y)
```

Replacement in crawl-ref/source/dungeon.cc at line 6330 [25.3429798]

B:BD[25.3667133] → [19.21040:21361]

    if (grd[x-1][y] == DNGN_CLOSED_DOOR && is_wall(x-1,y-1) && is_wall(x-1,y+1)
     || grd[x+1][y] == DNGN_CLOSED_DOOR && is_wall(x+1,y-1) && is_wall(x+1,y+1)
     || grd[x][y-1] == DNGN_CLOSED_DOOR && is_wall(x-1,y-1) && is_wall(x+1,y-1)
     || grd[x][y+1] == DNGN_CLOSED_DOOR && is_wall(x-1,y+1) && is_wall(x+1,y+1))

[25.3667133]

[25.3667462]

    if (   grd[x-1][y] == DNGN_CLOSED_DOOR
            && _is_wall(x-1,y-1) && _is_wall(x-1,y+1)
        || grd[x+1][y] == DNGN_CLOSED_DOOR
            && _is_wall(x+1,y-1) && _is_wall(x+1,y+1)
        || grd[x][y-1] == DNGN_CLOSED_DOOR
            && _is_wall(x-1,y-1) && _is_wall(x+1,y-1)
        || grd[x][y+1] == DNGN_CLOSED_DOOR
            && _is_wall(x-1,y+1) && _is_wall(x+1,y+1))

Replacement in crawl-ref/source/dungeon.cc at line 6345 [25.3429798]

B:BD[25.3667628] → [25.3667628:3667756]

    bool nor = is_wall(x, y-1);
    bool sou = is_wall(x, y+1);
    bool eas = is_wall(x-1, y);
    bool wes = is_wall(x+1, y);

[25.3667628]

[25.3667756]

    bool nor = _is_wall(x, y-1);
    bool sou = _is_wall(x, y+1);
    bool eas = _is_wall(x-1, y);
    bool wes = _is_wall(x+1, y);

Replacement in crawl-ref/source/dungeon.cc at line 6356 [25.3429798]

B:BD[25.3667841] → [25.3667841:3667919]

static int box_room_doors( int bx1, int bx2, int by1, int by2, int new_doors)

[25.3667841]

[25.3667919]

static int _box_room_doors( int bx1, int bx2, int by1, int by2, int new_doors)

Replacement in crawl-ref/source/dungeon.cc at line 6374 [25.3429798]

B:BD[25.3668346] → [25.3668346:3668474]

        good_doors[spot_count ++] = box_room_door_spot(i, by1);
        good_doors[spot_count ++] = box_room_door_spot(i, by2);

[25.3668346]

[25.3668474]

        good_doors[spot_count ++] = _box_room_door_spot(i, by1);
        good_doors[spot_count ++] = _box_room_door_spot(i, by2);

Replacement in crawl-ref/source/dungeon.cc at line 6380 [25.3429798]

B:BD[25.3668535] → [25.3668535:3668663]

        good_doors[spot_count ++] = box_room_door_spot(bx1, i);
        good_doors[spot_count ++] = box_room_door_spot(bx2, i);

[25.3668535]

[25.3668663]

        good_doors[spot_count ++] = _box_room_door_spot(bx1, i);
        good_doors[spot_count ++] = _box_room_door_spot(bx2, i);

Replacement in crawl-ref/source/dungeon.cc at line 6447 [25.3429798]

B:BD[25.3669808] → [51.13482:13592]

static void box_room(int bx1, int bx2, int by1, int by2,
                     dungeon_feature_type wall_type)

[25.3669808]

[25.3669880]

static void _box_room(int bx1, int bx2, int by1, int by2,
                      dungeon_feature_type wall_type)

Replacement in crawl-ref/source/dungeon.cc at line 6460 [25.3429798]

B:BD[25.3670169] → [25.3670169:3670281]

    replace_area(bx1,by1,bx2,by1,DNGN_FLOOR,wall_type);
    replace_area(bx1,by2,bx2,by2,DNGN_FLOOR,wall_type);

[25.3670169]

[25.3670281]

    _replace_area(bx1,by1,bx2,by1,DNGN_FLOOR,wall_type);
    _replace_area(bx1,by2,bx2,by2,DNGN_FLOOR,wall_type);

Replacement in crawl-ref/source/dungeon.cc at line 6464 [25.3429798]

B:BD[25.3670311] → [25.3670311:3670431]

    replace_area(bx1,by1+1,bx1,by2-1,DNGN_FLOOR,wall_type);
    replace_area(bx2,by1+1,bx2,by2-1,DNGN_FLOOR,wall_type);

[25.3670311]

[25.3670431]

    _replace_area(bx1,by1+1,bx1,by2-1,DNGN_FLOOR,wall_type);
    _replace_area(bx2,by1+1,bx2,by2-1,DNGN_FLOOR,wall_type);

Replacement in crawl-ref/source/dungeon.cc at line 6469 [25.3429798]
∅:D[3.372] → [25.3670515:3670573]
B:BD[25.3670515] → [25.3670515:3670573]
```
    doors_placed = box_room_doors(bx1, bx2, by1, by2, 0);
```
[3.372]
[25.3670573]
```
    doors_placed = _box_room_doors(bx1, bx2, by1, by2, 0);
```
Replacement in crawl-ref/source/dungeon.cc at line 6482 [25.3429798]
B:BD[25.3670842] → [25.3670842:3670897]
```
        box_room_doors(bx1, bx2, by1, by2, new_doors);
```
[25.3670842]
[25.3670897]
```
        _box_room_doors(bx1, bx2, by1, by2, new_doors);
```
Replacement in crawl-ref/source/dungeon.cc at line 6485 [25.3429798]
B:BD[25.3670900] → [25.3670900:3670941]
```
static void city_level(int level_number)
```
[25.3670900]
[25.3670941]
```
static void _city_level(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 6507 [25.3429798]
B:BD[25.3671561] → [25.3671561:3671609]
```
    make_box( 7, 7, GXM-7, GYM-7, DNGN_FLOOR );
```
[25.3671561]
[25.3671609]
```
    _make_box( 7, 7, GXM-7, GYM-7, DNGN_FLOOR );
```

Replacement in crawl-ref/source/dungeon.cc at line 6531 [25.3429798]

B:BD[25.3672456] → [25.3672456:3672514]

                box_room(x1, x2, y1, y2, wall_type_room);

[25.3672456]

[25.3672514]

                _box_room(x1, x2, y1, y2, wall_type_room);

Replacement in crawl-ref/source/dungeon.cc at line 6536 [25.3429798]

B:BD[25.3672639] → [25.3672639:3672712]

                    box_room(x1 + 2, x2 - 2, y1 + 2, y2 - 2, wall_type);

[25.3672639]

[25.3672712]

                    _box_room(x1 + 2, x2 - 2, y1 + 2, y2 - 2, wall_type);

Replacement in crawl-ref/source/dungeon.cc at line 6540 [25.3429798]

B:BD[25.3672800] → [3.425:548]

                        treasure_area(level_number, x1 + 3, x2 - 3,
                                      y1 + 3, y2 - 3);

[25.3672800]

[25.3672885]

                    {
                        _treasure_area(level_number, x1 + 3, x2 - 3,
                                       y1 + 3, y2 - 3);
                    }

Replacement in crawl-ref/source/dungeon.cc at line 6553 [25.3429798]

B:BD[25.3673063] → [19.21725:21949]

            place_specific_stair( static_cast<dungeon_feature_type>(
                                   j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                                 : DNGN_STONE_STAIRS_UP_I)) );

[25.3673063]

[25.3673211]

            _place_specific_stair( static_cast<dungeon_feature_type>(
                                    j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                                  : DNGN_STONE_STAIRS_UP_I)) );

Replacement in crawl-ref/source/dungeon.cc at line 6560 [25.3429798]

B:BD[25.3673281] → [25.3673281:3673461]

static bool treasure_area(int level_number, unsigned char ta1_x,
                          unsigned char ta2_x, unsigned char ta1_y,
                          unsigned char ta2_y)

[25.3673281]

[25.3673461]

static bool _treasure_area(int level_number, unsigned char ta1_x,
                           unsigned char ta2_x, unsigned char ta1_y,
                           unsigned char ta2_y)

Replacement in crawl-ref/source/dungeon.cc at line 6596 [25.3429798]
B:BD[25.3674294] → [25.3674294:3674338]
```
static void diamond_rooms(int level_number)
```
[25.3674294]
[25.3674338]
```
static void _diamond_rooms(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 6638 [25.3429798]
B:BD[25.3675568] → [25.3675568:3675621]
```
        if (!octa_room(sr, oblique_max, type_floor))
```
[25.3675568]
[25.3675621]
```
        if (!_octa_room(sr, oblique_max, type_floor))
```
Replacement in crawl-ref/source/dungeon.cc at line 6652 [25.3429798]
B:BD[25.3675950] → [25.3675950:3675989]
```
static void big_room(int level_number)
```
[25.3675950]
[25.3675989]
```
static void _big_room(int level_number)
```
Replacement in crawl-ref/source/dungeon.cc at line 6673 [25.3429798]
B:BD[25.3676503] → [25.3676503:3676551]
```
            octa_room(sr, oblique, DNGN_FLOOR);
```
[25.3676503]
[25.3676551]
```
            _octa_room(sr, oblique, DNGN_FLOOR);
```
Replacement in crawl-ref/source/dungeon.cc at line 6686 [25.3429798]
B:BD[25.3676836] → [25.3676836:3676880]
```
        octa_room(sr, oblique, type_floor);
```
[25.3676836]
[25.3676880]
```
        _octa_room(sr, oblique, type_floor);
```

Replacement in crawl-ref/source/dungeon.cc at line 6696 [25.3429798]

B:BD[25.3677072] → [25.3677072:3677149]

    if (find_in_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_BUILDER_SPECIAL_WALL))

[25.3677072]

[25.3677149]

    if (_find_in_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_BUILDER_SPECIAL_WALL))

Replacement in crawl-ref/source/dungeon.cc at line 6706 [25.3429798]

B:BD[25.3677385] → [25.3677385:3677535]

    replace_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_ROCK_WALL, type_floor);
    replace_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_CLOSED_DOOR, type_floor);

[25.3677385]

[25.3677535]

    _replace_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_ROCK_WALL, type_floor);
    _replace_area(sr.x1, sr.y1, sr.x2, sr.y2, DNGN_CLOSED_DOOR, type_floor);

Replacement in crawl-ref/source/dungeon.cc at line 6729 [25.3429798]

B:BD[25.3677981] → [25.3677981:3678041]

        chequerboard( sr, type_floor, type_floor, type_2 );

[25.3677981]

[25.3678041]

        _chequerboard( sr, type_floor, type_floor, type_2 );

Replacement in crawl-ref/source/dungeon.cc at line 6751 [25.3429798]
B:BD[25.3678504] → [25.3678504:3678555]
```
            box_room(i, k, j, l, DNGN_STONE_WALL);
```
[25.3678504]
[25.3678555]
```
            _box_room(i, k, j, l, DNGN_STONE_WALL);
```

Replacement in crawl-ref/source/dungeon.cc at line 6760 [25.3429798]

B:BD[25.3678764] → [51.14210:14391]

static void chequerboard( spec_room &sr, dungeon_feature_type target,
                          dungeon_feature_type floor1,
                          dungeon_feature_type floor2 )

[25.3678764]

[25.3678900]

static void _chequerboard( spec_room &sr, dungeon_feature_type target,
                           dungeon_feature_type floor1,
                           dungeon_feature_type floor2 )

Replacement in crawl-ref/source/dungeon.cc at line 6777 [25.3429798]
B:BD[25.3679239] → [25.3679239:3679297]
```
static void roguey_level(int level_number, spec_room &sr)
```
[25.3679239]
[25.3679297]
```
static void _roguey_level(int level_number, spec_room &sr)
```

Replacement in crawl-ref/source/dungeon.cc at line 6809 [25.3429798]

B:BD[25.3680058] → [25.3680058:3680169]

        replace_area( rox1[i], roy1[i], rox2[i], roy2[i], 
                      DNGN_ROCK_WALL, DNGN_FLOOR );

[25.3680058]

[25.3680169]

        _replace_area( rox1[i], roy1[i], rox2[i], roy2[i],
                       DNGN_ROCK_WALL, DNGN_FLOOR );

Replacement in crawl-ref/source/dungeon.cc at line 6818 [25.3429798]

B:BD[25.3680326] → [19.22094:22228]

                box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                          roy2[i] - 2, (coinflip() ? DNGN_STONE_WALL

[25.3680326]

[25.3680525]

                _box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                           roy2[i] - 2, (coinflip() ? DNGN_STONE_WALL

Replacement in crawl-ref/source/dungeon.cc at line 6824 [25.3429798]

B:BD[19.22274] → [19.22274:22397]

                box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                          roy2[i] - 2, DNGN_METAL_WALL );

[19.22274]

[19.22397]

                _box_room( rox1[i] + 2, rox2[i] - 2, roy1[i] + 2,
                           roy2[i] - 2, DNGN_METAL_WALL );

Replacement in crawl-ref/source/dungeon.cc at line 6830 [25.3429798]

B:BD[19.22454] → [19.22454:22598]

                treasure_area( level_number, rox1[i] + 3, rox2[i] - 3,
                                             roy1[i] + 3, roy2[i] - 3 );

[19.22454]

[25.3681031]

                _treasure_area( level_number, rox1[i] + 3, rox2[i] - 3,
                                              roy1[i] + 3, roy2[i] - 3 );

Replacement in crawl-ref/source/dungeon.cc at line 6911 [25.3429798]
B:BD[25.3683509] → [25.3683509:3683551]
```
        special_room( level_number, sr );
```
[25.3683509]
[25.3683551]
```
        _special_room( level_number, sr );
```

Replacement in crawl-ref/source/dungeon.cc at line 6917 [25.3429798]

B:BD[25.3683697] → [25.3683697:3683997]

        replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1, DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1, DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1, DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

[25.3683697]

[25.3683997]

        _replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1,
                      DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        _replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1,
                      DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        _replace_area(sr.x1-1, sr.y1-1, sr.x2+1,sr.y1-1,
                      DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 6925 [25.3429798]

B:BD[25.3684016] → [25.3684016:3684316]

        replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1, DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1, DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1, DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

[25.3684016]

[25.3684316]

        _replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1,
                      DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        _replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1,
                      DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        _replace_area(sr.x1-1, sr.y2+1, sr.x2+1,sr.y2+1,
                      DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 6933 [25.3429798]

B:BD[25.3684333] → [25.3684333:3684636]

        replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1, DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1, DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1, DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

[25.3684333]

[25.3684636]

        _replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1,
                      DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        _replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1,
                      DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        _replace_area(sr.x1-1, sr.y1-1, sr.x1-1, sr.y2+1,
                      DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 6941 [25.3429798]

B:BD[25.3684654] → [25.3684654:3684957]

        replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1, DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1, DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1, DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

[25.3684654]

[25.3684957]

        _replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1,
                      DNGN_ROCK_WALL, DNGN_BUILDER_SPECIAL_WALL);
        _replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1,
                      DNGN_FLOOR, DNGN_BUILDER_SPECIAL_FLOOR);
        _replace_area(sr.x2+1, sr.y1-1, sr.x2+1, sr.y2+1,
                      DNGN_CLOSED_DOOR, DNGN_BUILDER_SPECIAL_FLOOR);

Replacement in crawl-ref/source/dungeon.cc at line 6954 [25.3429798]

B:BD[25.3685097] → [19.22606:22826]

            place_specific_stair( static_cast<dungeon_feature_type>(
                                   j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                               : DNGN_STONE_STAIRS_UP_I)) );

[25.3685097]

[25.3685242]

            _place_specific_stair( static_cast<dungeon_feature_type>(
                                    j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                                  : DNGN_STONE_STAIRS_UP_I)) );

Replacement in crawl-ref/source/dungeon.cc at line 6960 [25.3429798]
B:BD[25.3685313] → [25.3685313:3685347]
```
static void morgue(spec_room &sr)
```
[25.3685313]
[25.3685347]
```
static void _morgue(spec_room &sr)
```
Replacement in crawl-ref/source/dungeon.cc at line 6982 [25.3429798]
B:BD[25.3686236] → [32.972935:972990]
```
static void jelly_pit(int level_number, spec_room &sr)
```
[25.3686236]
[32.972990]
```
static void _jelly_pit(int level_number, spec_room &sr)
```

Replacement in crawl-ref/source/dungeon.cc at line 7021 [25.3429798]

B:BD[32.973981] → [32.973981:974055]

    fill_monster_pit( sr, pit_list, 90, MONS_PROGRAM_BUG, lordx, lordy );

[32.973981]

[32.974055]

    _fill_monster_pit( sr, pit_list, 90, MONS_PROGRAM_BUG, lordx, lordy );

Replacement in crawl-ref/source/dungeon.cc at line 7256 [25.3429798]
B:BD[25.3693457] → [51.14769:14833]
```
static void build_river( dungeon_feature_type river_type ) //mv
```
[25.3693457]
[25.3693514]
```
static void _build_river( dungeon_feature_type river_type ) //mv
```
Replacement in crawl-ref/source/dungeon.cc at line 7265 [25.3429798]
B:BD[25.3693673] → [25.3693673:3693710]
```
    //     build_river(river_type); 
```
[25.3693673]
[25.3693710]
```
    //     _build_river(river_type);
```
Replacement in crawl-ref/source/dungeon.cc at line 7301 [25.3429798]
B:BD[25.3695021] → [51.14834:14894]
```
static void build_lake(dungeon_feature_type lake_type) //mv
```
[25.3695021]
[25.3695074]
```
static void _build_lake(dungeon_feature_type lake_type) //mv
```
Replacement in crawl-ref/source/dungeon.cc at line 7310 [25.3429798]
B:BD[25.3695240] → [25.3695240:3695276]
```
    //      build_lake(lake_type); 
```
[25.3695240]
[25.3695276]
```
    //     _build_lake(lake_type);
```
Replacement in crawl-ref/source/dungeon.cc at line 7375 [25.3429798]
B:BD[95.157798] → [86.3691:3751]
```
inline static bool dgn_square_travel_ok(const coord_def &c)
```
[95.157798]
[86.3751]
```
inline static bool _dgn_square_travel_ok(const coord_def &c)
```

Replacement in crawl-ref/source/dungeon.cc at line 7383 [25.3429798]

B:BD[85.4739] → [125.8155:8225]

static coord_def dgn_find_closest_to_stone_stairs(coord_def base_pos)

[85.4739]

[85.4791]

static coord_def _dgn_find_closest_to_stone_stairs(coord_def base_pos)

Replacement in crawl-ref/source/dungeon.cc at line 7392 [25.3429798]

B:BD[85.5086] → [86.3900:3977]

                dgn_fill_zone(coord_def(x, y), 1, np, dgn_square_travel_ok);

[85.5086]

[19.23254]

                _dgn_fill_zone(coord_def(x, y), 1, np, _dgn_square_travel_ok);

Replacement in crawl-ref/source/dungeon.cc at line 7397 [25.3429798]

B:BD[95.157799] → [126.285:353]

static coord_def dgn_find_feature_marker(dungeon_feature_type feat)

[95.157799]

[124.2860]

static coord_def _dgn_find_feature_marker(dungeon_feature_type feat)

Replacement in crawl-ref/source/dungeon.cc at line 7413 [25.3429798]
B:BD[126.454] → [126.454:504]
```
static coord_def dgn_find_labyrinth_entry_point()
```
[126.454]
[126.504]
```
static coord_def _dgn_find_labyrinth_entry_point()
```

Replacement in crawl-ref/source/dungeon.cc at line 7415 [25.3429798]

B:BD[126.506] → [126.506:566]

    return (dgn_find_feature_marker(DNGN_ENTER_LABYRINTH));

[126.506]

[124.3253]

    return (_dgn_find_feature_marker(DNGN_ENTER_LABYRINTH));

Replacement in crawl-ref/source/dungeon.cc at line 7432 [25.3429798]

B:BD[85.5359] → [125.8331:8404]

        const coord_def pos(dgn_find_closest_to_stone_stairs(base_pos));

[85.5359]

[85.5424]

        const coord_def pos(_dgn_find_closest_to_stone_stairs(base_pos));

Replacement in crawl-ref/source/dungeon.cc at line 7439 [25.3429798]

B:BD[127.547] → [127.547:616]

        const coord_def pos(dgn_find_feature_marker(stair_to_find));

[127.547]

[127.616]

        const coord_def pos(_dgn_find_feature_marker(stair_to_find));

Replacement in crawl-ref/source/dungeon.cc at line 7446 [25.3429798]

B:BD[124.3430] → [124.3430:3493]

        const coord_def pos(dgn_find_labyrinth_entry_point());

[124.3430]

[124.3493]

        const coord_def pos(_dgn_find_labyrinth_entry_point());

Replacement in crawl-ref/source/dungeon.cc at line 7459 [25.3429798]

B:BD[126.852] → [126.852:930]

        const coord_def pos(dgn_find_feature_marker(DNGN_STONE_STAIRS_UP_I));

[126.852]

[126.930]

        const coord_def pos(_dgn_find_feature_marker(DNGN_STONE_STAIRS_UP_I));

Replacement in crawl-ref/source/decks.cc at line 180 [25.3987460]
B:BD[128.41635] → [128.41635:41683]
```
static void check_odd_card(unsigned char flags)
```
[129.12002]
[128.41683]
```
static void _check_odd_card(unsigned char flags)
```
Replacement in crawl-ref/source/decks.cc at line 196 [25.3987460]
B:BD[128.42034] → [128.42034:42075]
```
static void shuffle_deck(item_def &deck)
```
[128.42034]
[128.42075]
```
static void _shuffle_deck(item_def &deck)
```

Replacement in crawl-ref/source/decks.cc at line 237 [25.3987460]

B:BD[128.43381] → [128.43381:43506]

static void set_card_and_flags(item_def& deck, int idx, card_type card,
                               unsigned char _flags)

[128.43381]

[128.43506]

static void _set_card_and_flags(item_def& deck, int idx, card_type card,
                                unsigned char _flags)

Replacement in crawl-ref/source/decks.cc at line 255 [25.3987460]

∅:D[128.43852] → [129.12075:12546]

B:BD[129.12075] → [129.12075:12546]

∅:D[129.12546] → [130.1266:1309]

B:BD[130.1266] → [130.1266:1309]

B:BD[130.1309] → [129.12547:12715]

B:BD[129.12715] → [27.4879:4920]

B:BD[27.4920] → [131.1896:1935]

∅:D[131.1935] → [129.12766:12979]

∅:D[27.4920] → [129.12766:12979]

B:BD[129.12766] → [129.12766:12979]

B:BD[129.12979] → [132.452:497]

∅:D[132.497] → [129.12979:13108]

B:BD[129.12979] → [129.12979:13108]

B:BD[129.13108] → [133.498:543]

∅:D[133.543] → [129.13108:13257]

B:BD[129.13108] → [129.13108:13257]

B:BD[129.13257] → [134.412:459]

    case CARD_PORTAL: return "the Portal";
    case CARD_WARP: return "the Warp";
    case CARD_SWAP: return "Swap";
    case CARD_VELOCITY: return "Velocity";
    case CARD_DAMNATION: return "Damnation";
    case CARD_SOLITUDE: return "Solitude";
    case CARD_ELIXIR: return "the Elixir";
    case CARD_BATTLELUST: return "Battlelust";
    case CARD_METAMORPHOSIS: return "Metamorphosis";
    case CARD_HELM: return "the Helm";
    case CARD_BLADE: return "the Blade";
    case CARD_SHADOW: return "the Shadow";
    case CARD_POTION: return "the Potion";
    case CARD_FOCUS: return "Focus";
    case CARD_SHUFFLE: return "Shuffle";
    case CARD_EXPERIENCE: return "Experience";
    case CARD_HELIX: return "the Helix";
    case CARD_SAGE: return "the Sage";
    case CARD_DOWSING: return "Dowsing";
    case CARD_TROWEL: return "the Trowel";
    case CARD_MINEFIELD: return "the Minefield";
    case CARD_GENIE: return "the Genie";
    case CARD_TOMB: return "the Tomb";
    case CARD_GLASS: return "Vitrification";
    case CARD_MAP: return "the Map";
    case CARD_BANSHEE: return "the Banshee";
    case CARD_WILD_MAGIC: return "Wild Magic";
    case CARD_CRUSADE: return "the Crusade";
    case CARD_SUMMON_ANIMAL: return "the Herd";
    case CARD_SUMMON_DEMON: return "the Pentagram";
    case CARD_SUMMON_WEAPON: return "the Dance";
    case CARD_SUMMON_FLYING: return "Foxfire";

[130.616]

[135.507]

    case CARD_PORTAL:          return "the Portal";
    case CARD_WARP:            return "the Warp";
    case CARD_SWAP:            return "Swap";
    case CARD_VELOCITY:        return "Velocity";
    case CARD_DAMNATION:       return "Damnation";
    case CARD_SOLITUDE:        return "Solitude";
    case CARD_ELIXIR:          return "the Elixir";
    case CARD_BATTLELUST:      return "Battlelust";
    case CARD_METAMORPHOSIS:   return "Metamorphosis";
    case CARD_HELM:            return "the Helm";
    case CARD_BLADE:           return "the Blade";
    case CARD_SHADOW:          return "the Shadow";
    case CARD_POTION:          return "the Potion";
    case CARD_FOCUS:           return "Focus";
    case CARD_SHUFFLE:         return "Shuffle";
    case CARD_EXPERIENCE:      return "Experience";
    case CARD_HELIX:           return "the Helix";
    case CARD_SAGE:            return "the Sage";
    case CARD_DOWSING:         return "Dowsing";
    case CARD_TROWEL:          return "the Trowel";
    case CARD_MINEFIELD:       return "the Minefield";
    case CARD_GENIE:           return "the Genie";
    case CARD_TOMB:            return "the Tomb";
    case CARD_GLASS:           return "Vitrification";
    case CARD_MAP:             return "the Map";
    case CARD_BANSHEE:         return "the Banshee";
    case CARD_WILD_MAGIC:      return "Wild Magic";
    case CARD_CRUSADE:         return "the Crusade";
    case CARD_SUMMON_ANIMAL:   return "the Herd";
    case CARD_SUMMON_DEMON:    return "the Pentagram";
    case CARD_SUMMON_WEAPON:   return "the Dance";
    case CARD_SUMMON_FLYING:   return "Foxfire";

Replacement in crawl-ref/source/decks.cc at line 288 [25.3987460]

∅:D[135.558] → [129.13257:13336]

B:BD[129.13257] → [129.13257:13336]

∅:D[129.13336] → [130.2813:2893]

B:BD[130.2813] → [130.2813:2893]

B:BD[130.2893] → [129.13337:13499]

B:BD[129.13499] → [136.408:445]

B:BD[136.445] → [137.918:959]

∅:D[136.445] → [129.13499:13542]

∅:D[137.959] → [129.13499:13542]

B:BD[129.13499] → [129.13499:13542]

B:BD[129.13542] → [138.530:606]

∅:D[138.606] → [129.13542:13792]

B:BD[129.13542] → [129.13542:13792]

    case CARD_SUMMON_ANY: return "Summoning";
    case CARD_XOM: return "Xom";
    case CARD_FAMINE: return "Famine";
    case CARD_FEAST: return "the Feast";
    case CARD_WARPWRIGHT: return "Warpwright";
    case CARD_VITRIOL: return "Vitriol";
    case CARD_FLAME: return "Flame";
    case CARD_FROST: return "Frost";
    case CARD_VENOM: return "Venom";
    case CARD_SPARK: return "the Spark";
    case CARD_HAMMER: return "the Hammer";
    case CARD_PAIN: return "Pain";
    case CARD_TORMENT: return "Torment";
    case CARD_SPADE: return "the Spade";
    case CARD_BARGAIN: return "the Bargain";
    case CARD_WRATH: return "Wrath";
    case CARD_WRAITH: return "the Wraith";
    case CARD_CURSE: return "the Curse";
    case NUM_CARDS: return "a buggy card";

[135.558]

[130.3345]

    case CARD_SUMMON_ANY:      return "Summoning";
    case CARD_XOM:             return "Xom";
    case CARD_FAMINE:          return "Famine";
    case CARD_FEAST:           return "the Feast";
    case CARD_WARPWRIGHT:      return "Warpwright";
    case CARD_VITRIOL:         return "Vitriol";
    case CARD_FLAME:           return "Flame";
    case CARD_FROST:           return "Frost";
    case CARD_VENOM:           return "Venom";
    case CARD_SPARK:           return "the Spark";
    case CARD_HAMMER:          return "the Hammer";
    case CARD_PAIN:            return "Pain";
    case CARD_TORMENT:         return "Torment";
    case CARD_SPADE:           return "the Spade";
    case CARD_BARGAIN:         return "the Bargain";
    case CARD_WRATH:           return "Wrath";
    case CARD_WRAITH:          return "the Wraith";
    case CARD_CURSE:           return "the Curse";
    case NUM_CARDS:            return "a buggy card";

Replacement in crawl-ref/source/decks.cc at line 311 [25.3987460]

B:BD[139.6017] → [140.3157:3227]

static const deck_archetype* random_sub_deck(unsigned char deck_type)

[139.6017]

[25.3991776]

static const deck_archetype* _random_sub_deck(unsigned char deck_type)

Replacement in crawl-ref/source/decks.cc at line 353 [25.3987460]

B:BD[128.43974] → [140.4243:4375]

static card_type choose_from_archetype(const deck_archetype* pdeck,
                                       deck_rarity_type rarity)

[128.43974]

[128.44046]

static card_type _choose_from_archetype(const deck_archetype* pdeck,
                                        deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 376 [25.3987460]

B:BD[130.3602] → [140.4953:5079]

static card_type random_card(unsigned char deck_type, deck_rarity_type rarity,
                             bool &was_oddity)

[130.3602]

[141.21450]

static card_type _random_card(unsigned char deck_type, deck_rarity_type rarity,
                              bool &was_oddity)

Replacement in crawl-ref/source/decks.cc at line 379 [25.3987460]

B:BD[141.21452] → [140.5080:5142]

    const deck_archetype *pdeck = random_sub_deck(deck_type);

[141.21452]

[141.21470]

    const deck_archetype *pdeck = _random_sub_deck(deck_type);

Replacement in crawl-ref/source/decks.cc at line 387 [25.3987460]
B:BD[128.45021] → [140.5241:5290]
```
    return choose_from_archetype(pdeck, rarity);
```
[128.45021]
[128.45114]
```
    return _choose_from_archetype(pdeck, rarity);
```

Replacement in crawl-ref/source/decks.cc at line 390 [25.3987460]

B:BD[128.45117] → [140.5291:5360]

static card_type random_card(const item_def& item, bool &was_oddity)

[128.45117]

[128.45229]

static card_type _random_card(const item_def& item, bool &was_oddity)

Replacement in crawl-ref/source/decks.cc at line 392 [25.3987460]

B:BD[128.45231] → [140.5361:5431]

    return random_card(item.sub_type, deck_rarity(item), was_oddity);

[128.45231]

[128.45281]

    return _random_card(item.sub_type, deck_rarity(item), was_oddity);

Replacement in crawl-ref/source/decks.cc at line 395 [25.3987460]

B:BD[128.45284] → [128.45284:45399]

static card_type draw_top_card(item_def& deck, bool message,
                               unsigned char &_flags)

[128.45284]

[128.45399]

static card_type _draw_top_card(item_def& deck, bool message,
                                unsigned char &_flags)

Replacement in crawl-ref/source/decks.cc at line 418 [25.3987460]
B:BD[128.45996] → [128.45996:46028]
```
        check_odd_card(_flags);
```
[128.45996]
[128.46028]
```
        _check_odd_card(_flags);
```

Replacement in crawl-ref/source/decks.cc at line 424 [25.3987460]

B:BD[128.46055] → [128.46055:46161]

static void push_top_card(item_def& deck, card_type card,
                          unsigned char _flags)

[128.46055]

[128.46161]

static void _push_top_card(item_def& deck, card_type card,
                           unsigned char _flags)

Replacement in crawl-ref/source/decks.cc at line 435 [25.3987460]
∅:D[141.21526] → [142.3170:3198]
B:BD[130.4071] → [142.3170:3198]
```
static bool wielding_deck()
```
[141.21526]
[130.4095]
```
static bool _wielding_deck()
```

Replacement in crawl-ref/source/decks.cc at line 442 [25.3987460]

B:BD[143.1516] → [143.1516:1580]

static void remember_drawn_card(item_def& deck, card_type card)

[143.1516]

[143.1580]

static void _remember_drawn_card(item_def& deck, card_type card)

Replacement in crawl-ref/source/decks.cc at line 466 [25.3987460]
∅:D[143.2219] → [144.429:474]
B:BD[144.429] → [144.429:474]
```
static bool check_buggy_deck(item_def& deck)
```
[143.2219]
[144.474]
```
static bool _check_buggy_deck(item_def& deck)
```

Replacement in crawl-ref/source/decks.cc at line 695 [25.3987460]

B:BD[6.416] → [6.416:471]

static int choose_inventory_deck( const char* prompt )

[6.416]

[145.591]

static int _choose_inventory_deck( const char* prompt )

Replacement in crawl-ref/source/decks.cc at line 720 [25.3987460]

B:BD[6.908] → [6.908:979]

    const int slot = choose_inventory_deck( "Draw from which deck?" );

[6.908]

[6.979]

    const int slot = _choose_inventory_deck( "Draw from which deck?" );

Replacement in crawl-ref/source/decks.cc at line 732 [25.3987460]
B:BD[128.51451] → [128.51451:51495]
```
static void deck_peek_ident(item_def& deck)
```
[128.51451]
[128.51495]
```
static void _deck_peek_ident(item_def& deck)
```
Replacement in crawl-ref/source/decks.cc at line 748 [25.3987460]
B:BD[142.3461] → [142.3461:3489]
```
    if ( !wielding_deck() )
```
[142.3461]
[130.4133]
```
    if ( !_wielding_deck() )
```
Replacement in crawl-ref/source/decks.cc at line 756 [25.3987460]
B:BD[128.51843] → [128.51843:51875]
```
    if (check_buggy_deck(deck))
```
[128.51843]
[128.51875]
```
    if (_check_buggy_deck(deck))
```
Replacement in crawl-ref/source/decks.cc at line 776 [25.3987460]
B:BD[128.52313] → [128.52313:52344]
```
        deck_peek_ident(deck);
```
[128.52313]
[128.52344]
```
        _deck_peek_ident(deck);
```

Replacement in crawl-ref/source/decks.cc at line 780 [25.3987460]

B:BD[128.52397] → [128.52397:52477]

        set_card_and_flags(deck, 0, card1, flags1 | CFLAG_SEEN | CFLAG_MARKED);

[128.52397]

[128.52477]

        _set_card_and_flags(deck, 0, card1, flags1 | CFLAG_SEEN | CFLAG_MARKED);

Replacement in crawl-ref/source/decks.cc at line 795 [25.3987460]
B:BD[128.52796] → [128.52796:52827]
```
        deck_peek_ident(deck);
```
[128.52796]
[128.52827]
```
        _deck_peek_ident(deck);
```

Replacement in crawl-ref/source/decks.cc at line 828 [25.3987460]

B:BD[144.4408] → [128.53755:53885]

        set_card_and_flags(deck, 0, card1, flags1 | CFLAG_SEEN);
        set_card_and_flags(deck, 1, card2, flags2 | CFLAG_SEEN);

[144.4408]

[128.53885]

        _set_card_and_flags(deck, 0, card1, flags1 | CFLAG_SEEN);
        _set_card_and_flags(deck, 1, card2, flags2 | CFLAG_SEEN);

Replacement in crawl-ref/source/decks.cc at line 834 [25.3987460]
B:BD[128.53914] → [128.53914:53941]
```
    deck_peek_ident(deck);
```
[128.53914]
[128.53941]
```
    _deck_peek_ident(deck);
```

Replacement in crawl-ref/source/decks.cc at line 852 [25.3987460]

B:BD[128.54439] → [128.54439:54622]

    set_card_and_flags(deck, 0, card1, flags1 | CFLAG_SEEN);
    set_card_and_flags(deck, 1, card2, flags2 | CFLAG_SEEN);
    set_card_and_flags(deck, 2, card3, flags3 | CFLAG_SEEN);

[128.54439]

[128.54622]

    _set_card_and_flags(deck, 0, card1, flags1 | CFLAG_SEEN);
    _set_card_and_flags(deck, 1, card2, flags2 | CFLAG_SEEN);
    _set_card_and_flags(deck, 2, card3, flags3 | CFLAG_SEEN);

Replacement in crawl-ref/source/decks.cc at line 857 [25.3987460]
B:BD[128.54677] → [128.54677:54701]
```
    shuffle_deck(deck);
```
[128.54677]
[128.54701]
```
    _shuffle_deck(deck);
```
Replacement in crawl-ref/source/decks.cc at line 869 [25.3987460]
B:BD[128.55070] → [128.55070:55098]
```
    if ( !wielding_deck() )
```
[128.55070]
[128.55098]
```
    if ( !_wielding_deck() )
```
Replacement in crawl-ref/source/decks.cc at line 876 [25.3987460]
B:BD[128.55267] → [128.55267:55299]
```
    if (check_buggy_deck(deck))
```
[128.55267]
[144.4440]
```
    if (_check_buggy_deck(deck))
```
Replacement in crawl-ref/source/decks.cc at line 902 [25.3987460]
B:BD[128.55916] → [128.55916:55966]
```
        set_card_and_flags(deck, i, card, flags);
```
[128.55916]
[128.55966]
```
        _set_card_and_flags(deck, i, card, flags);
```
Replacement in crawl-ref/source/decks.cc at line 920 [25.3987460]
B:BD[145.1457] → [128.56333:56357]
```
    shuffle_deck(deck);
```
[145.1457]
[128.56357]
```
    _shuffle_deck(deck);
```

Replacement in crawl-ref/source/decks.cc at line 926 [25.3987460]

B:BD[146.333] → [146.333:459]

static void redraw_stacked_cards(const std::vector<card_type>& draws,
                                 unsigned int selected)

[146.333]

[146.459]

static void _redraw_stacked_cards(const std::vector<card_type>& draws,
                                  unsigned int selected)

Replacement in crawl-ref/source/decks.cc at line 945 [25.3987460]
∅:D[146.723] → [147.2287:2315]
B:BD[147.2287] → [147.2287:2315]
```
    if ( !wielding_deck() )
```
[146.723]
[147.2315]
```
    if ( !_wielding_deck() )
```
Replacement in crawl-ref/source/decks.cc at line 952 [25.3987460]
B:BD[128.56439] → [128.56439:56471]
```
    if (check_buggy_deck(deck))
```
[128.56439]
[144.4497]
```
    if (_check_buggy_deck(deck))
```

Replacement in crawl-ref/source/decks.cc at line 971 [25.3987460]

B:BD[128.56825] → [128.56825:56890]

        card_type     card = draw_top_card(deck, false, _flags);

[128.56825]

[147.2678]

        card_type     card = _draw_top_card(deck, false, _flags);

Replacement in crawl-ref/source/decks.cc at line 1004 [25.3987460]
B:BD[147.3228] → [146.1032:1079]
```
        redraw_stacked_cards(draws, selected);
```
[147.3228]
[146.1079]
```
        _redraw_stacked_cards(draws, selected);
```
Replacement in crawl-ref/source/decks.cc at line 1007 [25.3987460]
B:BD[146.1159] → [146.1159:1179]
```
        while (1) {
```
[146.1159]
[146.1179]
```
        while (true)
        {
```
Insertion in crawl-ref/source/decks.cc at line 1021 [25.3987460]
[147.3503]
[146.1555]
```
            
```

Replacement in crawl-ref/source/decks.cc at line 1033 [25.3987460]

B:BD[146.2021] → [146.2021:2076]

                redraw_stacked_cards(draws, selected);

[146.2021]

[147.3571]

                    
                _redraw_stacked_cards(draws, selected);

Replacement in crawl-ref/source/decks.cc at line 1042 [25.3987460]

B:BD[146.2159] → [146.2159:2268]

        push_top_card(deck, draws[draws.size() - 1 - i],
                      flags[flags.size() - 1 - i]);

[146.2159]

[146.2268]

    {
        _push_top_card(deck, draws[draws.size() - 1 - i],
                       flags[flags.size() - 1 - i]);
    }

Replacement in crawl-ref/source/decks.cc at line 1050 [25.3987460]
B:BD[128.57675] → [128.57675:57703]
```
    check_buggy_deck(deck);
```
[128.57675]
[128.57703]
```
    _check_buggy_deck(deck);
```

Replacement in crawl-ref/source/decks.cc at line 1058 [25.3987460]

B:BD[142.3916] → [6.1042:1118]

    const int slot = choose_inventory_deck("Triple draw from which deck?");

[142.3916]

[6.1118]

    const int slot = _choose_inventory_deck("Triple draw from which deck?");

Replacement in crawl-ref/source/decks.cc at line 1067 [25.3987460]
B:BD[144.4522] → [128.57741:57773]
```
    if (check_buggy_deck(deck))
```
[144.4522]
[144.4554]
```
    if (_check_buggy_deck(deck))
```

Replacement in crawl-ref/source/decks.cc at line 1094 [25.3987460]

B:BD[128.58134] → [128.58134:58199]

        card_type     card = draw_top_card(deck, false, _flags);

[128.58134]

[128.58199]

        card_type     card = _draw_top_card(deck, false, _flags);

Insertion in crawl-ref/source/decks.cc at line 1102 [25.3987460]
[130.4944]
[130.4944]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 1105 [25.3987460]
[130.5092]
[130.5092]
```
    }
```
Replacement in crawl-ref/source/decks.cc at line 1122 [25.3987460]
B:BD[143.2264] → [143.2264:2309]
```
        remember_drawn_card(deck, draws[i]);
```
[143.2264]
[128.58405]
```
        _remember_drawn_card(deck, draws[i]);
```

Replacement in crawl-ref/source/decks.cc at line 1147 [25.3987460]

B:BD[140.5449] → [140.5449:5569]

    card_type card = random_card(MISC_DECK_OF_PUNISHMENT, DECK_RARITY_COMMON,
                                 oddity);

[140.5449]

[128.58851]

    card_type card = _random_card(MISC_DECK_OF_PUNISHMENT, DECK_RARITY_COMMON,
                                  oddity);

Replacement in crawl-ref/source/decks.cc at line 1154 [25.3987460]

B:BD[128.58929] → [128.58929:59034]

static int xom_check_card(item_def &deck, card_type card,
                          unsigned char flags)

[128.58929]

[128.59034]

static int _xom_check_card(item_def &deck, card_type card,
                           unsigned char flags)

Replacement in crawl-ref/source/decks.cc at line 1196 [25.3987460]
B:BD[130.5779] → [144.4577:4609]
```
    if (check_buggy_deck(deck))
```
[130.5779]
[144.4609]
```
    if (_check_buggy_deck(deck))
```

Replacement in crawl-ref/source/decks.cc at line 1206 [25.3987460]

B:BD[148.742] → [148.742:797]

    card_type card = draw_top_card(deck, true, flags);

[148.742]

[148.797]

    card_type card = _draw_top_card(deck, true, flags);

Replacement in crawl-ref/source/decks.cc at line 1221 [25.3987460]

B:BD[148.1242] → [148.1242:1312]

            card = choose_from_archetype(deck_of_punishment, rarity);

[148.1242]

[148.1312]

            card = _choose_from_archetype(deck_of_punishment, rarity);

Replacement in crawl-ref/source/decks.cc at line 1233 [25.3987460]

B:BD[141.22252] → [148.1718:1779]

    const int amusement = xom_check_card(deck, card, flags);

[141.22252]

[148.1779]

    const int amusement   = _xom_check_card(deck, card, flags);

Replacement in crawl-ref/source/decks.cc at line 1243 [25.3987460]
B:BD[128.60436] → [143.2310:2347]
```
    remember_drawn_card(deck, card);
```
[128.60436]
[141.22564]
```
    _remember_drawn_card(deck, card);
```
Replacement in crawl-ref/source/decks.cc at line 1318 [25.3987460]
B:BD[129.16625] → [149.2058:2118]
```
static void portal_card(int power, deck_rarity_type rarity)
```
[129.16625]
[25.3994379]
```
static void _portal_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 1346 [25.3987460]
B:BD[25.3995341] → [149.2119:2177]
```
static void warp_card(int power, deck_rarity_type rarity)
```
[25.3995341]
[129.17409]
```
static void _warp_card(int power, deck_rarity_type rarity)
```

Replacement in crawl-ref/source/decks.cc at line 1357 [25.3987460]

B:BD[25.3995407] → [149.2178:2244]

static void swap_monster_card(int power, deck_rarity_type rarity)

[25.3995407]

[129.17702]

static void _swap_monster_card(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 1386 [25.3987460]
B:BD[25.3995466] → [149.2245:2307]
```
static void velocity_card(int power, deck_rarity_type rarity)
```
[25.3995466]
[129.17806]
```
static void _velocity_card(int power, deck_rarity_type rarity)
```
Deletion in crawl-ref/source/decks.cc at line 1390 [25.3987460]
B:BD[129.17896] → [129.17896:17902]
```
    {
```
Deletion in crawl-ref/source/decks.cc at line 1391 [25.3987460]
B:BD[129.17958] → [129.17958:17964]
```
    }
```
Deletion in crawl-ref/source/decks.cc at line 1397 [25.3987460]
B:BD[129.18123] → [129.18123:18129]
```
    {
```
Deletion in crawl-ref/source/decks.cc at line 1398 [25.3987460]
B:BD[129.18173] → [129.18173:18179]
```
    }
```

Replacement in crawl-ref/source/decks.cc at line 1400 [25.3987460]

B:BD[25.3997490] → [149.2308:2371]

static void damnation_card(int power, deck_rarity_type rarity)

[25.3997490]

[129.18238]

static void _damnation_card(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 1436 [25.3987460]

B:BD[25.3997938] → [149.2372:2436]

static void warpwright_card(int power, deck_rarity_type rarity)

[25.3997938]

[129.19113]

static void _warpwright_card(int power, deck_rarity_type rarity)

Deletion in crawl-ref/source/decks.cc at line 1447 [25.3987460]
B:BD[129.19199] → [129.19199:19205]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 1451 [25.3987460]
[25.3998062]
[129.19288]

Replacement in crawl-ref/source/decks.cc at line 1454 [25.3987460]

B:BD[129.19374] → [129.19374:19446]

            if ( grd[rx][ry] == DNGN_FLOOR && trap_at_xy(rx,ry) == -1 )

[129.19374]

[25.3998259]


            if ( grd[rx][ry] == DNGN_FLOOR && trap_at_xy(rx,ry) == -1
                 && one_chance_in(++count) )

Replacement in crawl-ref/source/decks.cc at line 1458 [25.3987460]

B:BD[25.3998273] → [129.19447:19587]

                if ( one_chance_in(++count) )
                {
                    fx = rx;
                    fy = ry;
                }

[25.3998273]

[25.3998359]

                 fx = rx;
                 fy = ry;

Deletion in crawl-ref/source/decks.cc at line 1462 [25.3987460]
B:BD[25.3998562] → [129.19588:19594]
```
    }
```

Replacement in crawl-ref/source/decks.cc at line 1478 [25.3987460]

B:BD[25.3999075] → [27.4921:4984]

static void minefield_card(int power, deck_rarity_type rarity)

[25.3999075]

[27.4984]

static void _minefield_card(int power, deck_rarity_type rarity)

Deletion in crawl-ref/source/decks.cc at line 1483 [25.3987460]
B:BD[27.5142] → [27.5142:5148]
```
    {
```

Replacement in crawl-ref/source/decks.cc at line 1494 [25.3987460]

B:BD[27.5507] → [27.5507:5630]

            if ( grd[rx][ry] == DNGN_FLOOR && trap_at_xy(rx,ry) == -1 &&
                 one_chance_in(4 - power_level) )

[27.5507]

[27.5630]

                
            if ( grd[rx][ry] == DNGN_FLOOR && trap_at_xy(rx,ry) == -1
                 && one_chance_in(4 - power_level) )

Deletion in crawl-ref/source/decks.cc at line 1504 [25.3987460]
B:BD[137.970] → [137.970:976]
```
    }
```

Replacement in crawl-ref/source/decks.cc at line 1506 [25.3987460]

B:BD[137.979] → [137.979:1041]

static int drain_monsters(int x, int y, int pow, int garbage)

[137.979]

[137.1041]

static int _drain_monsters(int x, int y, int pow, int garbage)

Replacement in crawl-ref/source/decks.cc at line 1547 [25.3987460]
B:BD[137.1989] → [137.1989:2021]
```
static void mass_drain(int pow)
```
[137.1989]
[137.2021]
```
static void _mass_drain(int pow)
```
Replacement in crawl-ref/source/decks.cc at line 1549 [25.3987460]
B:BD[137.2023] → [137.2023:2068]
```
    apply_area_visible(drain_monsters, pow);
```
[137.2023]
[27.5732]
```
    apply_area_visible(_drain_monsters, pow);
```

Replacement in crawl-ref/source/decks.cc at line 1554 [25.3987460]

B:BD[150.1245] → [150.1245:1323]

static bool damaging_card(card_type card, int power, deck_rarity_type rarity)

[150.1245]

[129.20097]

static bool _damaging_card(card_type card, int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 1562 [25.3987460]

B:BD[136.627] → [136.627:776]

    const zap_type firezaps[3] = { ZAP_FLAME, ZAP_STICKY_FLAME, ZAP_FIRE };
    const zap_type frostzaps[3] = { ZAP_FROST, ZAP_ICE_BOLT, ZAP_COLD };

[136.627]

[136.776]

    const zap_type firezaps[3]   = { ZAP_FLAME, ZAP_STICKY_FLAME, ZAP_FIRE };
    const zap_type frostzaps[3]  = { ZAP_FROST, ZAP_ICE_BOLT, ZAP_COLD };

Replacement in crawl-ref/source/decks.cc at line 1566 [25.3987460]

B:BD[136.902] → [136.902:1021]

B:BD[136.1021] → [137.2069:2268]

    const zap_type venomzaps[3] = { ZAP_STING, ZAP_VENOM_BOLT,
                                    ZAP_POISON_ARROW };
    const zap_type sparkzaps[3] = { ZAP_ELECTRICITY, ZAP_LIGHTNING,
                                    ZAP_ORB_OF_ELECTRICITY };
    const zap_type painzaps[2] = { ZAP_AGONY, ZAP_NEGATIVE_ENERGY };

[136.902]

[136.1021]

    const zap_type venomzaps[3]  = { ZAP_STING, ZAP_VENOM_BOLT,
                                     ZAP_POISON_ARROW };
    const zap_type sparkzaps[3]  = { ZAP_ELECTRICITY, ZAP_LIGHTNING,
                                     ZAP_ORB_OF_ELECTRICITY };
    const zap_type painzaps[2]   = { ZAP_AGONY, ZAP_NEGATIVE_ENERGY };

Replacement in crawl-ref/source/decks.cc at line 1601 [25.3987460]
B:BD[137.2389] → [137.2389:2420]
```
            mass_drain(power);
```
[137.2389]
[137.2420]
```
            _mass_drain(power);
```
Replacement in crawl-ref/source/decks.cc at line 1620 [25.3987460]
B:BD[25.3999220] → [149.2518:2578]
```
static void elixir_card(int power, deck_rarity_type rarity)
```
[25.3999220]
[129.20728]
```
static void _elixir_card(int power, deck_rarity_type rarity)
```

Replacement in crawl-ref/source/decks.cc at line 1648 [25.3987460]

B:BD[25.4000136] → [149.2579:2644]

static void battle_lust_card(int power, deck_rarity_type rarity)

[25.4000136]

[129.21335]

static void _battle_lust_card(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 1665 [25.3987460]

B:BD[25.4000356] → [149.2645:2712]

static void metamorphosis_card(int power, deck_rarity_type rarity)

[25.4000356]

[129.21693]

// doesn't allow transformation into bat
static void _metamorphosis_card(int power, deck_rarity_type rarity)

Insertion in crawl-ref/source/decks.cc at line 1670 [25.3987460]
[129.21786]
[129.21786]
```
    
```
Insertion in crawl-ref/source/decks.cc at line 1677 [25.3987460]
[9.488]
[129.21942]
```
        
```
Replacement in crawl-ref/source/decks.cc at line 1681 [25.3987460]
B:BD[25.4000542] → [149.2713:2771]
```
static void helm_card(int power, deck_rarity_type rarity)
```
[25.4000542]
[129.22036]
```
static void _helm_card(int power, deck_rarity_type rarity)
```
Insertion in crawl-ref/source/decks.cc at line 1722 [25.3987460]
[27.6237]
[27.6237]
```
        
```
Replacement in crawl-ref/source/decks.cc at line 1746 [25.3987460]
B:BD[129.23077] → [149.2772:2831]
```
static void blade_card(int power, deck_rarity_type rarity)
```
[25.4000923]
[129.23129]
```
static void _blade_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 1786 [25.3987460]
B:BD[25.4002047] → [149.2832:2892]
```
static void shadow_card(int power, deck_rarity_type rarity)
```
[25.4002047]
[129.23538]
```
static void _shadow_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 1800 [25.3987460]
B:BD[25.4002323] → [149.2893:2953]
```
static void potion_card(int power, deck_rarity_type rarity)
```
[25.4002323]
[129.23795]
```
static void _potion_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 1821 [25.3987460]
B:BD[25.4002903] → [149.2954:3013]
```
static void focus_card(int power, deck_rarity_type rarity)
```
[25.4002903]
[129.24457]
```
static void _focus_card(int power, deck_rarity_type rarity)
```
Insertion in crawl-ref/source/decks.cc at line 1833 [25.3987460]
[129.24849]
[129.24849]
```
            
```
Replacement in crawl-ref/source/decks.cc at line 1841 [25.3987460]
B:BD[129.25064] → [129.25064:25096]
```
        best_stat = random2(3);
```
[129.25064]
[129.25096]
```
        best_stat  = random2(3);
```
Replacement in crawl-ref/source/decks.cc at line 1885 [25.3987460]
B:BD[25.4003802] → [149.3014:3075]
```
static void shuffle_card(int power, deck_rarity_type rarity)
```
[25.4003802]
[129.25422]
```
static void _shuffle_card(int power, deck_rarity_type rarity)
```

Replacement in crawl-ref/source/decks.cc at line 1953 [25.3987460]

B:BD[11.365] → [11.365:429]

static void experience_card(int power, deck_rarity_type rarity)

[11.365]

[11.429]

static void _experience_card(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 1987 [25.3987460]
B:BD[25.4004028] → [27.6893:6952]
```
static void helix_card(int power, deck_rarity_type rarity)
```
[25.4004028]
[129.25570]
```
static void _helix_card(int power, deck_rarity_type rarity)
```
Deletion in crawl-ref/source/decks.cc at line 1998 [25.3987460]
B:BD[129.25899] → [129.25899:25905]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 1999 [25.3987460]
[129.25983]
[129.25983]
```
        {
```
Replacement in crawl-ref/source/decks.cc at line 2002 [25.3987460]
B:BD[129.26074] → [129.26074:26080]
```
    }
```
[129.26074]
[129.26080]
```
        }
```
Replacement in crawl-ref/source/decks.cc at line 2010 [25.3987460]
B:BD[131.1939] → [131.1939:1997]
```
static void sage_card(int power, deck_rarity_type rarity)
```
[131.1939]
[131.1997]
```
static void _sage_card(int power, deck_rarity_type rarity)
```

Replacement in crawl-ref/source/decks.cc at line 2053 [25.3987460]

B:BD[132.501] → [132.501:560]

static void glass_card(int power, deck_rarity_type rarity)

[132.501]

[132.560]

static void _glass_card(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 2060 [25.3987460]
B:BD[25.4004530] → [149.3147:3208]
```
static void dowsing_card(int power, deck_rarity_type rarity)
```
[25.4004530]
[129.26193]
```
static void _dowsing_card(int power, deck_rarity_type rarity)
```
Insertion in crawl-ref/source/decks.cc at line 2070 [25.3987460]
[129.26443]
[129.26443]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 2073 [25.3987460]
[129.26517]
[25.4005267]
```
    }
```
Replacement in crawl-ref/source/decks.cc at line 2083 [25.3987460]
B:BD[25.4005392] → [151.6950:7010]
```
static bool trowel_card(int power, deck_rarity_type rarity)
```
[25.4005392]
[129.26897]
```
static bool _trowel_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 2189 [25.3987460]
B:BD[25.4005919] → [149.3334:3393]
```
static void genie_card(int power, deck_rarity_type rarity)
```
[25.4005919]
[129.26993]
```
static void _genie_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 2208 [25.3987460]
B:BD[25.4006221] → [149.3394:3420]
```
static void godly_wrath()
```
[25.4006221]
[149.3420]
```
// special case for *your* god maybe?
static void _godly_wrath()
```
Replacement in crawl-ref/source/decks.cc at line 2214 [25.3987460]
B:BD[149.3491] → [149.3491:3550]
```
static void curse_card(int power, deck_rarity_type rarity)
```
[149.3491]
[149.3550]
```
static void _curse_card(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 2230 [25.3987460]
B:BD[149.3923] → [149.3923:3962]
```
        } while ( !one_chance_in(4) );
```
[149.3923]
[149.3962]
```
        }
        while ( !one_chance_in(4) );
```

Replacement in crawl-ref/source/decks.cc at line 2241 [25.3987460]

B:BD[149.4103] → [133.544:605]

static void crusade_card(int power, deck_rarity_type rarity)

[149.4103]

[133.605]

static void _crusade_card(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 2250 [25.3987460]

B:BD[133.850] → [133.850:1059]

B:BD[133.1059] → [152.2660:2706]

B:BD[152.2706] → [16.2660:2730]

            if (monster->type == -1 || !mons_near(monster) ||
                mons_friendly(monster) ||
                mons_holiness(monster) != MH_NATURAL ||
                mons_is_unique(monster->type) ||
                mons_immune_magic(monster) ||
                (is_good_god(you.religion) && mons_is_evil(monster)))

[133.850]

[152.2802]

            if (monster->type == -1 || !mons_near(monster)
                || mons_friendly(monster)
                || mons_holiness(monster) != MH_NATURAL
                || mons_is_unique(monster->type)
                || mons_immune_magic(monster)
                || (is_good_god(you.religion) && mons_is_evil(monster)))

Replacement in crawl-ref/source/decks.cc at line 2285 [25.3987460]
∅:D[133.1715] → [27.6953:7019]
B:BD[149.4103] → [27.6953:7019]
```
static void summon_demon_card(int power, deck_rarity_type rarity)
```
[133.1715]
[27.7019]
```
static void _summon_demon_card(int power, deck_rarity_type rarity)
```
Insertion in crawl-ref/source/decks.cc at line 2295 [25.3987460]
[27.7262]
[153.291]
```
        
```

Replacement in crawl-ref/source/decks.cc at line 2301 [25.3987460]

B:BD[154.1961] → [154.1961:2028]

static void summon_any_monster(int power, deck_rarity_type rarity)

[154.1961]

[154.2028]

static void _summon_any_monster(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 2315 [25.3987460]
B:BD[154.2323] → [154.2323:2367]
```
    for ( int i = 0; i < num_tries; ++i ) {
```
[154.2323]
[154.2367]
```
    for ( int i = 0; i < num_tries; ++i )
    {
```
Replacement in crawl-ref/source/decks.cc at line 2318 [25.3987460]
B:BD[154.2387] → [154.2387:2400]
```
        do {
```
[154.2387]
[154.2400]
```
        do
        {
```

Replacement in crawl-ref/source/decks.cc at line 2322 [25.3987460]

B:BD[154.2466] → [154.2466:2506]

        } while ( dx == 0 && dy == 0 );

[154.2466]

[154.2506]

        }
        while ( dx == 0 && dy == 0 );

Replacement in crawl-ref/source/decks.cc at line 2326 [25.3987460]
B:BD[154.2536] → [154.2536:2549]
```
        do {
```
[154.2536]
[154.2549]
```
        do
        {
```

Replacement in crawl-ref/source/decks.cc at line 2329 [25.3987460]

B:BD[154.2627] → [154.2627:2672]

        } while ( mons_is_unique(cur_try) );

[154.2627]

[154.2672]

        }
        while ( mons_is_unique(cur_try) );

Replacement in crawl-ref/source/decks.cc at line 2352 [25.3987460]

B:BD[149.4104] → [155.291:361]

static void summon_dancing_weapon(int power, deck_rarity_type rarity)

[149.4104]

[155.361]

static void _summon_dancing_weapon(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 2407 [25.3987460]

B:BD[134.461] → [134.461:523]

static void summon_flying(int power, deck_rarity_type rarity)

[134.461]

[134.523]

static void _summon_flying(int power, deck_rarity_type rarity)

Replacement in crawl-ref/source/decks.cc at line 2420 [25.3987460]
B:BD[134.949] → [134.949:958]
```
    do {
```
[134.949]
[134.958]
```
    do
    {
```

Replacement in crawl-ref/source/decks.cc at line 2423 [25.3987460]

B:BD[134.1011] → [134.1011:1110]

    } while ( friendly && mons_class_flag(result, M_INVIS) &&
              !player_see_invis() );

[134.1011]

[134.1110]

    }
    while ( friendly && mons_class_flag(result, M_INVIS)
            && !player_see_invis() );

Insertion in crawl-ref/source/decks.cc at line 2428 [25.3987460]
[134.1163]
[134.1163]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 2432 [25.3987460]
[156.20823]
[134.1339]
```
    }
```
Replacement in crawl-ref/source/decks.cc at line 2435 [25.3987460]
∅:D[134.1342] → [135.604:668]
B:BD[135.604] → [135.604:668]
```
static void summon_skeleton(int power, deck_rarity_type rarity)
```
[134.1342]
[135.668]
```
static void _summon_skeleton(int power, deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 2448 [25.3987460]
∅:D[155.735] → [149.4104:4151]
B:BD[149.4104] → [149.4104:4151]
```
static int card_power(deck_rarity_type rarity)
```
[155.735]
[129.27197]
```
static int _card_power(deck_rarity_type rarity)
```
Replacement in crawl-ref/source/decks.cc at line 2466 [25.3987460]
∅:D[10.953] → [129.27640:27683]
B:BD[129.27640] → [129.27640:27683]
```
    if ( rarity == DECK_RARITY_LEGENDARY )
```
[10.953]
[10.954]
```
    else if ( rarity == DECK_RARITY_LEGENDARY )
```
Replacement in crawl-ref/source/decks.cc at line 2476 [25.3987460]
∅:D[150.1499] → [129.27807:27849]
B:BD[129.27807] → [129.27807:27849]
```
    const int power = card_power(rarity);
```
[150.1499]
[157.15320]
```
    const int power = _card_power(rarity);
    
```
Insertion in crawl-ref/source/decks.cc at line 2485 [25.3987460]
[128.61561]
[128.61561]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 2488 [25.3987460]
[128.61670]
[25.4007032]
```
    }
```

Replacement in crawl-ref/source/decks.cc at line 2505 [25.3987460]

∅:D[128.61729] → [129.28010:28354]

B:BD[129.28010] → [129.28010:28354]

    case CARD_PORTAL:           portal_card(power, rarity); break;
    case CARD_WARP:             warp_card(power, rarity); break;
    case CARD_SWAP:             swap_monster_card(power, rarity); break;
    case CARD_VELOCITY:         velocity_card(power, rarity); break;
    case CARD_DAMNATION:        damnation_card(power, rarity); break;

[129.27982]

[129.28354]

    case CARD_PORTAL:           _portal_card(power, rarity); break;
    case CARD_WARP:             _warp_card(power, rarity); break;
    case CARD_SWAP:             _swap_monster_card(power, rarity); break;
    case CARD_VELOCITY:         _velocity_card(power, rarity); break;
    case CARD_DAMNATION:        _damnation_card(power, rarity); break;

Replacement in crawl-ref/source/decks.cc at line 2511 [25.3987460]

B:BD[129.28418] → [129.28418:29030]

B:BD[129.29030] → [11.1458:1529]

∅:D[11.1529] → [27.7372:7438]

B:BD[129.29109] → [27.7372:7438]

B:BD[27.7438] → [131.3134:3199]

∅:D[131.3199] → [132.1365:1431]

B:BD[27.7438] → [132.1365:1431]

∅:D[132.1431] → [129.29186:29254]

∅:D[27.7438] → [129.29186:29254]

B:BD[129.29186] → [129.29186:29254]

B:BD[129.29321] → [129.29321:29457]

B:BD[129.29457] → [149.4152:4289]

    case CARD_ELIXIR:           elixir_card(power, rarity); break;
    case CARD_BATTLELUST:       battle_lust_card(power, rarity); break;
    case CARD_METAMORPHOSIS:    metamorphosis_card(power, rarity); break;
    case CARD_HELM:             helm_card(power, rarity); break;
    case CARD_BLADE:            blade_card(power, rarity); break;
    case CARD_SHADOW:           shadow_card(power, rarity); break;
    case CARD_POTION:           potion_card(power, rarity); break;
    case CARD_FOCUS:            focus_card(power, rarity); break;
    case CARD_SHUFFLE:          shuffle_card(power, rarity); break;
    case CARD_EXPERIENCE:       experience_card(power, rarity); break;
    case CARD_HELIX:            helix_card(power, rarity); break;
    case CARD_SAGE:             sage_card(power, rarity); break;
    case CARD_GLASS:            glass_card(power, rarity); break;
    case CARD_DOWSING:          dowsing_card(power, rarity); break;
    case CARD_MINEFIELD:        minefield_card(power, rarity); break;
    case CARD_GENIE:            genie_card(power, rarity); break;
    case CARD_CURSE:            curse_card(power, rarity); break;
    case CARD_WARPWRIGHT:       warpwright_card(power, rarity); break;

[129.28418]

[158.686]

    case CARD_ELIXIR:           _elixir_card(power, rarity); break;
    case CARD_BATTLELUST:       _battle_lust_card(power, rarity); break;
    case CARD_METAMORPHOSIS:    _metamorphosis_card(power, rarity); break;
    case CARD_HELM:             _helm_card(power, rarity); break;
    case CARD_BLADE:            _blade_card(power, rarity); break;
    case CARD_SHADOW:           _shadow_card(power, rarity); break;
    case CARD_POTION:           _potion_card(power, rarity); break;
    case CARD_FOCUS:            _focus_card(power, rarity); break;
    case CARD_SHUFFLE:          _shuffle_card(power, rarity); break;
    case CARD_EXPERIENCE:       _experience_card(power, rarity); break;
    case CARD_HELIX:            _helix_card(power, rarity); break;
    case CARD_SAGE:             _sage_card(power, rarity); break;
    case CARD_GLASS:            _glass_card(power, rarity); break;
    case CARD_DOWSING:          _dowsing_card(power, rarity); break;
    case CARD_MINEFIELD:        _minefield_card(power, rarity); break;
    case CARD_GENIE:            _genie_card(power, rarity); break;
    case CARD_CURSE:            _curse_card(power, rarity); break;
    case CARD_WARPWRIGHT:       _warpwright_card(power, rarity); break;

Replacement in crawl-ref/source/decks.cc at line 2531 [25.3987460]

∅:D[7.529] → [149.4356:4410]

B:BD[149.4356] → [149.4356:4410]

B:BD[149.4410] → [133.1716:1784]

∅:D[133.1784] → [27.7439:7512]

B:BD[149.4410] → [27.7439:7512]

    case CARD_WRATH:            godly_wrath(); break;
    case CARD_CRUSADE:          crusade_card(power, rarity); break;
    case CARD_SUMMON_DEMON:     summon_demon_card(power, rarity); break;

[7.529]

[154.3277]

    case CARD_WRATH:            _godly_wrath(); break;
    case CARD_CRUSADE:          _crusade_card(power, rarity); break;
    case CARD_SUMMON_DEMON:     _summon_demon_card(power, rarity); break;

Replacement in crawl-ref/source/decks.cc at line 2535 [25.3987460]

B:BD[154.3350] → [154.3350:3424]

B:BD[154.3424] → [135.1166:1243]

B:BD[135.1243] → [134.1423:1492]

∅:D[134.1492] → [135.1243:1314]

B:BD[135.1243] → [135.1243:1314]

    case CARD_SUMMON_ANY:       summon_any_monster(power, rarity); break;
    case CARD_SUMMON_WEAPON:    summon_dancing_weapon(power, rarity); break;
    case CARD_SUMMON_FLYING:    summon_flying(power, rarity); break;
    case CARD_SUMMON_SKELETON:  summon_skeleton(power, rarity); break;

[154.3350]

[159.998]

    case CARD_SUMMON_ANY:       _summon_any_monster(power, rarity); break;
    case CARD_SUMMON_WEAPON:    _summon_dancing_weapon(power, rarity); break;
    case CARD_SUMMON_FLYING:    _summon_flying(power, rarity); break;
    case CARD_SUMMON_SKELETON:  _summon_skeleton(power, rarity); break;

Replacement in crawl-ref/source/decks.cc at line 2540 [25.3987460]

B:BD[159.1070] → [151.7229:7296]

∅:D[151.7296] → [160.2946:3023]

B:BD[160.2946] → [160.2946:3023]

    case CARD_TROWEL:      rc = trowel_card(power, rarity); break;
    case CARD_SPADE: your_spells(SPELL_DIG, random2(power/4), false); break;

[159.1070]

[158.741]

    case CARD_TROWEL:      rc = _trowel_card(power, rarity); break;
    case CARD_SPADE:   your_spells(SPELL_DIG, random2(power/4), false); break;

Replacement in crawl-ref/source/decks.cc at line 2549 [25.3987460]

B:BD[136.1643] → [150.1500:1559]

            rc = damaging_card(which_card, power, rarity);

[136.1643]

[136.1697]

            rc = _damaging_card(which_card, power, rarity);

Replacement in crawl-ref/source/decks.cc at line 2552 [25.3987460]

∅:D[136.1713] → [129.29690:29765]

B:BD[129.29690] → [129.29690:29765]

B:BD[129.29765] → [137.2512:2552]

∅:D[137.2552] → [150.1560:1615]

B:BD[138.768] → [150.1560:1615]

    case CARD_VITRIOL: case CARD_FLAME: case CARD_FROST: case CARD_HAMMER:
    case CARD_SPARK:   case CARD_PAIN: 
        rc = damaging_card(which_card, power, rarity);

[136.1713]

[25.4007476]

    case CARD_VITRIOL:
    case CARD_FLAME:
    case CARD_FROST:
    case CARD_HAMMER:
    case CARD_SPARK:
    case CARD_PAIN:
        rc = _damaging_card(which_card, power, rarity);

Replacement in crawl-ref/source/decks.cc at line 2696 [25.3987460]

B:BD[128.63169] → [128.63169:63225]

        card_type card    = random_card(item, was_odd);

[128.63169]

[128.63225]

        card_type card    = _random_card(item, was_odd);

Replacement in crawl-ref/source/decks.cc at line 2702 [25.3987460]
B:BD[128.63315] → [128.63315:63365]
```
        set_card_and_flags(item, i, card, flags);
```
[128.63315]
[128.63365]
```
        _set_card_and_flags(item, i, card, flags);
```
Replacement in crawl-ref/source/decks.cc at line 2716 [25.3987460]
B:BD[161.4209] → [161.4209:4249]
```
static void unmark_deck(item_def& deck)
```
[161.4209]
[161.4249]
```
static void _unmark_deck(item_def& deck)
```
Insertion in crawl-ref/source/decks.cc at line 2728 [25.3987460]
[161.4491]
[161.4491]
```
    {
```
Insertion in crawl-ref/source/decks.cc at line 2731 [25.3987460]
[161.4588]
[161.4588]
```
    }
```
Replacement in crawl-ref/source/decks.cc at line 2737 [25.3987460]
B:BD[161.4696] → [161.4696:4748]
```
static void unmark_and_shuffle_deck(item_def& deck)
```
[161.4696]
[161.4748]
```
static void _unmark_and_shuffle_deck(item_def& deck)
```

Replacement in crawl-ref/source/decks.cc at line 2741 [25.3987460]

B:BD[161.4781] → [161.4781:4836]

        unmark_deck(deck);
        shuffle_deck(deck);

[161.4781]

[12.3051]

        _unmark_deck(deck);
        _shuffle_deck(deck);

Replacement in crawl-ref/source/decks.cc at line 2746 [25.3987460]
B:BD[161.4848] → [12.3058:3099]
```
static bool shuffle_all_decks_on_level()
```
[161.4848]
[161.4889]
```
static bool _shuffle_all_decks_on_level()
```
Replacement in crawl-ref/source/decks.cc at line 2761 [25.3987460]
B:BD[161.5296] → [161.5296:5339]
```
            unmark_and_shuffle_deck(item);
```
[161.5296]
[12.3128]
```
            _unmark_and_shuffle_deck(item);
```
Replacement in crawl-ref/source/decks.cc at line 2770 [25.3987460]
B:BD[161.5357] → [12.3180:3218]
```
static bool shuffle_inventory_decks()
```
[161.5357]
[161.5395]
```
static bool _shuffle_inventory_decks()
```
Replacement in crawl-ref/source/decks.cc at line 2783 [25.3987460]
B:BD[161.5690] → [161.5690:5733]
```
            unmark_and_shuffle_deck(item);
```
[161.5690]
[12.3247]
```
            _unmark_and_shuffle_deck(item);
```

Replacement in crawl-ref/source/decks.cc at line 2796 [25.3987460]

B:BD[12.3326] → [12.3326:3385]

    if (apply_to_all_dungeons(shuffle_all_decks_on_level))

[12.3326]

[12.3385]

    if (apply_to_all_dungeons(_shuffle_all_decks_on_level))

Replacement in crawl-ref/source/decks.cc at line 2799 [25.3987460]
B:BD[12.3410] → [12.3410:3445]
```
    if (shuffle_inventory_decks())
```
[12.3410]
[12.3445]
```
    if (_shuffle_inventory_decks())
```
Replacement in crawl-ref/source/acr.cc at line 1036 [25.4397395]
B:BD[13.3758] → [13.3758:3775]
```
            do {
```
[13.3758]
[13.3775]
```
            do
            {
```

Replacement in crawl-ref/source/acr.cc at line 1039 [25.4397395]

B:BD[13.3807] → [13.3807:3943]

            } while (old_piety < MAX_PIETY && old_piety == you.piety
                     && old_penance == you.penance[you.religion]);

[13.3807]

[13.3943]

            }
            while (old_piety < MAX_PIETY && old_piety == you.piety
                   && old_penance == you.penance[you.religion]);

Deletion in crawl-ref/source/acr.cc at line 1083 [25.4397395]
B:BD[25.4416875] → [25.4416875:4416885]
```
        {
```
Replacement in crawl-ref/source/acr.cc at line 1095 [25.4397395]
B:BD[25.4417413] → [25.4417413:4417423]
```
        }
```
[25.4417413]
[25.4417423]
Replacement in crawl-ref/source/acr.cc at line 2082 [25.4397395]
B:BD[32.1265687] → [32.1265687:1265708]
```
        int index=0;
```
[32.1265687]
[25.4430674]
```
        int index = 0;
```

Replacement in crawl-ref/source/acr.cc at line 2812 [25.4397395]

B:BD[162.6150] → [162.6150:6266]

            if ( you.religion == GOD_TROG && you.piety > random2(150) &&
                 !player_under_penance() )

[162.6150]

[162.6266]

            if ( you.religion == GOD_TROG && you.piety > random2(150)
                 && !player_under_penance() )
            {

Insertion in crawl-ref/source/acr.cc at line 2816 [25.4397395]
[162.6330]
[162.6330]
```
            }
```
Replacement in crawl-ref/source/acr.cc at line 3618 [25.4397395]
B:BD[163.400] → [17.4359:4387]
```
            switch (feat) {
```
[163.400]
[17.4387]
```
            switch (feat)
            {
```
Deletion in crawl-ref/source/acr.cc at line 4224 [25.4397395]
B:BD[25.4480766] → [25.4480766:4480776]
```
        {
```
Deletion in crawl-ref/source/acr.cc at line 4226 [25.4397395]
B:BD[25.4480844] → [25.4480844:4480854]
```
        }
```
Deletion in crawl-ref/source/acr.cc at line 4231 [25.4397395]
B:BD[25.4481038] → [25.4481038:4481048]
```
        {
```
Deletion in crawl-ref/source/acr.cc at line 4233 [25.4397395]
B:BD[25.4481110] → [25.4481110:4481120]
```
        }
```
Replacement in crawl-ref/source/acr.cc at line 4356 [25.4397395]
B:BD[164.34702] → [164.34702:34715]
```
        do {
```
[164.34702]
[164.34715]
```
        do
        {
```

Replacement in crawl-ref/source/acr.cc at line 4359 [25.4397395]

B:BD[164.34762] → [164.34762:34812]

        } while (repeat_again_rec.keys[0] != ch);

[164.34762]

[164.34812]

        }
        while (repeat_again_rec.keys[0] != ch);

Replacement in crawl-ref/source/acr.cc at line 4585 [25.4397395]
B:BD[18.3275] → [18.3275:3320]
```
    for (int i=0; i<NUM_BRANCHES; i++)
    {
```
[18.3275]
[18.3320]
```
    for (int i = 0; i < NUM_BRANCHES; i++)
```
Deletion in crawl-ref/source/acr.cc at line 4587 [25.4397395]
B:BD[18.3357] → [18.3357:3363]
```
    }
```

Code cleanup and renaming of static methods, mostly for decks.cc and

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/tile1.cc at line 1649 [21.96318]

Replacement in crawl-ref/source/tile1.cc at line 1658 [21.96318]

Deletion in crawl-ref/source/tile1.cc at line 3404 [21.96318]

Replacement in crawl-ref/source/tile1.cc at line 3406 [21.96318]

Deletion in crawl-ref/source/tile1.cc at line 3433 [21.96318]

Replacement in crawl-ref/source/tile1.cc at line 3435 [21.96318]

Deletion in crawl-ref/source/tile1.cc at line 3740 [21.96318]

Deletion in crawl-ref/source/tile1.cc at line 3744 [21.96318]

Deletion in crawl-ref/source/tile1.cc at line 4003 [21.96318]

Deletion in crawl-ref/source/tile1.cc at line 4004 [21.96318]

Insertion in crawl-ref/source/spl-cast.cc at line 89 [25.293070]

Insertion in crawl-ref/source/spl-cast.cc at line 91 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 93 [25.293070]

Deletion in crawl-ref/source/spl-cast.cc at line 99 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 113 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 339 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 993 [25.293070]

Deletion in crawl-ref/source/spl-cast.cc at line 1499 [25.293070]

Deletion in crawl-ref/source/spl-cast.cc at line 1500 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 2205 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 2208 [25.293070]

Insertion in crawl-ref/source/spl-cast.cc at line 3630 [25.293070]

Deletion in crawl-ref/source/spl-cast.cc at line 3634 [25.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 3636 [25.293070]

Replacement in crawl-ref/source/monstuff.cc at line 314 [25.1396662]

Replacement in crawl-ref/source/monstuff.cc at line 2095 [25.1396662]

Insertion in crawl-ref/source/monstuff.cc at line 2098 [25.1396662]

Replacement in crawl-ref/source/monstuff.cc at line 2102 [25.1396662]

Insertion in crawl-ref/source/monstuff.cc at line 2106 [25.1396662]

Replacement in crawl-ref/source/monstuff.cc at line 3977 [25.1396662]

Replacement in crawl-ref/source/monstuff.cc at line 3982 [25.1396662]

Replacement in crawl-ref/source/monstuff.cc at line 3987 [25.1396662]

Deletion in crawl-ref/source/monstuff.cc at line 4033 [25.1396662]

Deletion in crawl-ref/source/monstuff.cc at line 4034 [25.1396662]