fiddlerwoaroof/crawl - Change LUSG5HYFRMFNS3RACRCUJNQXJNXPL4SYKHHOIEG5RBQG2DKQXPDAC

Splitting up stuff.cc.

New: colour.cc, coord.cc, coordit.cc, random.cc, rng.cc.

Created by Robert Vollmert on October 30, 2009

LUSG5HYFRMFNS3RACRCUJNQXJNXPL4SYKHHOIEG5RBQG2DKQXPDAC

Dependencies

In channels

main

Change contents

Deletion in crawl-ref/source/view.h at line 12 [15.13254]

∅:D[12.25] → [15.13585:13586]

B:BD[15.13585] → [15.13585:13586]

B:BD[15.13586] → [16.6:173]

∅:D[16.173] → [17.189:209]

B:BD[17.189] → [17.189:209]

B:BD[17.209] → [18.6:2026]

∅:D[18.2026] → [17.2011:2014]

B:BD[17.2011] → [17.2011:2014]


// various elemental colour schemes... used for abstracting random
// short lists. When adding colours, please also add their names in
// initfile.cc (str_to_colour)!
enum element_type
{
    ETC_FIRE = 32,      // fiery colours (must be first and > highest colour)
    ETC_ICE,            // icy colours
    ETC_EARTH,          // earthy colours
    ETC_ELECTRICITY,    // electrical side of air
    ETC_AIR,            // non-electric and general air magic
    ETC_POISON,         // used only for venom mage and stalker stuff
    ETC_WATER,          // used only for the elemental
    ETC_MAGIC,          // general magical effect
    ETC_MUTAGENIC,      // transmute, poly, radiation effects
    ETC_WARP,           // teleportation and anything similar
    ETC_ENCHANT,        // magical enhancements
    ETC_HEAL,           // holy healing (not necromantic stuff)
    ETC_HOLY,           // general "good" god effects
    ETC_DARK,           // darkness
    ETC_DEATH,          // currently only assassin (and equal to ETC_NECRO)
    ETC_NECRO,          // necromancy stuff
    ETC_UNHOLY,         // demonology stuff
    ETC_VEHUMET,        // vehumet's oddball colours
    ETC_BEOGH,          // Beogh altar colours
    ETC_CRYSTAL,        // colours of crystal
    ETC_BLOOD,          // colours of blood
    ETC_SMOKE,          // colours of smoke
    ETC_SLIME,          // colours of slime
    ETC_JEWEL,          // colourful
    ETC_ELVEN,          // used for colouring elf fabric items
    ETC_DWARVEN,        // used for colouring dwarf fabric items
    ETC_ORCISH,         // used for colouring orc fabric items
    ETC_GILA,           // gila monster colours
    ETC_FLOOR,          // colour of the area's floor
    ETC_ROCK,           // colour of the area's rock
    ETC_STONE,          // colour of the area's stone
    ETC_MIST,           // colour of mist
    ETC_SHIMMER_BLUE,   // shimmering colours of blue.
    ETC_DECAY,          // colour of decay/swamp
    ETC_SILVER,         // colour of silver
    ETC_GOLD,           // colour of gold
    ETC_IRON,           // colour of iron
    ETC_BONE,           // colour of bone
    ETC_RANDOM          // any colour (except BLACK)
};

Insertion in crawl-ref/source/view.cc at line 28 [15.16817]
[19.517]
[20.6]
```
#include "colour.h"
```
Insertion in crawl-ref/source/view.cc at line 55 [15.16817]
[15.18183]
[21.7]
```
#include "random.h"
```
Insertion in crawl-ref/source/tutorial.cc at line 21 [24.5936]
[22.831]
[23.1359]
```
#include "colour.h"
#include "coordit.h"
```
Insertion in crawl-ref/source/tutorial.cc at line 45 [24.5936]
[23.1539]
[23.1539]
```
#include "random.h"
```
Insertion in crawl-ref/source/travel.cc at line 12 [19.39949]
[25.646]
[19.40180]
```
#include "coord.h"
#include "coordit.h"
```
Insertion in crawl-ref/source/traps.cc at line 17 [17.5308]
[26.866]
[27.137]
```
#include "coord.h"
```
Insertion in crawl-ref/source/transfor.cc at line 25 [15.143977]
[15.144514]
[15.144514]
```
#include "random.h"
```
Insertion in crawl-ref/source/tilesdl.cc at line 7 [28.19415]
[28.19433]
[28.19433]
```
#include "coord.h"
```
Insertion in crawl-ref/source/tilereg.cc at line 13 [28.54399]
[28.54659]
[28.54659]
```
#include "coord.h"
```
Insertion in crawl-ref/source/tilepick.cc at line 12 [31.96318]
[29.158]
[30.412]
```
#include "colour.h"
#include "coord.h"
#include "coordit.h"
```
Insertion in crawl-ref/source/terrain.cc at line 30 [17.26938]
[17.27553]
[17.27575]
```
#include "random.h"
```
Deletion in crawl-ref/source/stuff.h at line 19 [15.217090]
∅:D[32.873] → [19.132884:132885]
B:BD[15.217606] → [19.132884:132885]
B:BD[19.132885] → [32.874:891]
∅:D[32.891] → [19.132907:132933]
B:BD[19.132907] → [19.132907:132933]
B:BD[19.132934] → [19.132934:132957]
B:BD[15.217607] → [19.132958:132980]
```
void seed_rng();
void seed_rng(long seed);
void push_rng_state();
void pop_rng_state();
```
Deletion in crawl-ref/source/stuff.h at line 20 [15.217090]
B:BD[19.132981] → [32.892:928]
∅:D[32.928] → [33.103182:103222]
B:BD[15.218031] → [33.103182:103222]
B:BD[33.103222] → [34.147:185]
∅:D[34.185] → [15.218206:218241]
∅:D[33.103222] → [15.218206:218241]
B:BD[15.218206] → [15.218206:218241]
B:BD[15.218241] → [35.613:647]
B:BD[35.647] → [36.253:321]
∅:D[36.321] → [33.103223:103260]
∅:D[37.491] → [33.103223:103260]
B:BD[15.218442] → [33.103223:103260]
B:BD[33.103260] → [38.1390:1439]
B:BD[38.1439] → [39.6692:6750]
∅:D[38.1439] → [40.134:169]
∅:D[39.6750] → [40.134:169]
B:BD[33.103260] → [40.134:169]
B:BD[40.169] → [41.134:190]
∅:D[40.169] → [32.929:957]
∅:D[41.190] → [32.929:957]
∅:D[42.201] → [32.929:957]
B:BD[33.103260] → [32.929:957]
B:BD[32.957] → [36.322:358]
∅:D[36.358] → [33.103261:103295]
B:BD[15.218655] → [33.103261:103295]
∅:D[33.103295] → [15.218655:218656]
B:BD[15.218655] → [15.218655:218656]
B:BD[15.218656] → [36.359:446]
B:BD[36.446] → [43.312:377]
∅:D[43.377] → [44.316:317]
∅:D[36.446] → [44.316:317]
B:BD[33.103351] → [44.316:317]
B:BD[44.318] → [44.318:358]
∅:D[44.358] → [45.585:586]
B:BD[33.103351] → [45.585:586]
```
void cf_setseed();
bool coinflip();
int div_rand_round( int num, int den );
int div_round_up( int num, int den );
bool one_chance_in(int a_million);
bool x_chance_in_y(int x, int y);
int random2(int max);
int maybe_random2(int x, bool random_factor);
int random_range(int low, int high);
int random_range(int low, int high, int nrolls);
const char* random_choose_string(const char* first, ...);
int random_choose(int first, ...);
int random_choose_weighted(int weight, int first, ...);
unsigned long random_int();
int random2avg(int max, int rolls);
int bestroll(int max, int rolls);
int roll_dice(int num, int size);
void scale_dice(dice_def &dice, int threshold = 24);
int binomial_generator(unsigned n_trials, unsigned trial_prob);
// Various ways to iterate over things.
```

Deletion in crawl-ref/source/stuff.h at line 40 [15.217090]

B:BD[46.761] → [44.359:762]

B:BD[44.762] → [47.3216:3258]

∅:D[47.3258] → [44.808:862]

B:BD[44.808] → [44.808:862]

};
class rectangle_iterator :
    public std::iterator<std::forward_iterator_tag, coord_def>
{
public:
    rectangle_iterator( const coord_def& corner1, const coord_def& corner2 );
    explicit rectangle_iterator( int x_border_dist, int y_border_dist = -1 );
    operator bool() const;
    coord_def operator *() const;
    const coord_def* operator->() const;
    rectangle_iterator& operator ++ ();
    rectangle_iterator operator ++ (int);
private:
    coord_def current, topleft, bottomright;

Deletion in crawl-ref/source/stuff.h at line 42 [15.217090]

∅:D[46.765] → [45.586:864]

B:BD[45.586] → [45.586:864]

B:BD[45.864] → [48.253:363]

∅:D[48.363] → [45.916:939]

B:BD[45.916] → [45.916:939]

B:BD[45.939] → [3.147:165]

∅:D[3.165] → [45.939:1019]

B:BD[45.939] → [45.939:1019]

B:BD[45.1019] → [49.182:223]

∅:D[49.223] → [45.1019:1266]

B:BD[45.1019] → [45.1019:1266]

∅:D[45.1266] → [15.218738:218739]

∅:D[33.103351] → [15.218738:218739]

B:BD[15.218738] → [15.218738:218739]

B:BD[15.218739] → [45.1267:1371]

B:BD[45.1371] → [48.364:398]

∅:D[48.398] → [45.1371:1394]

B:BD[45.1371] → [45.1371:1394]

∅:D[45.1394] → [15.218739:218740]

B:BD[15.218739] → [15.218739:218740]

B:BD[15.218740] → [44.863:922]

B:BD[44.922] → [50.331:461]

∅:D[50.461] → [44.1034:1103]

B:BD[44.1034] → [44.1034:1103]

∅:D[44.1103] → [15.218961:218999]

B:BD[15.218961] → [15.218961:218999]

class radius_iterator : public std::iterator<std::bidirectional_iterator_tag,
                        coord_def>
{
public:
    radius_iterator( const coord_def& center, int radius,
                     bool roguelike_metric = true,
                     bool require_los = true,
                     bool exclude_center = false,
                     const env_show_grid* losgrid = NULL );
    bool done() const;
    void reset();
    operator bool() const { return !done(); }
    coord_def operator *() const;
    const coord_def* operator->() const;
    const radius_iterator& operator ++ ();
    const radius_iterator& operator -- ();
    radius_iterator operator ++ (int);
    radius_iterator operator -- (int);
private:
    void step();
    void step_back();
    bool on_valid_square() const;
    coord_def location, center;
    int radius;
    bool roguelike_metric, require_los, exclude_center;
    const env_show_grid* losgrid;
    bool iter_done;
};
class adjacent_iterator : public radius_iterator
{
public:
    explicit adjacent_iterator( const coord_def& pos = you.pos(),
                                bool _exclude_center = true ) :
        radius_iterator(pos, 1, true, false, _exclude_center) {}
};
int random2limit(int max, int limit);

Deletion in crawl-ref/source/stuff.h at line 48 [15.217090]
B:BD[32.982] → [51.134:205]
```
int fuzz_value(int val, int lowfuzz, int highfuzz, int naverage = 2);
```
Deletion in crawl-ref/source/stuff.h at line 72 [15.217090]
B:BD[15.221773] → [52.253:303]
∅:D[52.303] → [53.297:327]
B:BD[15.221773] → [53.297:327]
B:BD[53.327] → [52.304:356]
∅:D[52.356] → [53.327:358]
B:BD[53.327] → [53.327:358]
∅:D[53.358] → [54.1305:1335]
B:BD[33.103699] → [54.1305:1335]
∅:D[54.1335] → [55.2907:2986]
B:BD[33.103699] → [55.2907:2986]
∅:D[55.2986] → [33.103699:103700]
B:BD[33.103699] → [33.103699:103700]
B:BD[33.103700] → [55.2987:3068]
B:BD[55.3068] → [56.306:522]
∅:D[56.522] → [57.289:352]
B:BD[55.3068] → [57.289:352]
∅:D[57.352] → [15.222008:222059]
∅:D[55.3068] → [15.222008:222059]
∅:D[33.103700] → [15.222008:222059]
B:BD[15.222008] → [15.222008:222059]
B:BD[15.222059] → [58.353:411]
∅:D[58.411] → [15.222059:222104]
B:BD[15.222059] → [15.222059:222104]
B:BD[15.222104] → [59.8139:8198]
∅:D[59.8198] → [15.222151:222152]
B:BD[15.222151] → [15.222151:222152]
```
bool in_bounds_x(int x);
bool in_bounds_y(int y);
bool in_bounds(int x, int y);
bool map_bounds_x(int x);
bool map_bounds_y(int y);
bool map_bounds(int x, int y);
coord_def random_in_bounds();
inline bool in_bounds(const coord_def &p)
{
    return in_bounds(p.x, p.y);
}
inline bool map_bounds(const coord_def &p)
{
    return map_bounds(p.x, p.y);
}
// Determines if the coordinate is within bounds of an LOS array.
inline bool show_bounds(const coord_def &p)
{
    return (p.x >= 0 && p.x < ENV_SHOW_DIAMETER
            && p.y >= 0 && p.y < ENV_SHOW_DIAMETER);
}
int grid_distance( const coord_def& p1, const coord_def& p2 );
int grid_distance( int x, int y, int x2, int y2 );
int distance( const coord_def& p1, const coord_def& p2 );
int distance( int x, int y, int x2, int y2);
bool adjacent( const coord_def& p1, const coord_def& p2 );
```
Deletion in crawl-ref/source/stuff.h at line 76 [15.217090]
B:BD[15.222813] → [32.1006:1037]
∅:D[32.1037] → [60.19:59]
B:BD[15.223160] → [60.19:59]
B:BD[60.59] → [61.834:941]
∅:D[60.59] → [33.103701:103796]
∅:D[61.941] → [33.103701:103796]
B:BD[15.223160] → [33.103701:103796]
∅:D[33.103796] → [15.223161:223162]
B:BD[15.223161] → [15.223161:223162]
```
unsigned char random_colour();
unsigned char random_uncommon_colour();
unsigned char make_low_colour(unsigned char colour);
unsigned char make_high_colour(unsigned char colour);
bool is_element_colour( int col );
int  element_colour( int element, bool no_random = false );
```
Deletion in crawl-ref/source/stuff.h at line 95 [15.217090]
B:BD[33.103858] → [33.103858:103859]
B:BD[33.103859] → [62.134:169]
B:BD[62.169] → [63.952:1135]
∅:D[63.1135] → [62.264:268]
B:BD[62.264] → [62.264:268]
B:BD[62.268] → [64.420:511]
B:BD[64.511] → [65.334:357]
B:BD[65.357] → [66.252:253]
B:BD[66.253] → [6.272:285]
∅:D[6.285] → [66.263:293]
B:BD[66.263] → [66.263:293]
∅:D[66.293] → [65.357:358]
B:BD[65.357] → [65.357:358]
∅:D[65.358] → [64.511:536]
B:BD[64.511] → [64.511:536]
B:BD[64.536] → [66.294:325]
B:BD[66.325] → [67.329:352]
∅:D[67.352] → [64.592:627]
B:BD[64.592] → [64.592:627]
B:BD[64.627] → [67.353:394]
∅:D[67.394] → [65.406:416]
B:BD[64.670] → [65.406:416]
∅:D[65.416] → [64.670:698]
B:BD[64.670] → [64.670:698]
B:BD[64.698] → [6.286:299]
∅:D[6.299] → [65.417:442]
∅:D[66.336] → [65.417:442]
B:BD[64.698] → [65.417:442]
B:BD[65.442] → [66.337:344]
∅:D[66.344] → [65.442:452]
B:BD[65.442] → [65.442:452]
∅:D[65.452] → [64.698:736]
B:BD[64.698] → [64.698:736]
B:BD[64.736] → [6.300:313]
∅:D[6.313] → [65.453:480]
∅:D[67.405] → [65.453:480]
B:BD[64.736] → [65.453:480]
B:BD[65.480] → [67.406:413]
∅:D[67.413] → [64.736:757]
∅:D[65.480] → [64.736:757]
B:BD[64.736] → [64.736:757]
```
class rng_save_excursion
{
public:
    rng_save_excursion(long seed) { push_rng_state(); seed_rng(seed); }
    rng_save_excursion()          { push_rng_state(); }
    ~rng_save_excursion()         { pop_rng_state(); }
};
template<typename Iterator>
int choose_random_weighted(Iterator beg, const Iterator end)
{
    ASSERT(beg < end);
#ifdef DEBUG
    int times_set = 0;
#endif
    int totalweight = 0;
    int count = 0, result = 0;
    while (beg != end)
    {
        totalweight += *beg;
        if (random2(totalweight) < *beg)
        {
            result = count;
#ifdef DEBUG
            times_set++;
#endif
        }
        ++count;
        ++beg;
    }
#ifdef DEBUG
    ASSERT(times_set > 0);
#endif
    return result;
}
```
Insertion in crawl-ref/source/stuff.cc at line 11 [15.224557]
[68.158]
[69.1426]
```
#include "coordit.h"
```

Deletion in crawl-ref/source/stuff.cc at line 35 [15.224557]

B:BD[19.133224] → [19.133224:133352]


#ifdef USE_MORE_SECURE_SEED
// for times()
#include <sys/times.h>
// for getpid()
#include <sys/types.h>
#include <unistd.h>

Deletion in crawl-ref/source/stuff.cc at line 36 [15.224557]
B:BD[70.257] → [70.257:264]
∅:D[70.264] → [19.133352:133353]
B:BD[19.133352] → [19.133352:133353]
B:BD[19.133353] → [70.265:311]
∅:D[70.311] → [19.133353:133360]
B:BD[19.133353] → [19.133353:133360]
∅:D[19.133361] → [15.225035:225036]
B:BD[15.225035] → [15.225035:225036]
```
#endif
#ifdef MORE_HARDENED_PRNG
#include "sha256.h"
#endif
```
Deletion in crawl-ref/source/stuff.cc at line 55 [15.224557]
B:BD[15.225366] → [19.133362:133385]
```
#include "mt19937ar.h"
```

Deletion in crawl-ref/source/stuff.cc at line 115 [15.224557]

B:BD[46.1706] → [44.1141:1610]

B:BD[44.1610] → [71.1048:1075]

∅:D[71.1075] → [44.1639:1678]

B:BD[44.1639] → [44.1639:1678]

B:BD[44.1678] → [71.1076:1077]

B:BD[71.1077] → [72.1316:1434]

∅:D[73.628] → [44.1792:1815]

∅:D[72.1434] → [44.1792:1815]

B:BD[44.1792] → [44.1792:1815]

}
rectangle_iterator::rectangle_iterator( const coord_def& corner1,
                                        const coord_def& corner2 )
{
    topleft.x = std::min(corner1.x, corner2.x);
    topleft.y = std::min(corner1.y, corner2.y); // not really necessary
    bottomright.x = std::max(corner1.x, corner2.x);
    bottomright.y = std::max(corner1.y, corner2.y);
    current = topleft;
}
rectangle_iterator::rectangle_iterator( int x_border_dist, int y_border_dist )
{
    if (y_border_dist < 0)
        y_border_dist = x_border_dist;
    topleft.set(x_border_dist, y_border_dist);
    bottomright.set(GXM - x_border_dist - 1, GYM - y_border_dist - 1);
    current = topleft;

Deletion in crawl-ref/source/stuff.cc at line 117 [15.224557]

B:BD[44.1818] → [44.1818:1862]

B:BD[44.1862] → [74.558:599]

∅:D[75.205] → [44.1900:2115]

∅:D[74.599] → [44.1900:2115]

B:BD[44.1900] → [44.1900:2115]

B:BD[44.2115] → [74.600:636]

∅:D[74.636] → [44.2153:2277]

B:BD[44.2153] → [44.2153:2277]

∅:D[44.2277] → [46.1706:1709]

B:BD[46.1706] → [46.1706:1709]

B:BD[46.1709] → [44.2278:2423]

B:BD[44.2423] → [48.400:667]

∅:D[48.667] → [45.1604:1747]

B:BD[45.1604] → [45.1604:1747]

B:BD[45.1747] → [48.668:710]

∅:D[48.710] → [45.1770:1772]

B:BD[45.1770] → [45.1770:1772]

B:BD[45.1772] → [3.167:239]

∅:D[3.239] → [45.1772:1844]

B:BD[45.1772] → [45.1772:1844]

B:BD[45.1844] → [76.2694:2695]

∅:D[76.2695] → [45.1849:2041]

B:BD[45.1849] → [45.1849:2041]

B:BD[45.2041] → [49.340:420]

∅:D[49.420] → [45.2041:2302]

B:BD[45.2041] → [45.2041:2302]

B:BD[45.2302] → [77.1231:1258]

∅:D[77.1258] → [45.2331:2386]

B:BD[45.2331] → [45.2331:2386]

B:BD[45.2386] → [77.1259:1290]

∅:D[77.1290] → [45.2419:2702]

B:BD[45.2419] → [45.2419:2702]

B:BD[45.2702] → [72.1435:1462]

∅:D[72.1462] → [45.2731:2786]

B:BD[45.2731] → [45.2731:2786]

B:BD[45.2786] → [72.1463:1524]

∅:D[72.1524] → [45.2858:2915]

B:BD[45.2858] → [45.2858:2915]

B:BD[45.2915] → [78.148:178]

B:BD[78.178] → [79.4160:4184]

∅:D[79.4184] → [78.179:251]

B:BD[45.2969] → [78.179:251]

B:BD[78.251] → [79.4185:4209]

B:BD[79.4209] → [48.711:738]

B:BD[48.738] → [80.2284:2329]

∅:D[80.2329] → [48.783:811]

B:BD[48.783] → [48.783:811]

B:BD[48.811] → [80.2330:2392]

∅:D[80.2392] → [48.873:907]

B:BD[48.873] → [48.873:907]

∅:D[48.907] → [78.297:343]

∅:D[79.4234] → [78.297:343]

B:BD[45.3133] → [78.297:343]

B:BD[78.343] → [79.4235:4279]

∅:D[79.4279] → [45.3220:3278]

B:BD[45.3220] → [45.3220:3278]

B:BD[45.3278] → [81.440:447]

∅:D[81.453] → [45.3287:3309]

B:BD[45.3287] → [45.3287:3309]

B:BD[81.460] → [79.4280:4335]

∅:D[79.4335] → [81.517:518]

B:BD[81.517] → [81.517:518]

B:BD[81.518] → [79.4336:4356]

∅:D[79.4356] → [45.3386:3388]

B:BD[45.3386] → [45.3386:3388]

∅:D[45.3388] → [15.225500:225501]

B:BD[15.225500] → [15.225500:225501]

B:BD[15.225501] → [45.3389:3444]

B:BD[45.3444] → [81.519:526]

∅:D[81.532] → [45.3453:3480]

B:BD[45.3453] → [45.3453:3480]

B:BD[81.539] → [79.4357:4412]

∅:D[79.4412] → [81.596:597]

B:BD[81.596] → [81.596:597]

B:BD[81.597] → [79.4413:4433]

∅:D[79.4433] → [45.3557:3672]

B:BD[45.3557] → [45.3557:3672]

B:BD[45.3672] → [79.4434:4453]

∅:D[79.4453] → [45.3689:3804]

B:BD[45.3689] → [45.3689:3804]

B:BD[45.3804] → [79.4454:4473]

∅:D[79.4473] → [45.3821:3824]

B:BD[45.3821] → [45.3821:3824]

rectangle_iterator::operator bool() const
{
    return (current.y <= bottomright.y);
}
coord_def rectangle_iterator::operator *() const
{
    return current;
}
const coord_def* rectangle_iterator::operator->() const
{
    return &current;
}
rectangle_iterator& rectangle_iterator::operator ++()
{
    if (current.x == bottomright.x)
    {
        current.x = topleft.x;
        current.y++;
    }
    else
    {
        current.x++;
    }
    return *this;
}
rectangle_iterator rectangle_iterator::operator++( int dummy )
{
    const rectangle_iterator copy = *this;
    ++(*this);
    return (copy);
}
radius_iterator::radius_iterator(const coord_def& _center, int _radius,
                                 bool _roguelike_metric, bool _require_los,
                                 bool _exclude_center,
                                 const env_show_grid* _losgrid)
    : center(_center), radius(_radius), roguelike_metric(_roguelike_metric),
      require_los(_require_los), exclude_center(_exclude_center),
      losgrid(_losgrid), iter_done(false)
{
    reset();
}
void radius_iterator::reset()
{
    iter_done = false;
    location.x = center.x - radius;
    location.y = center.y - radius;
    if ( !this->on_valid_square() )
        ++(*this);
}
bool radius_iterator::done() const
{
    return iter_done;
}
coord_def radius_iterator::operator *() const
{
    return location;
}
const coord_def* radius_iterator::operator->() const
{
    return &location;
}
void radius_iterator::step()
{
    const int minx = std::max(X_BOUND_1+1, center.x - radius);
    const int maxx = std::min(X_BOUND_2-1, center.x + radius);
    const int maxy = std::min(Y_BOUND_2-1, center.y + radius);
    // Sweep L-R, U-D
    location.x++;
    if (location.x > maxx)
    {
        location.x = minx;
        location.y++;
        if (location.y > maxy)
            iter_done = true;
    }
}
void radius_iterator::step_back()
{
    const int minx = std::max(X_BOUND_1+1, center.x - radius);
    const int maxx = std::min(X_BOUND_2-1, center.x + radius);
    const int miny = std::max(Y_BOUND_1+1, center.y - radius);
    location.x--;
    if (location.x < minx)
    {
        location.x = maxx;
        location.y--;
        if (location.y < miny)
            iter_done = true;
    }
}
bool radius_iterator::on_valid_square() const
{
    if (!in_bounds(location))
        return (false);
    if (!roguelike_metric && (location - center).abs() > radius*radius)
        return (false);
    if (require_los)
    {
        if (!losgrid && !see_cell(location))
            return (false);
        if (losgrid && !see_cell(*losgrid, center, location))
            return (false);
    }
    if (exclude_center && location == center)
        return (false);
    return (true);
}
const radius_iterator& radius_iterator::operator++()
{
    do
        this->step();
    while (!this->done() && !this->on_valid_square());
    return (*this);
}
const radius_iterator& radius_iterator::operator--()
{
    do
        this->step_back();
    while (!this->done() && !this->on_valid_square());
    return (*this);
}
radius_iterator radius_iterator::operator++(int dummy)
{
    const radius_iterator copy = *this;
    ++(*this);
    return (copy);
}
radius_iterator radius_iterator::operator--(int dummy)
{
    const radius_iterator copy = *this;
    --(*this);
    return (copy);
}

Deletion in crawl-ref/source/stuff.cc at line 280 [15.224557]
B:BD[15.228566] → [4.297:299]
∅:D[4.299] → [19.133691:133692]
B:BD[15.228614] → [19.133691:133692]
B:BD[19.133692] → [70.312:464]
```
}
void seed_rng(unsigned long* seed_key, size_t num_keys)
{
    // MT19937 -- see mt19937ar.cc for details/licence
    init_by_array(seed_key, num_keys);
```

Deletion in crawl-ref/source/stuff.cc at line 282 [15.224557]

∅:D[70.467] → [19.133692:133719]

B:BD[19.133692] → [19.133692:133719]

B:BD[19.133765] → [19.133765:133844]

B:BD[19.133851] → [19.133851:133939]

B:BD[19.133939] → [70.468:540]

∅:D[70.540] → [19.133939:133998]

B:BD[19.133939] → [19.133939:133998]

B:BD[19.133998] → [70.541:988]

∅:D[70.988] → [19.134005:134006]

B:BD[19.134005] → [19.134005:134006]

B:BD[19.134006] → [70.989:1023]

∅:D[70.1023] → [19.134006:134026]

B:BD[19.134006] → [19.134006:134026]

B:BD[19.134026] → [70.1024:1031]

∅:D[70.1031] → [19.134101:134103]

B:BD[15.229188] → [19.134101:134103]

B:BD[19.134266] → [19.134266:134267]

B:BD[19.137417] → [19.137417:137495]

B:BD[19.137495] → [70.1032:1059]

∅:D[70.1059] → [19.137495:137525]

B:BD[19.137495] → [19.137495:137525]

B:BD[19.137525] → [70.1060:1104]

∅:D[70.1104] → [33.104166:104276]

B:BD[19.137525] → [33.104166:104276]

∅:D[33.104276] → [19.137525:137527]

B:BD[19.137525] → [19.137525:137527]

B:BD[19.137527] → [40.191:192]

B:BD[40.192] → [38.1670:1868]

B:BD[38.1868] → [82.141:243]

∅:D[82.243] → [40.192:322]

∅:D[38.1868] → [40.192:322]

B:BD[40.192] → [40.192:322]

∅:D[40.322] → [19.137527:137528]

B:BD[19.137527] → [19.137527:137528]

B:BD[19.137528] → [40.323:533]

B:BD[40.533] → [76.2696:2697]

∅:D[76.2697] → [40.538:580]

B:BD[40.538] → [40.538:580]

B:BD[40.580] → [39.6752:7236]

B:BD[39.7236] → [76.2698:2699]

∅:D[76.2699] → [39.7241:7283]

B:BD[39.7241] → [39.7241:7283]

∅:D[39.7283] → [41.192:626]

B:BD[40.580] → [41.192:626]

B:BD[41.626] → [76.2700:2701]

∅:D[76.2701] → [41.631:670]

B:BD[41.631] → [41.631:670]

B:BD[42.518] → [42.518:520]

∅:D[42.520] → [41.673:674]

B:BD[41.673] → [41.673:674]

B:BD[41.674] → [36.448:469]

∅:D[36.469] → [19.137551:137592]

B:BD[19.137551] → [19.137551:137592]

B:BD[19.137592] → [70.1105:1221]

∅:D[70.1221] → [36.470:545]

B:BD[19.137592] → [36.470:545]

B:BD[36.545] → [70.1222:1233]

∅:D[36.545] → [19.137669:137672]

∅:D[70.1233] → [19.137669:137672]

B:BD[19.137669] → [19.137669:137672]

B:BD[19.137672] → [36.546:566]

∅:D[36.566] → [19.137694:137696]

B:BD[19.137694] → [19.137694:137696]

B:BD[19.137696] → [36.567:611]

∅:D[36.611] → [37.493:564]

B:BD[19.137742] → [37.493:564]

B:BD[37.564] → [36.612:657]

∅:D[36.657] → [37.611:636]

B:BD[37.611] → [37.611:636]

B:BD[37.636] → [36.658:687]

∅:D[36.687] → [37.663:672]

B:BD[37.663] → [37.663:672]

B:BD[37.672] → [36.688:712]

∅:D[37.694] → [19.137742:137745]

∅:D[36.712] → [19.137742:137745]

B:BD[19.137742] → [19.137742:137745]

∅:D[37.696] → [19.137745:137836]

B:BD[19.137745] → [19.137745:137836]

∅:D[19.137836] → [15.229188:229190]

B:BD[15.229188] → [15.229188:229190]

B:BD[15.229190] → [19.137837:137838]

B:BD[19.137838] → [36.713:868]

∅:D[36.868] → [33.104435:104652]

B:BD[33.104435] → [33.104435:104652]

∅:D[33.104652] → [15.229190:229191]

∅:D[19.137865] → [15.229190:229191]

B:BD[15.229190] → [15.229190:229191]

B:BD[15.229191] → [33.104653:104706]

B:BD[33.104706] → [36.869:870]

∅:D[36.870] → [33.104706:104837]

B:BD[33.104706] → [33.104706:104837]

B:BD[33.104837] → [36.871:872]

∅:D[36.872] → [33.104837:104859]

B:BD[33.104837] → [33.104837:104859]

B:BD[33.104859] → [36.873:952]

∅:D[36.952] → [15.229271:229389]

B:BD[15.229271] → [15.229271:229389]

B:BD[15.229389] → [36.953:981]

∅:D[36.981] → [15.229406:229407]

B:BD[15.229406] → [15.229406:229407]

B:BD[15.229433] → [15.229433:229475]

B:BD[15.229481] → [15.229481:229514]

B:BD[15.229520] → [15.229520:229550]

B:BD[15.229550] → [36.982:1015]

∅:D[36.1015] → [15.229585:229616]

B:BD[15.229585] → [15.229585:229616]

B:BD[15.229616] → [76.2702:2835]

∅:D[76.2835] → [15.229751:229944]

B:BD[15.229751] → [15.229751:229944]

B:BD[15.229944] → [36.1016:1050]

∅:D[36.1050] → [15.229980:230005]

B:BD[15.229980] → [15.229980:230005]

B:BD[15.230102] → [15.230102:230105]

B:BD[15.230105] → [83.1484:1530]

∅:D[83.1530] → [15.230151:230334]

B:BD[15.230151] → [15.230151:230334]

B:BD[15.230334] → [36.1051:1071]

∅:D[36.1071] → [15.230352:230383]

B:BD[15.230352] → [15.230352:230383]

B:BD[15.230389] → [15.230389:230441]

B:BD[15.230447] → [15.230447:230448]

B:BD[15.230448] → [36.1072:1092]

∅:D[36.1092] → [15.230518:230519]

B:BD[15.230518] → [15.230518:230519]

B:BD[15.230519] → [43.379:921]

void seed_rng(long seed)
{
    // MT19937 -- see mt19937ar.cc for details/licence
    init_genrand(seed);
}
void seed_rng()
{
    unsigned long seed = time( NULL );
#ifdef USE_MORE_SECURE_SEED
    /* (at least) 256-bit wide seed */
    unsigned long seed_key[8];
    struct tms  buf;
    seed += times( &buf ) + getpid();
    seed_key[0] = seed;
    /* Try opening from various system provided (hopefully) CSPRNGs */
    FILE* seed_f = fopen("/dev/urandom", "rb");
    if (!seed_f)
        seed_f = fopen("/dev/random", "rb");
    if (!seed_f)
        seed_f = fopen("/dev/srandom", "rb");
    if (!seed_f)
        seed_f = fopen("/dev/arandom", "rb");
    if (seed_f)
    {
        fread(&seed_key[1], sizeof(unsigned long), 7, seed_f);
        fclose(seed_f);
    }
    seed_rng(seed_key, 8);
#else
    seed_rng(seed);
#endif
}
// MT19937 -- see mt19937ar.cc for details
unsigned long random_int( void )
{
#ifndef MORE_HARDENED_PRNG
    return (genrand_int32());
#else
    return (sha256_genrand());
#endif
}
int random_range(int low, int high)
{
    ASSERT(low <= high);
    return (low + random2(high - low + 1));
}
int random_range(int low, int high, int nrolls)
{
    ASSERT(nrolls > 0);
    int sum = 0;
    for (int i = 0; i < nrolls; ++i)
        sum += random_range(low, high);
    return (sum / nrolls);
}
// Chooses one of the numbers passed in at random. The list of numbers
// must be terminated with -1.
int random_choose(int first, ...)
{
    va_list args;
    va_start(args, first);
    int chosen = first, count = 1, nargs = 100;
    while (nargs-- > 0)
    {
        const int pick = va_arg(args, int);
        if (pick == -1)
            break;
        if (one_chance_in(++count))
            chosen = pick;
    }
    ASSERT(nargs > 0);
    va_end(args);
    return (chosen);
}
// Chooses one of the strings passed in at random. The list of strings
// must be terminated with NULL.
const char* random_choose_string(const char* first, ...)
{
    va_list args;
    va_start(args, first);
    const char* chosen = first;
    int count = 1, nargs = 100;
    while (nargs-- > 0)
    {
        char* pick = va_arg(args, char*);
        if (pick == NULL)
            break;
        if (one_chance_in(++count))
            chosen = pick;
    }
    ASSERT(nargs > 0);
    va_end(args);
    return (chosen);
}
int random_choose_weighted(int weight, int first, ...)
{
    va_list args;
    va_start(args, first);
    int chosen = first, cweight = weight, nargs = 100;
    while (nargs-- > 0)
    {
        const int nweight = va_arg(args, int);
        if (!nweight)
            break;
        const int choice = va_arg(args, int);
        if (random2(cweight += nweight) < nweight)
            chosen = choice;
    }
    ASSERT(nargs > 0);
    va_end(args);
    return (chosen);
}
int random2(int max)
{
    if (max <= 1)
        return (0);
    #ifdef MORE_HARDENED_PRNG
    return (static_cast<int>(sha256_genrand() / (0xFFFFFFFFUL / max + 1)));
    #else
    return (static_cast<int>(genrand_int32() / (0xFFFFFFFFUL / max + 1)));
    #endif
}
bool coinflip(void)
{
    return (static_cast<bool>(random2(2)));
}
// Returns random2(x) if random_factor is true, otherwise the mean.
int maybe_random2(int x, bool random_factor)
{
    if (random_factor)
        return (random2(x));
    else
        return (x / 2);
}
void push_rng_state()
{
    push_mt_state();
}
void pop_rng_state()
{
    pop_mt_state();
}
// Attempts to make missile weapons nicer to the player by reducing the
// extreme variance in damage done.
void scale_dice(dice_def &dice, int threshold)
{
    while (dice.size > threshold)
    {
        dice.num *= 2;
        // If it's an odd number, lose one; this is more than
        // compensated by the increase in number of dice.
        dice.size /= 2;
    }
}
int bestroll(int max, int rolls)
{
    int best = 0;
    for (int i = 0; i < rolls; i++)
    {
        int curr = random2(max);
        if (curr > best)
            best = curr;
    }
    return (best);
}
// random2avg() returns same mean value as random2() but with a lower variance
// never use with rolls < 2 as that would be silly - use random2() instead {dlb}
int random2avg(int max, int rolls)
{
    int sum = random2(max);
    for (int i = 0; i < (rolls - 1); i++)
        sum += random2(max + 1);
    return (sum / rolls);
}
int roll_dice(int num, int size)
{
    int ret = 0;
    int i;
    // If num <= 0 or size <= 0, then we'll just return the default
    // value of zero.  This is good behaviour in that it will be
    // appropriate for calculated values that might be passed in.
    if (num > 0 && size > 0)
    {
        ret += num;     // since random2() is zero based
        for (i = 0; i < num; i++)
            ret += random2(size);
    }
    return (ret);
}
// originally designed to randomise evasion -
// values are slightly lowered near (max) and
// approach an upper limit somewhere near (limit/2)
int random2limit(int max, int limit)
{
    int i;
    int sum = 0;
    if (max < 1)
        return (0);
    for (i = 0; i < max; i++)
        if (random2(limit) >= i)
            sum++;
    return (sum);
}
// Generate samples from a binomial distribution with n_trials and trial_prob
// probability of success per trial. trial_prob is a integer less than 100
// representing the % chancee of success.
// This just evaluates all n trials, there is probably an efficient way of
// doing this but I'm not much of a statistician. -CAO
int binomial_generator(unsigned n_trials, unsigned trial_prob)
{
    int count = 0;
    for (unsigned i = 0; i < n_trials; ++i)
        if (::x_chance_in_y(trial_prob, 100))
            count++;
    return count;
}

Deletion in crawl-ref/source/stuff.cc at line 507 [15.224557]
B:BD[33.105705] → [33.105705:105707]
∅:D[33.105707] → [15.233848:233849]
B:BD[15.233848] → [15.233848:233849]
B:BD[15.233849] → [33.105708:105776]
B:BD[33.105776] → [36.1093:1130]
∅:D[36.1130] → [33.105815:105870]
B:BD[33.105815] → [33.105815:105870]
```
}
// Calculates num/den and randomly adds one based on the remainder.
int div_rand_round(int num, int den)
{
    return (num / den + (random2(den) < num % den));
```
Deletion in crawl-ref/source/stuff.cc at line 512 [15.224557]
B:BD[34.269] → [34.269:272]
∅:D[34.272] → [15.234355:234429]
B:BD[15.234355] → [15.234355:234429]
B:BD[15.234429] → [35.649:687]
B:BD[35.687] → [84.155:171]
∅:D[84.171] → [35.713:807]
B:BD[35.713] → [35.713:807]
```
}
bool one_chance_in(int a_million)
{
    return (random2(a_million) == 0);
}
bool x_chance_in_y(int x, int y)
{
    if (x <= 0)
        return (false);
    if (x >= y)
        return (true);
    return (random2(y) < x);
```

Deletion in crawl-ref/source/stuff.cc at line 788 [15.224557]

B:BD[33.106958] → [57.354:471]

∅:D[57.471] → [33.106958:107033]

B:BD[33.106958] → [33.106958:107033]

∅:D[33.107033] → [15.239944:240145]

B:BD[15.239944] → [15.239944:240145]

B:BD[15.240145] → [58.413:520]

∅:D[58.520] → [15.240145:240192]

B:BD[15.240145] → [15.240145:240192]

B:BD[15.240192] → [33.107034:107114]

∅:D[33.107114] → [15.240273:240430]

B:BD[15.240273] → [15.240273:240430]

B:BD[15.240430] → [5.254:256]

∅:D[5.256] → [15.240480:240481]

B:BD[15.240480] → [15.240480:240481]

B:BD[15.240481] → [59.8200:8258]

∅:D[59.8258] → [15.240527:240529]

B:BD[15.240527] → [15.240527:240529]

B:BD[15.240529] → [59.8259:8298]

∅:D[59.8298] → [15.240580:240583]

B:BD[15.240580] → [15.240580:240583]

int grid_distance( const coord_def& p1, const coord_def& p2 )
{
    return grid_distance(p1.x, p1.y, p2.x, p2.y);
}
// More accurate than distance() given the actual movement geometry -- bwr
int grid_distance( int x, int y, int x2, int y2 )
{
    const int dx = abs( x - x2 );
    const int dy = abs( y - y2 );
    // returns distance in terms of moves:
    return ((dx > dy) ? dx : dy);
}
int distance( const coord_def& p1, const coord_def& p2 )
{
    return distance(p1.x, p1.y, p2.x, p2.y);
}
int distance( int x, int y, int x2, int y2 )
{
    //jmf: now accurate, but remember to only compare vs. pre-squared distances
    //     thus, next to == (distance(m1.x,m1.y, m2.x,m2.y) <= 2)
    const int dx = x - x2;
    const int dy = y - y2;
    return ((dx * dx) + (dy * dy));
}
bool adjacent( const coord_def& p1, const coord_def& p2 )
{
    return grid_distance(p1, p2) <= 1;
}

Deletion in crawl-ref/source/stuff.cc at line 797 [15.224557]

∅:D[50.599] → [79.4688:4690]

∅:D[44.2639] → [79.4688:4690]

B:BD[15.241278] → [79.4688:4690]

∅:D[79.4690] → [33.107115:107116]

B:BD[15.241365] → [33.107115:107116]

B:BD[33.107116] → [52.358:506]

∅:D[52.506] → [78.344:423]

B:BD[33.107116] → [78.344:423]

B:BD[78.423] → [53.360:389]

∅:D[53.389] → [33.107225:107227]

B:BD[33.107225] → [33.107225:107227]

B:BD[33.107227] → [52.507:554]

∅:D[52.554] → [33.107319:107322]

B:BD[33.107319] → [33.107319:107322]

B:BD[33.107322] → [52.555:709]

∅:D[52.709] → [33.107322:107497]

B:BD[33.107322] → [33.107322:107497]

B:BD[33.107497] → [53.390:420]

∅:D[53.420] → [33.107529:107531]

B:BD[33.107529] → [33.107529:107531]

B:BD[33.107531] → [52.710:759]

∅:D[52.759] → [54.1337:1371]

B:BD[33.107626] → [54.1337:1371]

B:BD[54.1371] → [85.254:698]

B:BD[33.109323] → [33.109323:109326]

∅:D[33.110010] → [15.241366:241432]

B:BD[15.241366] → [15.241366:241432]

B:BD[15.241432] → [53.873:875]

∅:D[53.875] → [60.61:129]

B:BD[15.241487] → [60.61:129]

B:BD[60.129] → [86.254:255]

∅:D[86.255] → [24.71398:71405]

B:BD[60.129] → [24.71398:71405]

∅:D[24.71405] → [60.138:172]

B:BD[60.138] → [60.138:172]

B:BD[60.172] → [86.256:348]

B:BD[86.348] → [61.943:1146]

B:BD[61.1146] → [87.254:275]

∅:D[87.275] → [61.1182:1233]

B:BD[61.1182] → [61.1182:1233]

∅:D[86.348] → [60.265:267]

∅:D[61.1233] → [60.265:267]

B:BD[60.265] → [60.265:267]

∅:D[60.267] → [15.241487:241488]

B:BD[15.241487] → [15.241487:241488]

∅:D[60.269] → [33.110011:110125]

B:BD[15.241488] → [33.110011:110125]

B:BD[33.110125] → [18.3449:3535]

∅:D[18.3535] → [33.110209:110264]

B:BD[33.110209] → [33.110209:110264]

B:BD[33.110264] → [76.2934:3002]

∅:D[76.3002] → [33.110333:110406]

B:BD[33.110333] → [33.110333:110406]

B:BD[33.110406] → [18.3536:3566]

∅:D[18.3566] → [33.110435:110471]

B:BD[33.110435] → [33.110435:110471]

B:BD[33.110471] → [18.3567:3601]

∅:D[18.3601] → [33.110504:110748]

B:BD[33.110504] → [33.110504:110748]

B:BD[33.110748] → [76.3003:3072]

∅:D[76.3072] → [88.20:65]

B:BD[33.110818] → [88.20:65]

∅:D[88.65] → [33.110863:110984]

B:BD[33.110863] → [33.110863:110984]

B:BD[33.110984] → [18.3602:3621]

∅:D[18.3621] → [33.111002:111040]

B:BD[33.111002] → [33.111002:111040]

B:BD[33.111040] → [76.3073:3112]

∅:D[76.3112] → [33.111080:111138]

B:BD[33.111080] → [33.111080:111138]

B:BD[33.111138] → [18.3622:3640]

∅:D[18.3640] → [33.111155:111199]

B:BD[33.111155] → [33.111155:111199]

B:BD[33.111199] → [76.3113:3150]

∅:D[76.3150] → [33.111237:111292]

B:BD[33.111237] → [33.111237:111292]

B:BD[33.111292] → [18.3641:3661]

∅:D[18.3661] → [33.111311:111377]

B:BD[33.111311] → [33.111311:111377]

B:BD[33.111377] → [18.3662:3680]

∅:D[18.3680] → [33.111394:111461]

B:BD[33.111394] → [33.111394:111461]

B:BD[33.111461] → [18.3681:3707]

∅:D[18.3707] → [33.111486:111530]

B:BD[33.111486] → [33.111486:111530]

B:BD[33.111530] → [76.3151:3193]

∅:D[76.3193] → [33.111573:111627]

B:BD[33.111573] → [33.111573:111627]

B:BD[33.111627] → [18.3708:3729]

∅:D[18.3729] → [33.111647:111715]

B:BD[33.111647] → [33.111647:111715]

B:BD[33.111715] → [18.3730:3750]

∅:D[18.3750] → [33.111734:111795]

B:BD[33.111734] → [33.111734:111795]

B:BD[33.111795] → [18.3751:3771]

∅:D[18.3771] → [33.111814:111905]

B:BD[33.111814] → [33.111814:111905]

B:BD[33.111905] → [76.3194:3234]

∅:D[76.3234] → [33.111946:112000]

B:BD[33.111946] → [33.111946:112000]

B:BD[33.112000] → [18.3772:3815]

∅:D[18.3815] → [33.112041:112113]

B:BD[33.112041] → [33.112041:112113]

B:BD[33.112113] → [18.3816:3838]

∅:D[18.3838] → [33.112134:112200]

B:BD[33.112134] → [33.112134:112200]

B:BD[33.112200] → [18.3839:3858]

∅:D[18.3858] → [33.112218:112286]

B:BD[33.112218] → [33.112218:112286]

B:BD[33.112286] → [18.3859:3879]

∅:D[18.3879] → [33.112305:112369]

B:BD[33.112305] → [33.112305:112369]

B:BD[33.112369] → [18.3880:3957]

∅:D[18.3957] → [33.112444:112512]

B:BD[33.112444] → [33.112444:112512]

B:BD[33.112512] → [18.3958:4000]

∅:D[18.4000] → [33.112553:112617]

B:BD[33.112553] → [33.112553:112617]

B:BD[33.112617] → [18.4001:4020]

∅:D[18.4020] → [89.361:415]

B:BD[33.112635] → [89.361:415]

∅:D[89.415] → [33.112659:112675]

B:BD[33.112659] → [33.112659:112675]

B:BD[33.112675] → [18.4021:4040]

∅:D[18.4040] → [33.112693:112757]

B:BD[33.112693] → [33.112693:112757]

B:BD[33.112757] → [18.4041:4063]

∅:D[18.4063] → [33.112778:112821]

B:BD[33.112778] → [33.112778:112821]

B:BD[33.112821] → [76.3235:3280]

∅:D[76.3280] → [33.112867:112910]

B:BD[33.112867] → [33.112867:112910]

B:BD[33.112910] → [90.228:244]

B:BD[90.244] → [18.4064:4084]

∅:D[18.4084] → [91.253:388]

B:BD[90.263] → [91.253:388]

∅:D[92.294] → [33.112910:112926]

∅:D[90.313] → [33.112910:112926]

∅:D[91.388] → [33.112910:112926]

∅:D[93.437] → [33.112910:112926]

B:BD[33.112910] → [33.112910:112926]

B:BD[33.112926] → [18.4085:4107]

∅:D[18.4107] → [33.112947:112991]

B:BD[33.112947] → [33.112947:112991]

B:BD[33.112991] → [76.3281:3319]

∅:D[76.3319] → [33.113030:113088]

B:BD[33.113030] → [33.113030:113088]

B:BD[33.113088] → [18.4108:4128]

∅:D[18.4128] → [33.113107:113147]

B:BD[33.113107] → [33.113107:113147]

B:BD[33.113147] → [76.3320:3358]

∅:D[76.3358] → [33.113186:113246]

B:BD[33.113186] → [33.113186:113246]

B:BD[33.113246] → [18.4129:4149]

∅:D[18.4149] → [33.113265:113352]

B:BD[33.113265] → [33.113265:113352]

B:BD[33.113352] → [76.3359:3401]

∅:D[76.3401] → [33.113395:113452]

B:BD[33.113395] → [33.113395:113452]

B:BD[33.113452] → [18.4150:4170]

∅:D[18.4170] → [33.113471:113819]

B:BD[33.113471] → [33.113471:113819]

B:BD[33.113819] → [76.3402:3441]

∅:D[76.3441] → [33.113859:113914]

B:BD[33.113859] → [33.113859:113914]

B:BD[33.113914] → [18.4171:4191]

∅:D[18.4191] → [33.113933:114020]

B:BD[33.113933] → [33.113933:114020]

B:BD[33.114020] → [76.3442:3485]

∅:D[76.3485] → [33.114064:114119]

B:BD[33.114064] → [33.114064:114119]

B:BD[33.114119] → [18.4192:4214]

∅:D[18.4214] → [33.114140:114225]

B:BD[33.114140] → [33.114140:114225]

B:BD[33.114225] → [76.3486:3529]

∅:D[76.3529] → [33.114269:114324]

B:BD[33.114269] → [33.114269:114324]

B:BD[33.114324] → [18.4215:4236]

∅:D[18.4236] → [33.114344:114427]

B:BD[33.114344] → [33.114344:114427]

B:BD[33.114427] → [76.3530:3569]

∅:D[76.3569] → [33.114467:114525]

B:BD[33.114467] → [33.114467:114525]

B:BD[33.114525] → [18.4237:4256]

∅:D[18.4256] → [33.114543:114634]

B:BD[33.114543] → [33.114543:114634]

B:BD[33.114634] → [76.3570:3654]

∅:D[76.3654] → [33.114720:114774]

B:BD[33.114720] → [33.114720:114774]

B:BD[33.114774] → [18.4257:4277]

∅:D[18.4277] → [33.114793:114922]

B:BD[33.114793] → [33.114793:114922]

B:BD[33.114922] → [94.208:224]

B:BD[94.224] → [18.4278:4297]

∅:D[18.4297] → [94.242:285]

B:BD[94.242] → [94.242:285]

B:BD[94.285] → [38.1934:1950]

B:BD[38.1950] → [18.4298:4325]

∅:D[18.4325] → [38.1976:2051]

B:BD[38.1976] → [38.1976:2051]

B:BD[38.2051] → [89.416:432]

B:BD[89.432] → [18.4326:4346]

∅:D[18.4346] → [89.451:514]

B:BD[89.451] → [89.451:514]

B:BD[89.514] → [18.4347:4368]

∅:D[18.4368] → [89.534:601]

B:BD[89.534] → [89.534:601]

B:BD[89.601] → [18.4369:4388]

∅:D[18.4388] → [89.619:683]

B:BD[89.619] → [89.619:683]

B:BD[89.683] → [18.4389:4408]

∅:D[18.4408] → [89.701:842]

B:BD[89.701] → [89.701:842]

B:BD[89.842] → [18.4409:4428]

∅:D[18.4428] → [89.860:911]

B:BD[89.860] → [89.860:911]

∅:D[94.285] → [33.114922:114938]

∅:D[89.911] → [33.114922:114938]

∅:D[38.2051] → [33.114922:114938]

B:BD[33.114922] → [33.114922:114938]

B:BD[33.114938] → [18.4429:4450]

∅:D[18.4450] → [33.114958:115035]

B:BD[33.114958] → [33.114958:115035]

B:BD[33.115035] → [18.4451:4549]

∅:D[93.534] → [33.115131:115251]

∅:D[18.4549] → [33.115131:115251]

B:BD[33.115131] → [33.115131:115251]

}
bool in_bounds_x(int x)
{
    return (x > X_BOUND_1 && x < X_BOUND_2);
}
bool in_bounds_y(int y)
{
    return (y > Y_BOUND_1 && y < Y_BOUND_2);
}
// Returns true if inside the area the player can move and dig (ie exclusive).
bool in_bounds(int x, int y)
{
    return (in_bounds_x(x) && in_bounds_y(y));
}
bool map_bounds_x(int x)
{
    return (x >= X_BOUND_1 && x <= X_BOUND_2);
}
bool map_bounds_y(int y)
{
    return (y >= Y_BOUND_1 && y <= Y_BOUND_2);
}
// Returns true if inside the area the player can map (ie inclusive).
// Note that terrain features should be in_bounds() leaving an outer
// ring of rock to frame the level.
bool map_bounds(int x, int y)
{
    return (map_bounds_x(x) && map_bounds_y(y));
}
coord_def random_in_bounds()
{
    if (crawl_state.arena)
    {
        const coord_def &ul = crawl_view.glos1; // Upper left
        const coord_def &lr = crawl_view.glos2; // Lower right
        return coord_def(random_range(ul.x, lr.x - 1),
                         random_range(ul.y, lr.y - 1));
    }
    else
        return coord_def(random_range(MAPGEN_BORDER, GXM - MAPGEN_BORDER - 1),
                         random_range(MAPGEN_BORDER, GYM - MAPGEN_BORDER - 1));
}
unsigned char random_colour(void)
{
    return (1 + random2(15));
}
unsigned char random_uncommon_colour()
{
    unsigned char result;
    do
        result = random_colour();
    while (result == LIGHTCYAN || result == CYAN || result == BROWN);
    return (result);
}
unsigned char make_low_colour(unsigned char colour)
{
    if (colour >= 8 && colour <= 15)
        return (colour - 8);
    return (colour);
}
unsigned char make_high_colour(unsigned char colour)
{
    if (colour <= 7)
        return (colour + 8);
    return (colour);
}
// returns if a colour is one of the special element colours (ie not regular)
bool is_element_colour( int col )
{
    // stripping any COLFLAGS (just in case)
    return ((col & 0x007f) >= ETC_FIRE);
}
int element_colour( int element, bool no_random )
{
    // Doing this so that we don't have to do recursion here at all
    // (these were the only cases which had possible double evaluation):
    if (element == ETC_FLOOR)
        element = env.floor_colour;
    else if (element == ETC_ROCK)
        element = env.rock_colour;
    // pass regular colours through for safety.
    if (!is_element_colour( element ))
        return (element);
    int ret = BLACK;
    // Setting no_random to true will get the first colour in the cases
    // below.  This is potentially useful for calls to this function
    // which might want a consistent result.
    int tmp_rand = (no_random ? 0 : random2(120));
    switch (element & 0x007f)   // strip COLFLAGs just in case
    {
    case ETC_FIRE:
        ret = (tmp_rand < 40) ? RED :
              (tmp_rand < 80) ? YELLOW
                              : LIGHTRED;
        break;
    case ETC_ICE:
        ret = (tmp_rand < 40) ? LIGHTBLUE :
              (tmp_rand < 80) ? BLUE
                              : WHITE;
        break;
    case ETC_EARTH:
        ret = (tmp_rand < 60) ? BROWN : LIGHTRED;
        break;
    case ETC_AIR:
        ret = (tmp_rand < 60) ? LIGHTGREY : WHITE;
        break;
    case ETC_ELECTRICITY:
        ret = (tmp_rand < 40) ? LIGHTCYAN :
              (tmp_rand < 80) ? LIGHTBLUE
                              : CYAN;
        break;
    case ETC_POISON:
        ret = (tmp_rand < 60) ? LIGHTGREEN : GREEN;
        break;
    case ETC_WATER:
        ret = (tmp_rand < 60) ? BLUE : CYAN;
        break;
    case ETC_MAGIC:
        ret = (tmp_rand < 30) ? LIGHTMAGENTA :
              (tmp_rand < 60) ? LIGHTBLUE :
              (tmp_rand < 90) ? MAGENTA
                              : BLUE;
        break;
    case ETC_MUTAGENIC:
    case ETC_WARP:
        ret = (tmp_rand < 60) ? LIGHTMAGENTA : MAGENTA;
        break;
    case ETC_ENCHANT:
        ret = (tmp_rand < 60) ? LIGHTBLUE : BLUE;
        break;
    case ETC_HEAL:
        ret = (tmp_rand < 60) ? LIGHTBLUE : YELLOW;
        break;
    case ETC_BLOOD:
        ret = (tmp_rand < 60) ? RED : DARKGREY;
        break;
    case ETC_DEATH:      // assassin
    case ETC_NECRO:      // necromancer
        ret = (tmp_rand < 80) ? DARKGREY : MAGENTA;
        break;
    case ETC_UNHOLY:     // ie demonology
        ret = (tmp_rand < 80) ? DARKGREY : RED;
        break;
    case ETC_DARK:
        ret = (tmp_rand < 80) ? DARKGREY : LIGHTGREY;
        break;
    case ETC_HOLY:
        ret = (tmp_rand < 60) ? YELLOW : WHITE;
        break;
    case ETC_VEHUMET:
        ret = (tmp_rand < 40) ? LIGHTRED :
              (tmp_rand < 80) ? LIGHTMAGENTA
                              : LIGHTBLUE;
        break;
    case ETC_BEOGH:
        ret = (tmp_rand < 60) ? LIGHTRED // plain Orc colour
                              : BROWN;   // Orcish mines wall/idol colour
        break;
    case ETC_CRYSTAL:
        ret = (tmp_rand < 40) ? LIGHTGREY :
              (tmp_rand < 80) ? GREEN
                              : LIGHTRED;
        break;
    case ETC_SLIME:
        ret = (tmp_rand < 40) ? GREEN :
              (tmp_rand < 80) ? BROWN
                              : LIGHTGREEN;
        break;
    case ETC_SMOKE:
        ret = (tmp_rand < 30) ? LIGHTGREY :
              (tmp_rand < 60) ? DARKGREY :
              (tmp_rand < 90) ? LIGHTBLUE
                              : MAGENTA;
        break;
    case ETC_JEWEL:
        ret = (tmp_rand <  12) ? WHITE :
              (tmp_rand <  24) ? YELLOW :
              (tmp_rand <  36) ? LIGHTMAGENTA :
              (tmp_rand <  48) ? LIGHTRED :
              (tmp_rand <  60) ? LIGHTGREEN :
              (tmp_rand <  72) ? LIGHTBLUE :
              (tmp_rand <  84) ? MAGENTA :
              (tmp_rand <  96) ? RED :
              (tmp_rand < 108) ? GREEN
                               : BLUE;
        break;
    case ETC_ELVEN:
        ret = (tmp_rand <  40) ? LIGHTGREEN :
              (tmp_rand <  80) ? GREEN :
              (tmp_rand < 100) ? LIGHTBLUE
                               : BLUE;
        break;
    case ETC_DWARVEN:
        ret = (tmp_rand <  40) ? BROWN :
              (tmp_rand <  80) ? LIGHTRED :
              (tmp_rand < 100) ? LIGHTGREY
                               : CYAN;
        break;
    case ETC_ORCISH:
        ret = (tmp_rand <  40) ? DARKGREY :
              (tmp_rand <  80) ? RED :
              (tmp_rand < 100) ? BROWN
                               : MAGENTA;
        break;
    case ETC_GILA:
        ret = (tmp_rand <  30) ? LIGHTMAGENTA :
              (tmp_rand <  60) ? MAGENTA :
              (tmp_rand <  90) ? YELLOW :
              (tmp_rand < 105) ? LIGHTRED
                               : RED;
        break;
    case ETC_STONE:
        if (player_in_branch( BRANCH_HALL_OF_ZOT ))
            ret = env.rock_colour;
        else
            ret = LIGHTGREY;
        break;
    case ETC_MIST:
        ret = tmp_rand < 100? CYAN : BLUE;
        break;
    case ETC_SHIMMER_BLUE:
        ret = random_choose_weighted(80, BLUE, 20, LIGHTBLUE, 5, CYAN, 0);
        break;
    case ETC_DECAY:
        ret = (tmp_rand < 60) ? BROWN : GREEN;
        break;
    case ETC_SILVER:
        ret = (tmp_rand < 90) ? LIGHTGREY : WHITE;
        break;
    case ETC_GOLD:
        ret = (tmp_rand < 60) ? YELLOW : BROWN;
        break;
    case ETC_IRON:
        ret = (tmp_rand < 40) ? CYAN :
              (tmp_rand < 80) ? LIGHTGREY :
                                DARKGREY;
        break;
    case ETC_BONE:
        ret = (tmp_rand < 90) ? WHITE : LIGHTGREY;
        break;
    case ETC_RANDOM:
        ret = 1 + random2(15);              // always random
        break;
    case ETC_FLOOR: // should already be handled
    case ETC_ROCK:  // should already be handled
    default:
        break;
    }
    ASSERT( !is_element_colour( ret ) );
    return ((ret == BLACK) ? GREEN : ret);

Deletion in crawl-ref/source/stuff.cc at line 814 [15.224557]

B:BD[36.1201] → [36.1201:1203]

∅:D[36.1203] → [15.242006:242007]

B:BD[15.242006] → [15.242006:242007]

B:BD[15.242007] → [51.207:421]

}
int fuzz_value(int val, int lowfuzz, int highfuzz, int naverage)
{
    const int lfuzz = lowfuzz * val / 100,
        hfuzz = highfuzz * val / 100;
    return val + random2avg(lfuzz + hfuzz + 1, naverage) - lfuzz;

Deletion in crawl-ref/source/stuff.cc at line 908 [15.224557]
B:BD[95.146] → [95.146:295]
B:BD[95.295] → [96.1322:1364]
∅:D[96.1364] → [97.1996:1998]
B:BD[95.347] → [97.1996:1998]
B:BD[97.1998] → [98.943:944]
```
//////////////////////////////////////////////////////////////////////////
// coord_def
int coord_def::distance_from(const coord_def &other) const
{
    return (grid_distance(*this, other));
}
```
Deletion in crawl-ref/source/stuff.cc at line 932 [15.224557]
∅:D[99.322] → [100.255:257]
B:BD[100.255] → [100.255:257]
B:BD[100.257] → [101.426:501]
```
}
int dice_def::roll() const
{
    return roll_dice(this->num, this->size);
```
Insertion in crawl-ref/source/stash.cc at line 14 [19.147324]
[102.175]
[19.147500]
```
#include "coord.h"
```
Insertion in crawl-ref/source/spl-util.cc at line 22 [15.245665]
[17.45702]
[30.670]
```
#include "coordit.h"
```
Insertion in crawl-ref/source/spl-mis.cc at line 15 [103.461]
[103.774]
[103.774]
```
#include "colour.h"
```
Insertion in crawl-ref/source/spl-cast.cc at line 17 [15.293070]
[15.293686]
[104.169]
```
#include "coord.h"
#include "coordit.h"
```
Insertion in crawl-ref/source/spells1.cc at line 23 [15.616635]
[15.617410]
[105.273]
```
#include "coord.h"
#include "coordit.h"
```
Replacement in crawl-ref/source/species.cc at line 5 [106.785]
B:BD[106.829] → [106.829:848]
```
#include "stuff.h"
```
[106.829]
[106.848]
```
#include "random.h"
```
Insertion in crawl-ref/source/skills.cc at line 21 [15.745542]
[15.746134]
[15.746134]
```
#include "random.h"
```
Deletion in crawl-ref/source/skills.cc at line 24 [15.745542]
∅:D[107.4302] → [15.746155:746174]
B:BD[15.746155] → [15.746155:746174]
```
#include "stuff.h"
```

File addition: rng.h (----------)

[108.24]

#ifndef RNG_H
#define RNG_H
void seed_rng();
void seed_rng(long seed);
void push_rng_state();
void pop_rng_state();
void cf_setseed();
unsigned long random_int();
#endif

File addition: rng.cc (----------)

[108.24]

/*
 * File:      rng.cc
 * Summary:   Random number generator wrapping.
 */
#include "AppHdr.h"
#include "rng.h"
#include "mt19937ar.h"
#ifdef USE_MORE_SECURE_SEED
// for times()
#include <sys/times.h>
// for getpid()
#include <sys/types.h>
#include <unistd.h>
#endif
#ifdef MORE_HARDENED_PRNG
#include "sha256.h"
#endif
void seed_rng(unsigned long* seed_key, size_t num_keys)
{
    // MT19937 -- see mt19937ar.cc for details/licence
    init_by_array(seed_key, num_keys);
}
void seed_rng(long seed)
{
    // MT19937 -- see mt19937ar.cc for details/licence
    init_genrand(seed);
}
void seed_rng()
{
    unsigned long seed = time( NULL );
#ifdef USE_MORE_SECURE_SEED
    /* (at least) 256-bit wide seed */
    unsigned long seed_key[8];
    struct tms  buf;
    seed += times( &buf ) + getpid();
    seed_key[0] = seed;
    /* Try opening from various system provided (hopefully) CSPRNGs */
    FILE* seed_f = fopen("/dev/urandom", "rb");
    if (!seed_f)
        seed_f = fopen("/dev/random", "rb");
    if (!seed_f)
        seed_f = fopen("/dev/srandom", "rb");
    if (!seed_f)
        seed_f = fopen("/dev/arandom", "rb");
    if (seed_f)
    {
        fread(&seed_key[1], sizeof(unsigned long), 7, seed_f);
        fclose(seed_f);
    }
    seed_rng(seed_key, 8);
#else
    seed_rng(seed);
#endif
}
// MT19937 -- see mt19937ar.cc for details
unsigned long random_int( void )
{
#ifndef MORE_HARDENED_PRNG
    return (genrand_int32());
#else
    return (sha256_genrand());
#endif
}
void push_rng_state()
{
    push_mt_state();
}
void pop_rng_state()
{
    pop_mt_state();
}

File addition: random.h (----------)

[108.24]

#ifndef RANDOM_H
#define RANDOM_H
#include "rng.h"
bool coinflip();
int div_rand_round( int num, int den );
int div_round_up( int num, int den );
bool one_chance_in(int a_million);
bool x_chance_in_y(int x, int y);
int random2(int max);
int maybe_random2(int x, bool random_factor);
int random_range(int low, int high);
int random_range(int low, int high, int nrolls);
const char* random_choose_string(const char* first, ...);
int random_choose(int first, ...);
int random_choose_weighted(int weight, int first, ...);
int random2avg(int max, int rolls);
int bestroll(int max, int rolls);
int random2limit(int max, int limit);
int binomial_generator(unsigned n_trials, unsigned trial_prob);
int fuzz_value(int val, int lowfuzz, int highfuzz, int naverage = 2);
int roll_dice(int num, int size);
struct dice_def
{
    int num;
    int size;
    dice_def(int n = 0, int s = 0) : num(n), size(s) {}
    int roll() const;
};
dice_def calc_dice(int num_dice, int max_damage);
void scale_dice(dice_def &dice, int threshold = 24);
class rng_save_excursion
{
public:
    rng_save_excursion(long seed) { push_rng_state(); seed_rng(seed); }
    rng_save_excursion()          { push_rng_state(); }
    ~rng_save_excursion()         { pop_rng_state(); }
};
template<typename Iterator>
int choose_random_weighted(Iterator beg, const Iterator end)
{
    ASSERT(beg < end);
#ifdef DEBUG
    int times_set = 0;
#endif
    int totalweight = 0;
    int count = 0, result = 0;
    while (beg != end)
    {
        totalweight += *beg;
        if (random2(totalweight) < *beg)
        {
            result = count;
#ifdef DEBUG
            times_set++;
#endif
        }
        ++count;
        ++beg;
    }
#ifdef DEBUG
    ASSERT(times_set > 0);
#endif
    return result;
}
#endif

File addition: random.cc (----------)

[108.24]

#include "AppHdr.h"
#include "random.h"
int random_range(int low, int high)
{
    ASSERT(low <= high);
    return (low + random2(high - low + 1));
}
int random_range(int low, int high, int nrolls)
{
    ASSERT(nrolls > 0);
    int sum = 0;
    for (int i = 0; i < nrolls; ++i)
        sum += random_range(low, high);
    return (sum / nrolls);
}
// Chooses one of the numbers passed in at random. The list of numbers
// must be terminated with -1.
int random_choose(int first, ...)
{
    va_list args;
    va_start(args, first);
    int chosen = first, count = 1, nargs = 100;
    while (nargs-- > 0)
    {
        const int pick = va_arg(args, int);
        if (pick == -1)
            break;
        if (one_chance_in(++count))
            chosen = pick;
    }
    ASSERT(nargs > 0);
    va_end(args);
    return (chosen);
}
// Chooses one of the strings passed in at random. The list of strings
// must be terminated with NULL.
const char* random_choose_string(const char* first, ...)
{
    va_list args;
    va_start(args, first);
    const char* chosen = first;
    int count = 1, nargs = 100;
    while (nargs-- > 0)
    {
        char* pick = va_arg(args, char*);
        if (pick == NULL)
            break;
        if (one_chance_in(++count))
            chosen = pick;
    }
    ASSERT(nargs > 0);
    va_end(args);
    return (chosen);
}
int random_choose_weighted(int weight, int first, ...)
{
    va_list args;
    va_start(args, first);
    int chosen = first, cweight = weight, nargs = 100;
    while (nargs-- > 0)
    {
        const int nweight = va_arg(args, int);
        if (!nweight)
            break;
        const int choice = va_arg(args, int);
        if (random2(cweight += nweight) < nweight)
            chosen = choice;
    }
    ASSERT(nargs > 0);
    va_end(args);
    return (chosen);
}
int random2(int max)
{
    if (max <= 1)
        return (0);
    return (static_cast<int>(random_int() / (0xFFFFFFFFUL / max + 1)));
}
bool coinflip(void)
{
    return (static_cast<bool>(random2(2)));
}
// Returns random2(x) if random_factor is true, otherwise the mean.
int maybe_random2(int x, bool random_factor)
{
    if (random_factor)
        return (random2(x));
    else
        return (x / 2);
}
int roll_dice(int num, int size)
{
    int ret = 0;
    int i;
    // If num <= 0 or size <= 0, then we'll just return the default
    // value of zero.  This is good behaviour in that it will be
    // appropriate for calculated values that might be passed in.
    if (num > 0 && size > 0)
    {
        ret += num;     // since random2() is zero based
        for (i = 0; i < num; i++)
            ret += random2(size);
    }
    return (ret);
}
int dice_def::roll() const
{
    return roll_dice(this->num, this->size);
}
dice_def calc_dice(int num_dice, int max_damage)
{
    dice_def ret(num_dice, 0);
    if (num_dice <= 1)
    {
        ret.num  = 1;
        ret.size = max_damage;
    }
    else if (max_damage <= num_dice)
    {
        ret.num  = max_damage;
        ret.size = 1;
    }
    else
    {
        // Divide the damage among the dice, and add one
        // occasionally to make up for the fractions. -- bwr
        ret.size  = max_damage / num_dice;
        ret.size += x_chance_in_y(max_damage % num_dice, num_dice);
    }
    return (ret);
}
// Attempts to make missile weapons nicer to the player by reducing the
// extreme variance in damage done.
void scale_dice(dice_def &dice, int threshold)
{
    while (dice.size > threshold)
    {
        dice.num *= 2;
        // If it's an odd number, lose one; this is more than
        // compensated by the increase in number of dice.
        dice.size /= 2;
    }
}
// Calculates num/den and randomly adds one based on the remainder.
int div_rand_round(int num, int den)
{
    return (num / den + (random2(den) < num % den));
}
int bestroll(int max, int rolls)
{
    int best = 0;
    for (int i = 0; i < rolls; i++)
    {
        int curr = random2(max);
        if (curr > best)
            best = curr;
    }
    return (best);
}
// random2avg() returns same mean value as random2() but with a lower variance
// never use with rolls < 2 as that would be silly - use random2() instead {dlb}
int random2avg(int max, int rolls)
{
    int sum = random2(max);
    for (int i = 0; i < (rolls - 1); i++)
        sum += random2(max + 1);
    return (sum / rolls);
}
// originally designed to randomise evasion -
// values are slightly lowered near (max) and
// approach an upper limit somewhere near (limit/2)
int random2limit(int max, int limit)
{
    int i;
    int sum = 0;
    if (max < 1)
        return (0);
    for (i = 0; i < max; i++)
        if (random2(limit) >= i)
            sum++;
    return (sum);
}
// Generate samples from a binomial distribution with n_trials and trial_prob
// probability of success per trial. trial_prob is a integer less than 100
// representing the % chancee of success.
// This just evaluates all n trials, there is probably an efficient way of
// doing this but I'm not much of a statistician. -CAO
int binomial_generator(unsigned n_trials, unsigned trial_prob)
{
    int count = 0;
    for (unsigned i = 0; i < n_trials; ++i)
        if (::x_chance_in_y(trial_prob, 100))
            count++;
    return count;
}
bool one_chance_in(int a_million)
{
    return (random2(a_million) == 0);
}
bool x_chance_in_y(int x, int y)
{
    if (x <= 0)
        return (false);
    if (x >= y)
        return (true);
    return (random2(y) < x);
}
int fuzz_value(int val, int lowfuzz, int highfuzz, int naverage)
{
    const int lfuzz = lowfuzz * val / 100,
        hfuzz = highfuzz * val / 100;
    return val + random2avg(lfuzz + hfuzz + 1, naverage) - lfuzz;
}

Insertion in crawl-ref/source/player.cc at line 27 [15.962854]
[19.197728]
[33.337045]
```
#include "coord.h"
#include "coordit.h"
```
Insertion in crawl-ref/source/player.cc at line 52 [15.962854]
[109.8997]
[15.963817]
```
#include "random.h"
```
Insertion in crawl-ref/source/overmap.cc at line 23 [15.1070017]
[110.6065]
[111.2126]
```
#include "colour.h"
#include "coord.h"
```
Insertion in crawl-ref/source/output.cc at line 24 [15.1088282]
[112.2590]
[113.1134]
```
#include "colour.h"
#include "coord.h"
```
Insertion in crawl-ref/source/ouch.cc at line 58 [15.1104358]
[15.1106227]
[15.1106248]
```
#include "random.h"
```
Replacement in crawl-ref/source/ng-init.cc at line 15 [14.2971]
B:BD[14.3272] → [14.3272:3291]
```
#include "stuff.h"
```
[14.3272]
[14.3291]
```
#include "random.h"
```
Insertion in crawl-ref/source/newgame.cc at line 55 [15.1132300]
[15.1135513]
[114.2557]
```
#include "random.h"
```
Insertion in crawl-ref/source/mutation.cc at line 41 [15.1263003]
[115.36445]
[15.1263988]
```
#include "random.h"
```
Deletion in crawl-ref/source/mutation.cc at line 43 [15.1263003]
B:BD[15.1264009] → [15.1264009:1264028]
```
#include "stuff.h"
```
Replacement in crawl-ref/source/mtransit.cc at line 18 [117.8445]
∅:D[116.3874] → [117.8778:8797]
B:BD[117.8778] → [117.8778:8797]
```
#include "stuff.h"
```
[117.8778]
[117.8797]
```
#include "random.h"
```
Insertion in crawl-ref/source/mstuff2.cc at line 22 [15.1340842]
[118.3582]
[119.6205]
```
#include "colour.h"
```
Insertion in crawl-ref/source/monstuff.cc at line 25 [15.1396662]
[15.1397612]
[120.3129]
```
#include "colour.h"
```
Insertion in crawl-ref/source/monplace.h at line 11 [15.1638277]
[15.1638565]
[15.1638565]
```
#include "coord.h"
```
Insertion in crawl-ref/source/monplace.cc at line 26 [15.1641732]
[15.1642168]
[121.2546]
```
#include "random.h"
```
Insertion in crawl-ref/source/mon-util.cc at line 29 [15.1699344]
[122.3010]
[123.2801]
```
#include "colour.h"
```
Insertion in crawl-ref/source/mon-util.cc at line 49 [15.1699344]
[15.1700146]
[124.2533]
```
#include "random.h"
```
Insertion in crawl-ref/source/misc.cc at line 65 [15.1933596]
[15.1934463]
[125.692]
```
#include "random.h"
```
Replacement in crawl-ref/source/mgrow.cc at line 13 [126.2647]
B:BD[126.2922] → [126.2922:2941]
```
#include "stuff.h"
```
[126.2922]
[126.2941]
```
#include "random.h"
```
Insertion in crawl-ref/source/message.cc at line 23 [15.1993826]
[127.4593]
[17.72405]
```
#include "colour.h"
```
Insertion in crawl-ref/source/message.cc at line 31 [15.1993826]
[33.555209]
[17.72469]
```
#include "random.h"
```
Insertion in crawl-ref/source/menu.cc at line 15 [19.261322]
[17.72593]
[128.3674]
```
#include "player.h"
#include "tutorial.h"
#include "view.h"
```
Insertion in crawl-ref/source/menu.cc at line 20 [19.261322]
[128.3690]
[129.2673]
```
 #include "coord.h"
```
Deletion in crawl-ref/source/menu.cc at line 24 [19.261322]
∅:D[130.4254] → [128.3713:3720]
B:BD[128.3713] → [128.3713:3720]
∅:D[128.3720] → [131.222:242]
B:BD[17.72593] → [131.222:242]
B:BD[131.242] → [132.5060:5096]
```
#endif
#include "player.h"
#ifdef USE_TILE
 #include "stuff.h"
```
Deletion in crawl-ref/source/menu.cc at line 28 [19.261322]
∅:D[131.242] → [133.1369:1391]
∅:D[132.5144] → [133.1369:1391]
∅:D[17.72593] → [133.1369:1391]
∅:D[31.5750040] → [133.1369:1391]
B:BD[19.261378] → [133.1369:1391]
∅:D[133.1391] → [19.261378:261396]
B:BD[19.261378] → [19.261378:261396]
```
#include "tutorial.h"
#include "view.h"
```
Insertion in crawl-ref/source/maps.cc at line 26 [15.2007666]
[33.583623]
[17.72596]
```
#include "random.h"
```
Deletion in crawl-ref/source/maps.cc at line 28 [15.2007666]
∅:D[134.559] → [15.2008120:2008139]
∅:D[17.72615] → [15.2008120:2008139]
∅:D[33.583623] → [15.2008120:2008139]
B:BD[15.2008120] → [15.2008120:2008139]
```
#include "stuff.h"
```
Insertion in crawl-ref/source/mapdef.h at line 18 [33.591249]
[33.591553]
[135.2902]
```
#include "coordit.h"
```
Insertion in crawl-ref/source/mapdef.cc at line 18 [33.594797]
[136.4293]
[137.3793]
```
#include "colour.h"
#include "coord.h"
```
Insertion in crawl-ref/source/mapdef.cc at line 36 [33.594797]
[17.73332]
[87.3244]
```
#include "random.h"
```
Insertion in crawl-ref/source/makeitem.cc at line 16 [139.927]
[138.29314]
[17.73552]
```
#include "colour.h"
#include "coord.h"
```
Insertion in crawl-ref/source/makeitem.cc at line 27 [139.927]
[139.1116]
[139.1137]
```
#include "random.h"
```
Deletion in crawl-ref/source/makeitem.cc at line 29 [139.927]
B:BD[139.1159] → [139.1159:1178]
```
#include "stuff.h"
```
Insertion in crawl-ref/source/makefile.obj at line 16 [140.79]
[7.2868]
[140.155]
```
colour.o \
```
Insertion in crawl-ref/source/makefile.obj at line 18 [140.79]
[140.167]
[141.4937]
```
coord.o \
coordit.o \
```
Insertion in crawl-ref/source/makefile.obj at line 108 [140.79]
[142.12549]
[143.24741]
```
random.o \
```
Insertion in crawl-ref/source/makefile.obj at line 111 [140.79]
[140.617]
[70.11950]
```
rng.o \
```
Insertion in crawl-ref/source/los.cc at line 51 [143.26450]
[144.3127]
[143.26618]
```
#include "coord.h"
#include "coordit.h"
```
Replacement in crawl-ref/source/lev-pand.cc at line 17 [15.2574562]
B:BD[15.2574896] → [15.2574896:2574915]
```
#include "stuff.h"
```
[15.2574896]
[15.2574915]
```
#include "random.h"
```
Insertion in crawl-ref/source/l_you.cc at line 8 [146.2866]
[145.2900]
[145.2900]
```
#include "coord.h"
```
Insertion in crawl-ref/source/l_los.cc at line 12 [148.4668]
[8.2930]
[147.2888]
```
#include "coord.h"
```
Insertion in crawl-ref/source/l_item.cc at line 9 [149.3037]
[149.3140]
[149.3140]
```
#include "colour.h"
```
Insertion in crawl-ref/source/l_dgnit.cc at line 11 [150.9944]
[150.10095]
[150.10095]
```
#include "coord.h"
```
Insertion in crawl-ref/source/l_dgngrd.cc at line 12 [151.3004]
[151.3161]
[151.3161]
```
#include "coord.h"
```
Replacement in crawl-ref/source/l_dgngrd.cc at line 14 [151.3004]
B:BD[151.3182] → [152.3362:3381]
```
#include "stuff.h"
```
[151.3182]
[151.3182]
```
#include "env.h"
```
Insertion in crawl-ref/source/l_dgnbld.cc at line 13 [153.2992]
[153.3156]
[153.3156]
```
#include "coord.h"
```
Insertion in crawl-ref/source/l_dgnbld.cc at line 15 [153.2992]
[153.3177]
[153.3177]
```
#include "random.h"
```
Deletion in crawl-ref/source/l_dgn_bf.cc at line 10 [154.3071]
B:BD[154.3209] → [154.3209:3210]
Insertion in crawl-ref/source/l_dgn_bf.cc at line 11 [154.3071]
[154.3230]
[154.3230]
```
#include "random.h"
```
Insertion in crawl-ref/source/l_dgn.cc at line 10 [156.1232]
[155.4423]
[9.2918]
```
#include "colour.h"
#include "coord.h"
```
Insertion in crawl-ref/source/l_dgn.cc at line 16 [156.1232]
[157.522]
[155.4442]
```
#include "random.h"
```
Insertion in crawl-ref/source/l_crawl.cc at line 23 [160.2870]
[158.4638]
[159.2893]
```
#include "random.h"
```
Insertion in crawl-ref/source/itemprop.cc at line 34 [33.646661]
[161.7538]
[33.647262]
```
#include "random.h"
```
Insertion in crawl-ref/source/itemname.cc at line 24 [15.2667494]
[138.34215]
[162.952]
```
#include "colour.h"
```
Insertion in crawl-ref/source/item_use.cc at line 23 [15.2781507]
[163.509]
[164.581]
```
#include "colour.h"
```
Insertion in crawl-ref/source/invent.cc at line 25 [15.2920632]
[19.370217]
[165.2692]
```
#include "colour.h"
```

Deletion in crawl-ref/source/initfile.h at line 23 [15.2956146]

B:BD[166.6687] → [167.6311:6424]

int str_to_colour(const std::string &str, int default_colour = -1,
                  bool accept_number = true);

Deletion in crawl-ref/source/initfile.h at line 24 [15.2956146]
∅:D[10.6109] → [167.6424:6479]
B:BD[167.6424] → [167.6424:6479]
```
const std::string colour_to_str(unsigned char colour);
```
Insertion in crawl-ref/source/initfile.cc at line 18 [15.2957258]
[19.390989]
[135.18812]
```
#include "colour.h"
```

Deletion in crawl-ref/source/initfile.cc at line 84 [15.2957258]

B:BD[168.14721] → [169.4581:4598]

B:BD[169.4598] → [170.5948:5983]

∅:D[170.5983] → [169.4632:4937]

B:BD[169.4632] → [169.4632:4937]

∅:D[169.4937] → [168.14721:14722]

B:BD[168.14721] → [168.14721:14722]

B:BD[168.14722] → [171.9057:9117]

∅:D[171.9117] → [169.4997:5043]

B:BD[169.4997] → [169.4997:5043]


#ifdef USE_TILE
static std::string tile_cols[24] =
{
    "black", "darkgrey", "grey", "lightgrey", "white",
    "blue", "lightblue", "darkblue",
    "green", "lightgreen", "darkgreen",
    "cyan", "lightcyan", "darkcyan",
    "red", "lightred", "darkred",
    "magenta", "lightmagenta", "darkmagenta",
    "yellow", "lightyellow", "darkyellow", "brown"
};
static unsigned int _str_to_tile_colour(std::string colour)
{
    if (colour.empty())
        return (0);

Deletion in crawl-ref/source/initfile.cc at line 85 [15.2957258]

B:BD[169.5044] → [169.5044:5249]

B:BD[169.5249] → [172.5637:5638]

∅:D[172.5638] → [171.9118:9160]

B:BD[169.5258] → [171.9118:9160]

∅:D[171.9160] → [169.5296:5396]

B:BD[169.5296] → [169.5296:5396]

∅:D[169.5396] → [168.14722:14941]

B:BD[168.14722] → [168.14722:14941]

B:BD[168.14941] → [167.6481:6535]

∅:D[167.6535] → [168.14989:15052]

B:BD[168.14989] → [168.14989:15052]

B:BD[168.15052] → [167.6536:6565]

∅:D[167.6565] → [15.2959142:2959145]

∅:D[168.15089] → [15.2959142:2959145]

∅:D[19.391347] → [15.2959142:2959145]

B:BD[15.2959142] → [15.2959142:2959145]

    lowercase(colour);
    if (colour == "darkgray")
        colour = "darkgrey";
    else if (colour == "gray")
        colour = "grey";
    else if (colour == "lightgray")
        colour = "lightgrey";
    for (unsigned int i = 0; i < 24; i++)
    {
         if (tile_cols[i] == colour)
             return (i);
    }
    return (0);
}
#endif
const std::string cols[16] =
{
    "black", "blue", "green", "cyan", "red", "magenta", "brown",
    "lightgrey", "darkgrey", "lightblue", "lightgreen", "lightcyan",
    "lightred", "lightmagenta", "yellow", "white"
};
const std::string colour_to_str(unsigned char colour)
{
    if ( colour >= 16 )
        return "lightgrey";
    else
        return cols[colour];
}

Deletion in crawl-ref/source/initfile.cc at line 86 [15.2957258]

∅:D[173.6839] → [174.3123:3226]

B:BD[15.2959190] → [174.3123:3226]

∅:D[174.3226] → [15.2959243:2959259]

∅:D[33.785326] → [15.2959243:2959259]

B:BD[15.2959243] → [15.2959243:2959259]

B:BD[15.2959259] → [2.280:326]

∅:D[2.326] → [33.785366:785372]

B:BD[33.785366] → [33.785366:785372]

B:BD[33.785372] → [16.448:869]

∅:D[175.326] → [33.785701:785709]

∅:D[16.869] → [33.785701:785709]

∅:D[94.2876] → [33.785701:785709]

B:BD[33.785701] → [33.785701:785709]

B:BD[33.785709] → [18.8203:8269]

∅:D[30.7062] → [16.936:937]

∅:D[18.8269] → [16.936:937]

B:BD[16.936] → [16.936:937]

B:BD[16.937] → [176.4002:4043]

∅:D[176.4043] → [15.2959543:2959592]

B:BD[15.2959543] → [15.2959543:2959592]

B:BD[15.2959592] → [176.4044:4050]

∅:D[176.4050] → [15.2959598:2959599]

B:BD[15.2959598] → [15.2959598:2959599]

B:BD[15.2959599] → [177.7827:7865]

∅:D[177.7865] → [15.2959636:2959771]

B:BD[15.2959636] → [15.2959636:2959771]

B:BD[15.2959771] → [19.391348:391380]

B:BD[19.391380] → [33.785710:785764]

B:BD[33.785764] → [172.5639:5718]

∅:D[172.5718] → [33.785844:785953]

B:BD[33.785844] → [33.785844:785953]

B:BD[33.785953] → [18.8270:8320]

∅:D[18.8320] → [33.786002:786056]

B:BD[33.786002] → [33.786002:786056]

B:BD[33.786056] → [174.3227:3263]

∅:D[174.3263] → [33.786075:786081]

B:BD[33.786075] → [33.786075:786081]

B:BD[33.786081] → [177.7866:7917]

∅:D[177.7917] → [19.391430:391492]

B:BD[19.391430] → [19.391430:391492]

B:BD[19.391492] → [178.4467:4528]

∅:D[178.4528] → [19.391535:391621]

B:BD[19.391535] → [19.391535:391621]

∅:D[19.391621] → [15.2959771:2959778]

B:BD[15.2959771] → [15.2959771:2959778]

B:BD[15.2959778] → [33.786082:786131]

∅:D[33.786131] → [15.2959815:2959818]

B:BD[15.2959815] → [15.2959815:2959818]

B:BD[15.2959818] → [177.7918:7964]

int str_to_colour( const std::string &str, int default_colour,
                   bool accept_number )
{
    int ret;
    static const std::string element_cols[] =
    {
        "fire", "ice", "earth", "electricity", "air", "poison",
        "water", "magic", "mutagenic", "warp", "enchant", "heal",
        "holy", "dark", "death", "necro", "unholy", "vehumet",
        "beogh", "crystal", "blood", "smoke", "slime", "jewel",
        "elven", "dwarven", "orcish", "gila", "floor", "rock",
        "stone", "mist", "shimmer_blue", "decay", "silver", "gold",
        "iron", "bone", "random"
    };
    ASSERT(ARRAYSZ(element_cols) == (ETC_RANDOM - ETC_FIRE) + 1);
    for (ret = 0; ret < 16; ++ret)
    {
        if (str == cols[ret])
            break;
    }
    // Check for alternate spellings.
    if (ret == 16)
    {
        if (str == "lightgray")
            ret = 7;
        else if (str == "darkgray")
            ret = 8;
    }
    if (ret == 16)
    {
        // Maybe we have an element colour attribute.
        for (unsigned i = 0; i < sizeof(element_cols) / sizeof(*element_cols);
                ++i)
        {
            if (str == element_cols[i])
            {
                // Ugh.
                ret = element_type(ETC_FIRE + i);
                break;
            }
        }
    }
    if (ret == 16 && accept_number)
    {
        // Check if we have a direct colour index.
        const char *s = str.c_str();
        char *es = NULL;
        const int ci = static_cast<int>(strtol(s, &es, 10));
        if (s != (const char *) es && es && ci >= 0 && ci < 16)
            ret = ci;
    }
    return ((ret == 16) ? default_colour : ret);
}
// Returns -1 if unmatched else returns 0-15.

Replacement in crawl-ref/source/initfile.cc at line 3057 [15.2957258]
B:BD[169.6129] → [171.14917:14960]
```
               _str_to_tile_colour(field);
```
[169.6129]
[169.6171]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3062 [15.2957258]
B:BD[169.6250] → [171.14961:15004]
```
               _str_to_tile_colour(field);
```
[169.6250]
[179.6462]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3067 [15.2957258]
B:BD[179.6541] → [171.15005:15048]
```
               _str_to_tile_colour(field);
```
[179.6541]
[169.6292]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3072 [15.2957258]
B:BD[169.6373] → [180.11462:11505]
```
               _str_to_tile_colour(field);
```
[169.6373]
[180.11505]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3077 [15.2957258]
∅:D[180.11580] → [171.15049:15092]
B:BD[169.6373] → [171.15049:15092]
```
               _str_to_tile_colour(field);
```
[180.11580]
[169.6415]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3082 [15.2957258]
B:BD[169.6488] → [171.15093:15136]
```
               _str_to_tile_colour(field);
```
[169.6488]
[169.6530]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3087 [15.2957258]
B:BD[169.6607] → [171.15137:15180]
```
               _str_to_tile_colour(field);
```
[169.6607]
[169.6649]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3092 [15.2957258]
B:BD[169.6724] → [171.15181:15224]
```
               _str_to_tile_colour(field);
```
[169.6724]
[169.6766]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3097 [15.2957258]
B:BD[169.6839] → [171.15225:15268]
```
               _str_to_tile_colour(field);
```
[169.6839]
[169.6881]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3102 [15.2957258]
B:BD[169.6968] → [171.15269:15312]
```
               _str_to_tile_colour(field);
```
[169.6968]
[169.7010]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3107 [15.2957258]
B:BD[169.7083] → [171.15313:15356]
```
               _str_to_tile_colour(field);
```
[169.7083]
[169.7125]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3112 [15.2957258]
B:BD[169.7210] → [171.15357:15400]
```
               _str_to_tile_colour(field);
```
[169.7210]
[169.7252]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3117 [15.2957258]
B:BD[169.7333] → [171.15401:15444]
```
               _str_to_tile_colour(field);
```
[169.7333]
[169.7375]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3122 [15.2957258]
B:BD[169.7454] → [171.15445:15488]
```
               _str_to_tile_colour(field);
```
[169.7454]
[169.7496]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3127 [15.2957258]
B:BD[169.7569] → [171.15489:15532]
```
               _str_to_tile_colour(field);
```
[169.7569]
[169.7611]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3132 [15.2957258]
B:BD[169.7686] → [171.15533:15576]
```
               _str_to_tile_colour(field);
```
[169.7686]
[169.7728]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3137 [15.2957258]
B:BD[169.7801] → [171.15577:15620]
```
               _str_to_tile_colour(field);
```
[169.7801]
[169.7843]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3142 [15.2957258]
B:BD[169.7924] → [181.3953:3996]
```
               _str_to_tile_colour(field);
```
[169.7924]
[181.3996]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3147 [15.2957258]
∅:D[181.4116] → [171.15621:15664]
B:BD[169.7924] → [171.15621:15664]
```
               _str_to_tile_colour(field);
```
[181.4116]
[28.172504]
```
               str_to_tile_colour(field);
```
Replacement in crawl-ref/source/initfile.cc at line 3152 [15.2957258]
B:BD[28.172581] → [28.172581:172625]
```
                _str_to_tile_colour(field);
```
[28.172581]
[169.7966]
```
                str_to_tile_colour(field);
```
Insertion in crawl-ref/source/godabil.cc at line 9 [11.4086]
[11.4201]
[11.4201]
```
#include "colour.h"
#include "coord.h"
#include "coordit.h"
```
Insertion in crawl-ref/source/godabil.cc at line 25 [11.4086]
[11.4429]
[11.4429]
```
#include "random.h"
```
Insertion in crawl-ref/source/ghost.cc at line 14 [182.9890]
[138.34994]
[182.10098]
```
#include "colour.h"
```
Insertion in crawl-ref/source/ghost.cc at line 19 [182.9890]
[183.12596]
[182.10184]
```
#include "random.h"
```
Deletion in crawl-ref/source/ghost.cc at line 21 [182.9890]
B:BD[182.10205] → [182.10205:10224]
```
#include "stuff.h"
```
Insertion in crawl-ref/source/ghost.cc at line 25 [182.9890]
[184.2928]
[182.10262]
Replacement in crawl-ref/source/format.cc at line 8 [185.2166]
B:BD[185.2188] → [185.2188:2210]
```
#include "initfile.h"
```
[185.2188]
[185.2210]
```
#include "colour.h"
```
Insertion in crawl-ref/source/food.cc at line 43 [15.3043806]
[15.3044538]
[15.3044538]
```
#include "random.h"
```
Insertion in crawl-ref/source/files.cc at line 71 [15.3084589]
[15.3086124]
[19.432509]
```
#include "random.h"
```
Deletion in crawl-ref/source/externs.h at line 234 [15.3270163]
B:BD[15.3272144] → [15.3272144:3272264]
B:BD[15.3272264] → [101.6440:6462]
∅:D[101.6462] → [15.3272831:3272834]
∅:D[186.7706] → [15.3272831:3272834]
B:BD[15.3272831] → [15.3272831:3272834]
B:BD[15.3272835] → [15.3272835:3272836]
```
struct dice_def
{
    int         num;
    int         size;
    dice_def( int n = 0, int s = 0 ) : num(n), size(s) {}
    int roll() const;
};
```
Insertion in crawl-ref/source/exclude.cc at line 10 [13.3225]
[13.3351]
[13.3351]
```
#include "coord.h"
```
Insertion in crawl-ref/source/effects.cc at line 24 [15.3382105]
[187.481]
[188.3085]
```
#include "colour.h"
```
Insertion in crawl-ref/source/dungeon.cc at line 45 [15.3429798]
[15.3431217]
[189.6927]
```
#include "random.h"
```
Insertion in crawl-ref/source/directn.cc at line 27 [15.3697945]
[190.2728]
[191.182]
```
#include "colour.h"
```
Insertion in crawl-ref/source/directn.cc at line 29 [15.3697945]
[191.203]
[15.3698675]
```
#include "coord.h"
```
Replacement in crawl-ref/source/dgnevent.cc at line 10 [38.43722]
B:BD[38.43949] → [38.43949:43968]
```
#include "stuff.h"
```
[38.43949]
[192.5862]
```
#include "coord.h"
```
Insertion in crawl-ref/source/describe.cc at line 48 [15.3736416]
[15.3737493]
[15.3737514]
```
#include "random.h"
```
Insertion in crawl-ref/source/describe.cc at line 50 [15.3736416]
[15.3737536]
[15.3737536]
```
#include "rng.h"
```
Insertion in crawl-ref/source/delay.cc at line 17 [15.3963459]
[33.993477]
[193.2702]
```
#include "coordit.h"
```
Insertion in crawl-ref/source/delay.cc at line 39 [15.3963459]
[15.3963987]
[115.55555]
```
#include "random.h"
```
Insertion in crawl-ref/source/database.cc at line 24 [69.13932]
[194.2043]
[194.2043]
```
#include "random.h"
```

File addition: coordit.h (----------)

[108.24]

#ifndef COORDIT_H
#define COORDIT_H
#include "player.h"
class rectangle_iterator :
    public std::iterator<std::forward_iterator_tag, coord_def>
{
public:
    rectangle_iterator( const coord_def& corner1, const coord_def& corner2 );
    explicit rectangle_iterator( int x_border_dist, int y_border_dist = -1 );
    operator bool() const;
    coord_def operator *() const;
    const coord_def* operator->() const;
    rectangle_iterator& operator ++ ();
    rectangle_iterator operator ++ (int);
private:
    coord_def current, topleft, bottomright;
};
class radius_iterator : public std::iterator<std::bidirectional_iterator_tag,
                        coord_def>
{
public:
    radius_iterator( const coord_def& center, int radius,
                     bool roguelike_metric = true,
                     bool require_los = true,
                     bool exclude_center = false,
                     const env_show_grid* losgrid = NULL );
    bool done() const;
    void reset();
    operator bool() const { return !done(); }
    coord_def operator *() const;
    const coord_def* operator->() const;
    const radius_iterator& operator ++ ();
    const radius_iterator& operator -- ();
    radius_iterator operator ++ (int);
    radius_iterator operator -- (int);
private:
    void step();
    void step_back();
    bool on_valid_square() const;
    coord_def location, center;
    int radius;
    bool roguelike_metric, require_los, exclude_center;
    const env_show_grid* losgrid;
    bool iter_done;
};
class adjacent_iterator : public radius_iterator
{
public:
    explicit adjacent_iterator( const coord_def& pos = you.pos(),
                                bool _exclude_center = true ) :
        radius_iterator(pos, 1, true, false, _exclude_center) {}
};
#endif

File addition: coordit.cc (----------)

[108.24]

/*
 * File:     coordit.h
 * Summary:  Coordinate iterators.
 */
#include "AppHdr.h"
#include "coordit.h"
#include "coord.h"
#include "los.h"
rectangle_iterator::rectangle_iterator( const coord_def& corner1,
                                        const coord_def& corner2 )
{
    topleft.x = std::min(corner1.x, corner2.x);
    topleft.y = std::min(corner1.y, corner2.y); // not really necessary
    bottomright.x = std::max(corner1.x, corner2.x);
    bottomright.y = std::max(corner1.y, corner2.y);
    current = topleft;
}
rectangle_iterator::rectangle_iterator( int x_border_dist, int y_border_dist )
{
    if (y_border_dist < 0)
        y_border_dist = x_border_dist;
    topleft.set(x_border_dist, y_border_dist);
    bottomright.set(GXM - x_border_dist - 1, GYM - y_border_dist - 1);
    current = topleft;
}
rectangle_iterator::operator bool() const
{
    return (current.y <= bottomright.y);
}
coord_def rectangle_iterator::operator *() const
{
    return current;
}
const coord_def* rectangle_iterator::operator->() const
{
    return &current;
}
rectangle_iterator& rectangle_iterator::operator ++()
{
    if (current.x == bottomright.x)
    {
        current.x = topleft.x;
        current.y++;
    }
    else
    {
        current.x++;
    }
    return *this;
}
rectangle_iterator rectangle_iterator::operator++( int dummy )
{
    const rectangle_iterator copy = *this;
    ++(*this);
    return (copy);
}
radius_iterator::radius_iterator(const coord_def& _center, int _radius,
                                 bool _roguelike_metric, bool _require_los,
                                 bool _exclude_center,
                                 const env_show_grid* _losgrid)
    : center(_center), radius(_radius), roguelike_metric(_roguelike_metric),
      require_los(_require_los), exclude_center(_exclude_center),
      losgrid(_losgrid), iter_done(false)
{
    reset();
}
void radius_iterator::reset()
{
    iter_done = false;
    location.x = center.x - radius;
    location.y = center.y - radius;
    if ( !this->on_valid_square() )
        ++(*this);
}
bool radius_iterator::done() const
{
    return iter_done;
}
coord_def radius_iterator::operator *() const
{
    return location;
}
const coord_def* radius_iterator::operator->() const
{
    return &location;
}
void radius_iterator::step()
{
    const int minx = std::max(X_BOUND_1+1, center.x - radius);
    const int maxx = std::min(X_BOUND_2-1, center.x + radius);
    const int maxy = std::min(Y_BOUND_2-1, center.y + radius);
    // Sweep L-R, U-D
    location.x++;
    if (location.x > maxx)
    {
        location.x = minx;
        location.y++;
        if (location.y > maxy)
            iter_done = true;
    }
}
void radius_iterator::step_back()
{
    const int minx = std::max(X_BOUND_1+1, center.x - radius);
    const int maxx = std::min(X_BOUND_2-1, center.x + radius);
    const int miny = std::max(Y_BOUND_1+1, center.y - radius);
    location.x--;
    if (location.x < minx)
    {
        location.x = maxx;
        location.y--;
        if (location.y < miny)
            iter_done = true;
    }
}
bool radius_iterator::on_valid_square() const
{
    if (!in_bounds(location))
        return (false);
    if (!roguelike_metric && (location - center).abs() > radius*radius)
        return (false);
    if (require_los)
    {
        if (!losgrid && !see_cell(location))
            return (false);
        if (losgrid && !see_cell(*losgrid, center, location))
            return (false);
    }
    if (exclude_center && location == center)
        return (false);
    return (true);
}
const radius_iterator& radius_iterator::operator++()
{
    do
        this->step();
    while (!this->done() && !this->on_valid_square());
    return (*this);
}
const radius_iterator& radius_iterator::operator--()
{
    do
        this->step_back();
    while (!this->done() && !this->on_valid_square());
    return (*this);
}
radius_iterator radius_iterator::operator++(int dummy)
{
    const radius_iterator copy = *this;
    ++(*this);
    return (copy);
}
radius_iterator radius_iterator::operator--(int dummy)
{
    const radius_iterator copy = *this;
    --(*this);
    return (copy);
}

File addition: coord.h (----------)

[108.24]

#ifndef COORD_H
#define COORD_H
bool in_bounds_x(int x);
bool in_bounds_y(int y);
bool in_bounds(int x, int y);
bool map_bounds_x(int x);
bool map_bounds_y(int y);
bool map_bounds(int x, int y);
coord_def random_in_bounds();
inline bool in_bounds(const coord_def &p)
{
    return in_bounds(p.x, p.y);
}
inline bool map_bounds(const coord_def &p)
{
    return map_bounds(p.x, p.y);
}
// Determines if the coordinate is within bounds of an LOS array.
inline bool show_bounds(const coord_def &p)
{
    return (p.x >= 0 && p.x < ENV_SHOW_DIAMETER
            && p.y >= 0 && p.y < ENV_SHOW_DIAMETER);
}
int grid_distance( const coord_def& p1, const coord_def& p2 );
int grid_distance( int x, int y, int x2, int y2 );
int distance( const coord_def& p1, const coord_def& p2 );
int distance( int x, int y, int x2, int y2);
bool adjacent( const coord_def& p1, const coord_def& p2 );
#endif

File addition: coord.cc (----------)

[108.24]

#include "AppHdr.h"
#include "coord.h"
#include "directn.h"
#include "random.h"
#include "state.h"
//////////////////////////////////////////////////////////////////////////
// coord_def
int coord_def::distance_from(const coord_def &other) const
{
    return (grid_distance(*this, other));
}
int grid_distance( const coord_def& p1, const coord_def& p2 )
{
    return grid_distance(p1.x, p1.y, p2.x, p2.y);
}
// More accurate than distance() given the actual movement geometry -- bwr
int grid_distance( int x, int y, int x2, int y2 )
{
    const int dx = abs( x - x2 );
    const int dy = abs( y - y2 );
    // returns distance in terms of moves:
    return ((dx > dy) ? dx : dy);
}
int distance( const coord_def& p1, const coord_def& p2 )
{
    return distance(p1.x, p1.y, p2.x, p2.y);
}
int distance( int x, int y, int x2, int y2 )
{
    //jmf: now accurate, but remember to only compare vs. pre-squared distances
    //     thus, next to == (distance(m1.x,m1.y, m2.x,m2.y) <= 2)
    const int dx = x - x2;
    const int dy = y - y2;
    return ((dx * dx) + (dy * dy));
}
bool adjacent( const coord_def& p1, const coord_def& p2 )
{
    return grid_distance(p1, p2) <= 1;
}
bool in_bounds_x(int x)
{
    return (x > X_BOUND_1 && x < X_BOUND_2);
}
bool in_bounds_y(int y)
{
    return (y > Y_BOUND_1 && y < Y_BOUND_2);
}
// Returns true if inside the area the player can move and dig (ie exclusive).
bool in_bounds(int x, int y)
{
    return (in_bounds_x(x) && in_bounds_y(y));
}
bool map_bounds_x(int x)
{
    return (x >= X_BOUND_1 && x <= X_BOUND_2);
}
bool map_bounds_y(int y)
{
    return (y >= Y_BOUND_1 && y <= Y_BOUND_2);
}
// Returns true if inside the area the player can map (ie inclusive).
// Note that terrain features should be in_bounds() leaving an outer
// ring of rock to frame the level.
bool map_bounds(int x, int y)
{
    return (map_bounds_x(x) && map_bounds_y(y));
}
coord_def random_in_bounds()
{
    if (crawl_state.arena)
    {
        const coord_def &ul = crawl_view.glos1; // Upper left
        const coord_def &lr = crawl_view.glos2; // Lower right
        return coord_def(random_range(ul.x, lr.x - 1),
                         random_range(ul.y, lr.y - 1));
    }
    else
        return coord_def(random_range(MAPGEN_BORDER, GXM - MAPGEN_BORDER - 1),
                         random_range(MAPGEN_BORDER, GYM - MAPGEN_BORDER - 1));
}

Deletion in crawl-ref/source/command.cc at line 17 [15.4082507]
B:BD[15.4083068] → [106.21015:21036]
```
#include "species.h"
```
Insertion in crawl-ref/source/command.cc at line 22 [15.4082507]
[195.347]
[196.1739]
```
#include "colour.h"
```
Insertion in crawl-ref/source/command.cc at line 44 [15.4082507]
[197.18150]
[198.2766]
```
#include "species.h"
```

File addition: colour.h (----------)

[108.24]

#ifndef COLOUR_H
#define COLOUR_H
// various elemental colour schemes... used for abstracting random
// short lists. When adding colours, please also add their names in
// str_to_colour!
enum element_type
{
    ETC_FIRE = 32,      // fiery colours (must be first and > highest colour)
    ETC_ICE,            // icy colours
    ETC_EARTH,          // earthy colours
    ETC_ELECTRICITY,    // electrical side of air
    ETC_AIR,            // non-electric and general air magic
    ETC_POISON,         // used only for venom mage and stalker stuff
    ETC_WATER,          // used only for the elemental
    ETC_MAGIC,          // general magical effect
    ETC_MUTAGENIC,      // transmute, poly, radiation effects
    ETC_WARP,           // teleportation and anything similar
    ETC_ENCHANT,        // magical enhancements
    ETC_HEAL,           // holy healing (not necromantic stuff)
    ETC_HOLY,           // general "good" god effects
    ETC_DARK,           // darkness
    ETC_DEATH,          // currently only assassin (and equal to ETC_NECRO)
    ETC_NECRO,          // necromancy stuff
    ETC_UNHOLY,         // demonology stuff
    ETC_VEHUMET,        // vehumet's oddball colours
    ETC_BEOGH,          // Beogh altar colours
    ETC_CRYSTAL,        // colours of crystal
    ETC_BLOOD,          // colours of blood
    ETC_SMOKE,          // colours of smoke
    ETC_SLIME,          // colours of slime
    ETC_JEWEL,          // colourful
    ETC_ELVEN,          // used for colouring elf fabric items
    ETC_DWARVEN,        // used for colouring dwarf fabric items
    ETC_ORCISH,         // used for colouring orc fabric items
    ETC_GILA,           // gila monster colours
    ETC_FLOOR,          // colour of the area's floor
    ETC_ROCK,           // colour of the area's rock
    ETC_STONE,          // colour of the area's stone
    ETC_MIST,           // colour of mist
    ETC_SHIMMER_BLUE,   // shimmering colours of blue.
    ETC_DECAY,          // colour of decay/swamp
    ETC_SILVER,         // colour of silver
    ETC_GOLD,           // colour of gold
    ETC_IRON,           // colour of iron
    ETC_BONE,           // colour of bone
    ETC_RANDOM          // any colour (except BLACK)
};
int str_to_colour(const std::string &str, int default_colour = -1,
                  bool accept_number = true);
const std::string colour_to_str(unsigned char colour);
unsigned int str_to_tile_colour(std::string colour);
unsigned char random_colour();
unsigned char random_uncommon_colour();
unsigned char make_low_colour(unsigned char colour);
unsigned char make_high_colour(unsigned char colour);
bool is_element_colour(int col);
int  element_colour(int element, bool no_random = false);
#endif

File addition: colour.cc (----------)

[108.24]

#include "AppHdr.h"
#include "colour.h"
#include "env.h"
#include "player.h"
#include "random.h"
unsigned char random_colour(void)
{
    return (1 + random2(15));
}
unsigned char random_uncommon_colour()
{
    unsigned char result;
    do
        result = random_colour();
    while (result == LIGHTCYAN || result == CYAN || result == BROWN);
    return (result);
}
unsigned char make_low_colour(unsigned char colour)
{
    if (colour >= 8 && colour <= 15)
        return (colour - 8);
    return (colour);
}
unsigned char make_high_colour(unsigned char colour)
{
    if (colour <= 7)
        return (colour + 8);
    return (colour);
}
// returns if a colour is one of the special element colours (ie not regular)
bool is_element_colour( int col )
{
    // stripping any COLFLAGS (just in case)
    return ((col & 0x007f) >= ETC_FIRE);
}
int element_colour( int element, bool no_random )
{
    // Doing this so that we don't have to do recursion here at all
    // (these were the only cases which had possible double evaluation):
    if (element == ETC_FLOOR)
        element = env.floor_colour;
    else if (element == ETC_ROCK)
        element = env.rock_colour;
    // pass regular colours through for safety.
    if (!is_element_colour( element ))
        return (element);
    int ret = BLACK;
    // Setting no_random to true will get the first colour in the cases
    // below.  This is potentially useful for calls to this function
    // which might want a consistent result.
    int tmp_rand = (no_random ? 0 : random2(120));
    switch (element & 0x007f)   // strip COLFLAGs just in case
    {
    case ETC_FIRE:
        ret = (tmp_rand < 40) ? RED :
              (tmp_rand < 80) ? YELLOW
                              : LIGHTRED;
        break;
    case ETC_ICE:
        ret = (tmp_rand < 40) ? LIGHTBLUE :
              (tmp_rand < 80) ? BLUE
                              : WHITE;
        break;
    case ETC_EARTH:
        ret = (tmp_rand < 60) ? BROWN : LIGHTRED;
        break;
    case ETC_AIR:
        ret = (tmp_rand < 60) ? LIGHTGREY : WHITE;
        break;
    case ETC_ELECTRICITY:
        ret = (tmp_rand < 40) ? LIGHTCYAN :
              (tmp_rand < 80) ? LIGHTBLUE
                              : CYAN;
        break;
    case ETC_POISON:
        ret = (tmp_rand < 60) ? LIGHTGREEN : GREEN;
        break;
    case ETC_WATER:
        ret = (tmp_rand < 60) ? BLUE : CYAN;
        break;
    case ETC_MAGIC:
        ret = (tmp_rand < 30) ? LIGHTMAGENTA :
              (tmp_rand < 60) ? LIGHTBLUE :
              (tmp_rand < 90) ? MAGENTA
                              : BLUE;
        break;
    case ETC_MUTAGENIC:
    case ETC_WARP:
        ret = (tmp_rand < 60) ? LIGHTMAGENTA : MAGENTA;
        break;
    case ETC_ENCHANT:
        ret = (tmp_rand < 60) ? LIGHTBLUE : BLUE;
        break;
    case ETC_HEAL:
        ret = (tmp_rand < 60) ? LIGHTBLUE : YELLOW;
        break;
    case ETC_BLOOD:
        ret = (tmp_rand < 60) ? RED : DARKGREY;
        break;
    case ETC_DEATH:      // assassin
    case ETC_NECRO:      // necromancer
        ret = (tmp_rand < 80) ? DARKGREY : MAGENTA;
        break;
    case ETC_UNHOLY:     // ie demonology
        ret = (tmp_rand < 80) ? DARKGREY : RED;
        break;
    case ETC_DARK:
        ret = (tmp_rand < 80) ? DARKGREY : LIGHTGREY;
        break;
    case ETC_HOLY:
        ret = (tmp_rand < 60) ? YELLOW : WHITE;
        break;
    case ETC_VEHUMET:
        ret = (tmp_rand < 40) ? LIGHTRED :
              (tmp_rand < 80) ? LIGHTMAGENTA
                              : LIGHTBLUE;
        break;
    case ETC_BEOGH:
        ret = (tmp_rand < 60) ? LIGHTRED // plain Orc colour
                              : BROWN;   // Orcish mines wall/idol colour
        break;
    case ETC_CRYSTAL:
        ret = (tmp_rand < 40) ? LIGHTGREY :
              (tmp_rand < 80) ? GREEN
                              : LIGHTRED;
        break;
    case ETC_SLIME:
        ret = (tmp_rand < 40) ? GREEN :
              (tmp_rand < 80) ? BROWN
                              : LIGHTGREEN;
        break;
    case ETC_SMOKE:
        ret = (tmp_rand < 30) ? LIGHTGREY :
              (tmp_rand < 60) ? DARKGREY :
              (tmp_rand < 90) ? LIGHTBLUE
                              : MAGENTA;
        break;
    case ETC_JEWEL:
        ret = (tmp_rand <  12) ? WHITE :
              (tmp_rand <  24) ? YELLOW :
              (tmp_rand <  36) ? LIGHTMAGENTA :
              (tmp_rand <  48) ? LIGHTRED :
              (tmp_rand <  60) ? LIGHTGREEN :
              (tmp_rand <  72) ? LIGHTBLUE :
              (tmp_rand <  84) ? MAGENTA :
              (tmp_rand <  96) ? RED :
              (tmp_rand < 108) ? GREEN
                               : BLUE;
        break;
    case ETC_ELVEN:
        ret = (tmp_rand <  40) ? LIGHTGREEN :
              (tmp_rand <  80) ? GREEN :
              (tmp_rand < 100) ? LIGHTBLUE
                               : BLUE;
        break;
    case ETC_DWARVEN:
        ret = (tmp_rand <  40) ? BROWN :
              (tmp_rand <  80) ? LIGHTRED :
              (tmp_rand < 100) ? LIGHTGREY
                               : CYAN;
        break;
    case ETC_ORCISH:
        ret = (tmp_rand <  40) ? DARKGREY :
              (tmp_rand <  80) ? RED :
              (tmp_rand < 100) ? BROWN
                               : MAGENTA;
        break;
    case ETC_GILA:
        ret = (tmp_rand <  30) ? LIGHTMAGENTA :
              (tmp_rand <  60) ? MAGENTA :
              (tmp_rand <  90) ? YELLOW :
              (tmp_rand < 105) ? LIGHTRED
                               : RED;
        break;
    case ETC_STONE:
        if (player_in_branch( BRANCH_HALL_OF_ZOT ))
            ret = env.rock_colour;
        else
            ret = LIGHTGREY;
        break;
    case ETC_MIST:
        ret = tmp_rand < 100? CYAN : BLUE;
        break;
    case ETC_SHIMMER_BLUE:
        ret = random_choose_weighted(80, BLUE, 20, LIGHTBLUE, 5, CYAN, 0);
        break;
    case ETC_DECAY:
        ret = (tmp_rand < 60) ? BROWN : GREEN;
        break;
    case ETC_SILVER:
        ret = (tmp_rand < 90) ? LIGHTGREY : WHITE;
        break;
    case ETC_GOLD:
        ret = (tmp_rand < 60) ? YELLOW : BROWN;
        break;
    case ETC_IRON:
        ret = (tmp_rand < 40) ? CYAN :
              (tmp_rand < 80) ? LIGHTGREY :
                                DARKGREY;
        break;
    case ETC_BONE:
        ret = (tmp_rand < 90) ? WHITE : LIGHTGREY;
        break;
    case ETC_RANDOM:
        ret = 1 + random2(15);              // always random
        break;
    case ETC_FLOOR: // should already be handled
    case ETC_ROCK:  // should already be handled
    default:
        break;
    }
    ASSERT( !is_element_colour( ret ) );
    return ((ret == BLACK) ? GREEN : ret);
}
#ifdef USE_TILE
static std::string tile_cols[24] =
{
    "black", "darkgrey", "grey", "lightgrey", "white",
    "blue", "lightblue", "darkblue",
    "green", "lightgreen", "darkgreen",
    "cyan", "lightcyan", "darkcyan",
    "red", "lightred", "darkred",
    "magenta", "lightmagenta", "darkmagenta",
    "yellow", "lightyellow", "darkyellow", "brown"
};
unsigned int str_to_tile_colour(std::string colour)
{
    if (colour.empty())
        return (0);
    lowercase(colour);
    if (colour == "darkgray")
        colour = "darkgrey";
    else if (colour == "gray")
        colour = "grey";
    else if (colour == "lightgray")
        colour = "lightgrey";
    for (unsigned int i = 0; i < 24; i++)
    {
         if (tile_cols[i] == colour)
             return (i);
    }
    return (0);
}
#endif
const std::string cols[16] =
{
    "black", "blue", "green", "cyan", "red", "magenta", "brown",
    "lightgrey", "darkgrey", "lightblue", "lightgreen", "lightcyan",
    "lightred", "lightmagenta", "yellow", "white"
};
const std::string colour_to_str(unsigned char colour)
{
    if ( colour >= 16 )
        return "lightgrey";
    else
        return cols[colour];
}
// Returns -1 if unmatched else returns 0-15.
int str_to_colour( const std::string &str, int default_colour,
                   bool accept_number )
{
    int ret;
    static const std::string element_cols[] =
    {
        "fire", "ice", "earth", "electricity", "air", "poison",
        "water", "magic", "mutagenic", "warp", "enchant", "heal",
        "holy", "dark", "death", "necro", "unholy", "vehumet",
        "beogh", "crystal", "blood", "smoke", "slime", "jewel",
        "elven", "dwarven", "orcish", "gila", "floor", "rock",
        "stone", "mist", "shimmer_blue", "decay", "silver", "gold",
        "iron", "bone", "random"
    };
    ASSERT(ARRAYSZ(element_cols) == (ETC_RANDOM - ETC_FIRE) + 1);
    for (ret = 0; ret < 16; ++ret)
    {
        if (str == cols[ret])
            break;
    }
    // Check for alternate spellings.
    if (ret == 16)
    {
        if (str == "lightgray")
            ret = 7;
        else if (str == "darkgray")
            ret = 8;
    }
    if (ret == 16)
    {
        // Maybe we have an element colour attribute.
        for (unsigned i = 0; i < sizeof(element_cols) / sizeof(*element_cols);
                ++i)
        {
            if (str == element_cols[i])
            {
                // Ugh.
                ret = element_type(ETC_FIRE + i);
                break;
            }
        }
    }
    if (ret == 16 && accept_number)
    {
        // Check if we have a direct colour index.
        const char *s = str.c_str();
        char *es = NULL;
        const int ci = static_cast<int>(strtol(s, &es, 10));
        if (s != (const char *) es && es && ci >= 0 && ci < 16)
            ret = ci;
    }
    return ((ret == 16) ? default_colour : ret);
}

Insertion in crawl-ref/source/cloud.cc at line 17 [15.4095717]
[15.4096041]
[199.2303]
```
#include "coord.h"
```
Insertion in crawl-ref/source/cloud.cc at line 21 [15.4095717]
[190.3089]
[200.3769]
```
#include "random.h"
```
Insertion in crawl-ref/source/beam.h at line 13 [15.4124541]
[15.4124822]
[17.102706]
```
#include "random.h"
```
Deletion in crawl-ref/source/beam.h at line 278 [15.4124541]
∅:D[17.108448] → [15.4124823:4124876]
B:BD[15.4124823] → [15.4124823:4124876]
```
dice_def calc_dice( int num_dice, int max_damage );
```
Insertion in crawl-ref/source/beam.cc at line 29 [15.4128068]
[15.4128970]
[201.444]
```
#include "colour.h"
```

Deletion in crawl-ref/source/beam.cc at line 290 [15.4128068]

B:BD[202.30465] → [202.30465:30468]

∅:D[202.30468] → [15.4132998:4133293]

B:BD[15.4132998] → [15.4132998:4133293]

B:BD[15.4133293] → [203.12893:12950]

∅:D[203.12950] → [15.4133351:4133412]

B:BD[15.4133351] → [15.4133351:4133412]

B:BD[15.4133412] → [204.12305:12348]

B:BD[204.12348] → [205.14622:14690]

∅:D[205.14690] → [15.4133521:4133546]

B:BD[15.4133521] → [15.4133521:4133546]

}
dice_def calc_dice( int num_dice, int max_damage )
{
    dice_def    ret( num_dice, 0 );
    if (num_dice <= 1)
    {
        ret.num  = 1;
        ret.size = max_damage;
    }
    else if (max_damage <= num_dice)
    {
        ret.num  = max_damage;
        ret.size = 1;
    }
    else
    {
        // Divide the damage among the dice, and add one
        // occasionally to make up for the fractions. -- bwr
        ret.size  = max_damage / num_dice;
        ret.size += x_chance_in_y(max_damage % num_dice, num_dice);
    }
    return (ret);

Deletion in crawl-ref/source/artefact.cc at line 18 [15.893152]
B:BD[15.893622] → [106.21057:21078]
```
#include "species.h"
```
Insertion in crawl-ref/source/artefact.cc at line 19 [15.893152]
[206.3020]
[206.3020]
```
#include "colour.h"
```
Insertion in crawl-ref/source/artefact.cc at line 27 [15.893152]
[206.3082]
[206.3082]
```
#include "random.h"
```
Insertion in crawl-ref/source/artefact.cc at line 29 [15.893152]
[206.3104]
[207.4921]
```
#include "species.h"
```
Insertion in crawl-ref/source/arena.cc at line 12 [208.10815]
[208.10916]
[209.4216]
```
#include "colour.h"
```
Insertion in crawl-ref/source/acr.cc at line 97 [15.4397395]
[109.12138]
[15.4400624]
```
#include "random.h"
```
Deletion in crawl-ref/source/abyss.cc at line 13 [15.4482606]
∅:D[76.18199] → [15.4482974:4482996]
B:BD[15.4482974] → [15.4482974:4482996]
```
#include "externs.h"
```
Insertion in crawl-ref/source/abyss.cc at line 16 [15.4482606]
[15.4483016]
[139.131154]
```
#include "colour.h"
```
Insertion in crawl-ref/source/abyss.cc at line 30 [15.4482606]
[143.57015]
[210.3152]
```
#include "random.h"
```

Splitting up stuff.cc.

Dependencies

In channels

Change contents

Deletion in crawl-ref/source/view.h at line 12 [15.13254]

Insertion in crawl-ref/source/view.cc at line 28 [15.16817]

Insertion in crawl-ref/source/view.cc at line 55 [15.16817]

Insertion in crawl-ref/source/tutorial.cc at line 21 [24.5936]

Insertion in crawl-ref/source/tutorial.cc at line 45 [24.5936]

Insertion in crawl-ref/source/travel.cc at line 12 [19.39949]

Insertion in crawl-ref/source/traps.cc at line 17 [17.5308]

Insertion in crawl-ref/source/transfor.cc at line 25 [15.143977]

Insertion in crawl-ref/source/tilesdl.cc at line 7 [28.19415]

Insertion in crawl-ref/source/tilereg.cc at line 13 [28.54399]

Insertion in crawl-ref/source/tilepick.cc at line 12 [31.96318]

Insertion in crawl-ref/source/terrain.cc at line 30 [17.26938]

Deletion in crawl-ref/source/stuff.h at line 19 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 20 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 40 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 42 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 48 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 72 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 76 [15.217090]

Deletion in crawl-ref/source/stuff.h at line 95 [15.217090]

Insertion in crawl-ref/source/stuff.cc at line 11 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 35 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 36 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 55 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 115 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 117 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 280 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 282 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 507 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 512 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 788 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 797 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 814 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 908 [15.224557]

Deletion in crawl-ref/source/stuff.cc at line 932 [15.224557]

Insertion in crawl-ref/source/stash.cc at line 14 [19.147324]

Insertion in crawl-ref/source/spl-util.cc at line 22 [15.245665]

Insertion in crawl-ref/source/spl-mis.cc at line 15 [103.461]

Insertion in crawl-ref/source/spl-cast.cc at line 17 [15.293070]

Insertion in crawl-ref/source/spells1.cc at line 23 [15.616635]

Replacement in crawl-ref/source/species.cc at line 5 [106.785]

Insertion in crawl-ref/source/skills.cc at line 21 [15.745542]

Deletion in crawl-ref/source/skills.cc at line 24 [15.745542]

File addition: rng.h (----------)

File addition: rng.cc (----------)

File addition: random.h (----------)

File addition: random.cc (----------)

Insertion in crawl-ref/source/player.cc at line 27 [15.962854]

Insertion in crawl-ref/source/player.cc at line 52 [15.962854]

Insertion in crawl-ref/source/overmap.cc at line 23 [15.1070017]

Insertion in crawl-ref/source/output.cc at line 24 [15.1088282]

Insertion in crawl-ref/source/ouch.cc at line 58 [15.1104358]

Replacement in crawl-ref/source/ng-init.cc at line 15 [14.2971]

Insertion in crawl-ref/source/newgame.cc at line 55 [15.1132300]

Insertion in crawl-ref/source/mutation.cc at line 41 [15.1263003]

Deletion in crawl-ref/source/mutation.cc at line 43 [15.1263003]

Replacement in crawl-ref/source/mtransit.cc at line 18 [117.8445]

Insertion in crawl-ref/source/mstuff2.cc at line 22 [15.1340842]

Insertion in crawl-ref/source/monstuff.cc at line 25 [15.1396662]

Insertion in crawl-ref/source/monplace.h at line 11 [15.1638277]

Insertion in crawl-ref/source/monplace.cc at line 26 [15.1641732]

Insertion in crawl-ref/source/mon-util.cc at line 29 [15.1699344]

Insertion in crawl-ref/source/mon-util.cc at line 49 [15.1699344]

Insertion in crawl-ref/source/misc.cc at line 65 [15.1933596]

Replacement in crawl-ref/source/mgrow.cc at line 13 [126.2647]

Insertion in crawl-ref/source/message.cc at line 23 [15.1993826]

Insertion in crawl-ref/source/message.cc at line 31 [15.1993826]

Insertion in crawl-ref/source/menu.cc at line 15 [19.261322]

Insertion in crawl-ref/source/menu.cc at line 20 [19.261322]

Deletion in crawl-ref/source/menu.cc at line 24 [19.261322]

Deletion in crawl-ref/source/menu.cc at line 28 [19.261322]

Insertion in crawl-ref/source/maps.cc at line 26 [15.2007666]

Deletion in crawl-ref/source/maps.cc at line 28 [15.2007666]

Insertion in crawl-ref/source/mapdef.h at line 18 [33.591249]

Insertion in crawl-ref/source/mapdef.cc at line 18 [33.594797]

Insertion in crawl-ref/source/mapdef.cc at line 36 [33.594797]