fiddlerwoaroof/crawl - Change 6FBAIIDQLTXNSPYEEDV5ISD24S5F7PX2JOWEMXMS4LE53RC6T6EAC

New slot-based demonspawn generator.

This generator divides facets into body, awesome, great, and good ranks and assigns a fixed number of each.

Created by Stefan O'Rear on October 25, 2009

6FBAIIDQLTXNSPYEEDV5ISD24S5F7PX2JOWEMXMS4LE53RC6T6EAC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/mutation.cc at line 2531 [4.1263003]
[3.3788]
[3.3788]
```
static const mutation_type _all_scales[] = {
    MUT_SHAGGY_FUR,
```

Insertion in crawl-ref/source/mutation.cc at line 2535 [4.1263003]

[3.3789]

[5.13015]

    MUT_BONEY_PLATES,      MUT_GREEN_SCALES,    MUT_BLACK_SCALES,
    MUT_GREY_SCALES,       MUT_RED_SCALES,      MUT_NACREOUS_SCALES,
    MUT_GREY2_SCALES,      MUT_METALLIC_SCALES, MUT_BLACK2_SCALES,
    MUT_WHITE_SCALES,      MUT_YELLOW_SCALES,   MUT_BROWN_SCALES,
    MUT_BLUE_SCALES,       MUT_PURPLE_SCALES,   MUT_SPECKLED_SCALES,
    MUT_ORANGE_SCALES,     MUT_INDIGO_SCALES,   MUT_RED2_SCALES,
    MUT_IRIDESCENT_SCALES, MUT_PATTERNED_SCALES
};
static int _is_covering(mutation_type mut)
{
    for (unsigned i = 0; i < ARRAYSZ(_all_scales); ++i)
        if (_all_scales[i] == mut)
            return 1;
    return 0;
}

Deletion in crawl-ref/source/mutation.cc at line 2563 [4.1263003]
B:BD[6.2641] → [5.13043:13105]
```
    const mutation_type scales[] = {
        MUT_SHAGGY_FUR,
```

Deletion in crawl-ref/source/mutation.cc at line 2564 [4.1263003]

B:BD[4.1319633] → [5.13106:13591]

        MUT_BONEY_PLATES,      MUT_GREEN_SCALES,    MUT_BLACK_SCALES,
        MUT_GREY_SCALES,       MUT_RED_SCALES,      MUT_NACREOUS_SCALES,
        MUT_GREY2_SCALES,      MUT_METALLIC_SCALES, MUT_BLACK2_SCALES,
        MUT_WHITE_SCALES,      MUT_YELLOW_SCALES,   MUT_BROWN_SCALES,
        MUT_BLUE_SCALES,       MUT_PURPLE_SCALES,   MUT_SPECKLED_SCALES,
        MUT_ORANGE_SCALES,     MUT_INDIGO_SCALES,   MUT_RED2_SCALES,
        MUT_IRIDESCENT_SCALES, MUT_PATTERNED_SCALES
    };

Replacement in crawl-ref/source/mutation.cc at line 2565 [4.1263003]

B:BD[5.13592] → [5.13592:13687]

    for (unsigned i = 0; i < ARRAYSZ(scales); ++i)
        covered += you.mutation[scales[i]];

[5.13592]

[4.1320636]

    for (unsigned i = 0; i < ARRAYSZ(_all_scales); ++i)
        covered += you.mutation[_all_scales[i]];

Replacement in crawl-ref/source/mutation.cc at line 2657 [4.1263003]

B:BD[7.3433] → [8.3837:3941]

static mutation_type _demonspawn(FixedVector<int, NUM_MUTATIONS>& muts, int& powers,
        int level)

[7.3433]

[4.1321720]

void roll_demonspawn_mutations()

Replacement in crawl-ref/source/mutation.cc at line 2659 [4.1263003]

B:BD[4.1321722] → [9.2858:2900]

∅:D[5.13706] → [4.1321762:1321784]

B:BD[4.1321762] → [4.1321762:1321784]

B:BD[4.1321784] → [8.3942:3956]

∅:D[10.2683] → [4.1321829:1321830]

∅:D[8.3956] → [4.1321829:1321830]

∅:D[5.13748] → [4.1321829:1321830]

B:BD[4.1321829] → [4.1321829:1321830]

B:BD[11.3176] → [11.3176:3387]

B:BD[11.3387] → [12.2795:2865]

∅:D[12.2865] → [11.3457:3495]

∅:D[13.2866] → [11.3457:3495]

B:BD[11.3457] → [11.3457:3495]

B:BD[11.3495] → [12.2866:2867]

∅:D[12.2867] → [11.3496:3894]

∅:D[13.2874] → [11.3496:3894]

B:BD[11.3496] → [11.3496:3894]

B:BD[11.3894] → [8.3957:3985]

∅:D[8.3985] → [12.2905:2915]

B:BD[12.2905] → [12.2905:2915]

∅:D[13.2911] → [11.3941:3963]

∅:D[12.2915] → [11.3941:3963]

B:BD[11.3941] → [11.3941:3963]

B:BD[11.3963] → [12.2916:2926]

∅:D[12.2926] → [11.3973:3996]

B:BD[11.3973] → [11.3973:3996]

B:BD[11.3996] → [8.3986:4043]

∅:D[8.4043] → [11.4062:4109]

B:BD[11.4062] → [11.4062:4109]

    mutation_type whichm = NUM_MUTATIONS;
    int counter = 0;
    powers++;
    // A demonspawn logically has six mutation slots, like [cold res,
    // negative res, teleport, black scales, mapping, repulsion field].
    // They all start at 0 levels.  For a smooth power-up, when this
    // function is called we increase one mutation slot (which is not
    // already at 3) by 1 level only.
    // Look through the existing demon powers to find the slot.  Note
    // that this will not find powers at level 0; if a new power needs
    // to be given, we will fall off the loop.
    int increasable_muts_seen = 0;
    int muts_seen = 0;
    mutation_type mut_to_increase = NUM_MUTATIONS;
    for (int i = 0; i < NUM_MUTATIONS; ++i)
    {
        whichm = static_cast<mutation_type>(i);
        if (! muts[whichm])
        {
            continue;
        }
        ++muts_seen;
        if (muts[whichm] < mutation_defs[whichm].levels)
        {
            ++increasable_muts_seen;

[4.1321722]

[11.4109]

    // First try for a body mutation; every DS has exactly one of these, as
    // they result in the loss or crippling of one slot, and we don't want to
    // deal with the balance issues of a variable-slot race.
    static const mutation_type body_muts[] = {
        MUT_CLAWS, MUT_HORNS
    };

Replacement in crawl-ref/source/mutation.cc at line 2666 [4.1263003]

B:BD[11.4110] → [11.4110:4164]

B:BD[11.4164] → [12.2927:2941]

∅:D[12.2941] → [11.4178:4220]

B:BD[11.4178] → [11.4178:4220]

B:BD[11.4220] → [12.2942:2956]

∅:D[12.2956] → [11.4234:4250]

B:BD[11.4234] → [11.4234:4250]

            if (one_chance_in(increasable_muts_seen))
            {
                mut_to_increase = whichm;
            }
        }
    }

[11.4110]

[4.1321951]

    // "Awesome" mutations are character defining; they have a major effect
    // on strategy in at least one branch.
    static const mutation_type awesome_muts[] = {
        MUT_HEAT_RESISTANCE, MUT_FAST, MUT_TELEPORT_AT_WILL, MUT_MAPPING,
        MUT_ROBUST, MUT_NEGATIVE_ENERGY_RESISTANCE, MUT_BLACK_SCALES,
        MUT_METALLIC_SCALES, MUT_RED2_SCALES
    };

Replacement in crawl-ref/source/mutation.cc at line 2674 [4.1263003]

B:BD[4.1321952] → [12.2957:3029]

∅:D[13.2985] → [11.4323:4400]

∅:D[12.3029] → [11.4323:4400]

B:BD[11.4323] → [11.4323:4400]

    // If you have less than 6 mutations, add chances to gain a new one
    if (muts_seen < 6)
    {
        int chances_to_get_new = 6 - muts_seen;

[4.1321952]

[11.4400]

    // "Great" mutations define strategy in common encounters, but not
    // universal.
    static const mutation_type great_muts[] = {
        MUT_REGENERATION, MUT_GREEN_SCALES, MUT_BLACK_SCALES,
        MUT_REPULSION_FIELD, MUT_MAGIC_RESISTANCE, MUT_BREATHE_FLAMES,
        MUT_NACREOUS_SCALES, MUT_GREY2_SCALES, MUT_BLACK2_SCALES,
        MUT_WHITE_SCALES, MUT_YELLOW_SCALES, MUT_BROWN_SCALES,
        MUT_PURPLE_SCALES, MUT_INDIGO_SCALES, MUT_COLD_RESISTANCE
    };

Replacement in crawl-ref/source/mutation.cc at line 2684 [4.1263003]

B:BD[11.4401] → [11.4401:4454]

        increasable_muts_seen += chances_to_get_new;

[11.4401]

[11.4454]

    // "Good" mutations are rarely noticed; they improve your character
    // in ways that affect most fights.

Replacement in crawl-ref/source/mutation.cc at line 2687 [4.1263003]

B:BD[11.4455] → [11.4455:4525]

B:BD[11.4525] → [12.3030:3040]

∅:D[12.3040] → [11.4535:4580]

B:BD[11.4535] → [11.4535:4580]

B:BD[11.4580] → [12.3041:3051]

∅:D[12.3051] → [11.4590:4596]

B:BD[11.4590] → [11.4590:4596]

        if (x_chance_in_y(chances_to_get_new, increasable_muts_seen))
        {
            mut_to_increase = NUM_MUTATIONS;
        }
    }

[11.4455]

[11.4596]

    static const mutation_type good_muts[] = {
        MUT_TOUGH_SKIN,  MUT_GREY_SCALES, MUT_BONEY_PLATES,
        MUT_SLOW_METABOLISM, MUT_SPIT_POISON, MUT_BLINK, MUT_SHAGGY_FUR,
        MUT_HIGH_MAGIC, MUT_RED_SCALES, MUT_BLUE_SCALES,
        MUT_SPECKLED_SCALES, MUT_ORANGE_SCALES, MUT_IRIDESCENT_SCALES,
        MUT_PATTERNED_SCALES
    };

Replacement in crawl-ref/source/mutation.cc at line 2695 [4.1263003]

B:BD[11.4597] → [11.4597:4668]

B:BD[11.4668] → [12.3052:3253]

    // If you already have 6 demon powers, but there are no candidates
    // for increasing, then this function has been called too many times.
    // XXX right now, there are 1-level mutations on the demonspawn list,
    // so this will be reached - give a bonus power.

[11.4597]

[11.4869]

    bool good_enough = false;

Replacement in crawl-ref/source/mutation.cc at line 2697 [4.1263003]
B:BD[11.4870] → [11.4870:4906]
B:BD[11.4906] → [12.3254:3260]
∅:D[12.3260] → [11.4912:4953]
B:BD[11.4912] → [11.4912:4953]
B:BD[11.4953] → [12.3261:3267]
```
    if (increasable_muts_seen == 0)
    {
        mut_to_increase = NUM_MUTATIONS;
    }
```
[11.4870]
[11.4959]
```
    typedef mutation_type facet_type[3];
    facet_type facets[6];
```
Replacement in crawl-ref/source/mutation.cc at line 2700 [4.1263003]
B:BD[11.4960] → [11.4960:5002]
```
    if (mut_to_increase != NUM_MUTATIONS)
```
[11.4960]
[11.5002]
```
try_again:
    while (!good_enough)
```

Replacement in crawl-ref/source/mutation.cc at line 2703 [4.1263003]

B:BD[11.5008] → [2.2795:2874]

        ASSERT(muts[mut_to_increase] < mutation_defs[mut_to_increase].levels);

[11.5008]

[11.6030]

        mutation_type muts[6];

Replacement in crawl-ref/source/mutation.cc at line 2705 [4.1263003]

B:BD[11.6031] → [8.4098:4130]

∅:D[8.4130] → [11.6047:6054]

B:BD[11.6047] → [11.6047:6054]

B:BD[11.6054] → [12.3733:3784]

        return mut_to_increase;
    }
    // Otherwise we're adding a brand new mutation

[11.6031]

[11.6105]

        muts[0] = RANDOM_ELEMENT(body_muts);
        muts[1] = RANDOM_ELEMENT(awesome_muts);
        muts[2] = RANDOM_ELEMENT(great_muts);
        muts[3] = RANDOM_ELEMENT(great_muts);
        muts[4] = RANDOM_ELEMENT(good_muts);
        muts[5] = RANDOM_ELEMENT(good_muts);

Replacement in crawl-ref/source/mutation.cc at line 2712 [4.1263003]

∅:D[11.6106] → [14.2639:2839]

B:BD[4.1321952] → [14.2639:2839]

∅:D[14.2839] → [4.1322152:1322165]

B:BD[4.1322152] → [4.1322152:1322165]

B:BD[4.1322165] → [8.4131:4156]

    // Merged the demonspawn lists into a single loop.  Now a high-level
    // character can potentially get mutations from the low-level list
    // if it's having trouble with the high level list.
    do
    {
        if (level >= 10)

[11.6106]

[4.1322205]

        // Check for conflicting mutations
        for (int i = 0; i < 6; ++i)

Replacement in crawl-ref/source/mutation.cc at line 2715 [4.1263003]
B:BD[4.1322215] → [8.4157:4176]
∅:D[8.4176] → [12.3785:3866]
B:BD[4.1322264] → [12.3785:3866]
∅:D[12.3866] → [4.1322345:1322381]
B:BD[4.1322345] → [4.1322345:1322381]
B:BD[4.1322381] → [12.3867:3881]
∅:D[12.3881] → [4.1322421:1322422]
B:BD[4.1322421] → [4.1322421:1322422]
B:BD[4.1322422] → [8.4177:4211]
∅:D[8.4211] → [12.3882:3955]
B:BD[4.1322492] → [12.3882:3955]
∅:D[12.3955] → [4.1322565:1322609]
B:BD[4.1322565] → [4.1322565:1322609]
B:BD[4.1322609] → [12.3956:3970]
∅:D[12.3970] → [4.1322649:1322650]
B:BD[4.1322649] → [4.1322649:1322650]
B:BD[4.1322650] → [12.3971:4029]
B:BD[12.4029] → [8.4212:4246]
∅:D[8.4246] → [12.4196:4273]
B:BD[12.4196] → [12.4196:4273]
∅:D[13.4137] → [4.1322794:1322838]
∅:D[12.4273] → [4.1322794:1322838]
B:BD[4.1322794] → [4.1322794:1322838]
B:BD[4.1322864] → [4.1322864:1322913]
B:BD[4.1322913] → [12.4274:4288]
∅:D[12.4288] → [4.1322927:1322974]
B:BD[4.1322927] → [4.1322927:1322974]
B:BD[4.1322974] → [12.4289:4303]
∅:D[12.4303] → [4.1323033:1323069]
B:BD[4.1323033] → [4.1323033:1323069]
B:BD[4.1323069] → [12.4304:4318]
∅:D[12.4318] → [4.1323083:1323118]
B:BD[4.1323083] → [4.1323083:1323118]
B:BD[4.1323118] → [12.4319:4333]
∅:D[12.4333] → [4.1323158:1323193]
B:BD[4.1323158] → [4.1323158:1323193]
B:BD[4.1323193] → [12.4334:4348]
∅:D[12.4348] → [4.1323207:1323254]
B:BD[4.1323207] → [4.1323207:1323254]
B:BD[4.1323254] → [12.4349:4363]
∅:D[12.4363] → [4.1323294:1323330]
B:BD[4.1323294] → [4.1323294:1323330]
B:BD[4.1323330] → [12.4364:4378]
∅:D[12.4378] → [4.1323344:1323387]
B:BD[4.1323344] → [4.1323344:1323387]
B:BD[4.1323387] → [12.4379:4393]
∅:D[12.4393] → [4.1323446:1323482]
B:BD[4.1323446] → [4.1323446:1323482]
B:BD[4.1323482] → [12.4394:4408]
∅:D[12.4408] → [4.1323496:1323543]
B:BD[4.1323496] → [4.1323496:1323543]
B:BD[4.1323543] → [12.4409:4423]
∅:D[12.4423] → [4.1323583:1323584]
B:BD[4.1323583] → [4.1323583:1323584]
B:BD[4.1323584] → [8.4247:4309]
∅:D[8.4309] → [12.4424:4438]
B:BD[4.1323654] → [12.4424:4438]
∅:D[15.168] → [4.1323668:1323717]
∅:D[12.4438] → [4.1323668:1323717]
B:BD[4.1323668] → [4.1323668:1323717]
B:BD[4.1323717] → [12.4439:4453]
∅:D[12.4453] → [4.1323757:1323793]
B:BD[4.1323757] → [4.1323757:1323793]
```
            if (1)
            {                       // good conjurers don't get bolt of draining
                whichm = MUT_SMITE;
            }
            if (one_chance_in(4))
            {                       // good conjurers don't get hellfire
                whichm = MUT_HURL_HELLFIRE;
            }
            // Makhlebites have the summonings invocation
            if (one_chance_in(3))
            {                       // good summoners don't get summon demon
                whichm = MUT_SUMMON_DEMONS;
            }
            if (one_chance_in(8))
            {
                whichm = MUT_MAGIC_RESISTANCE;
            }
            if (one_chance_in(12))
            {
                whichm = MUT_FAST;
            }
            if (one_chance_in(7))
            {
                whichm = MUT_TELEPORT_AT_WILL;
            }
            if (one_chance_in(10))
            {
                whichm = MUT_REGENERATION;
            }
            if (one_chance_in(12))
            {
                whichm = MUT_SHOCK_RESISTANCE;
            }
            if (!muts[MUT_CALL_TORMENT] && one_chance_in(15))
            {
                whichm = MUT_TORMENT_RESISTANCE;
            }
            if (one_chance_in(12))
```
[4.1322215]
[12.4454]
```
            for (int j = 0; j < i; ++j)
```
Replacement in crawl-ref/source/mutation.cc at line 2717 [4.1263003]
∅:D[12.4468] → [4.1323807:1323864]
B:BD[4.1323807] → [4.1323807:1323864]
B:BD[4.1323864] → [12.4469:4483]
∅:D[12.4483] → [4.1323917:1323918]
B:BD[4.1323917] → [4.1323917:1323918]
B:BD[4.1323918] → [8.4310:4378]
∅:D[8.4378] → [12.4484:4498]
B:BD[4.1323994] → [12.4484:4498]
∅:D[12.4498] → [4.1324008:1324051]
B:BD[4.1324008] → [4.1324008:1324051]
B:BD[4.1324051] → [12.4499:4513]
∅:D[12.4513] → [4.1324091:1324092]
B:BD[4.1324091] → [4.1324091:1324092]
B:BD[4.1324092] → [8.4379:4414]
∅:D[8.4414] → [4.1324209:1324268]
B:BD[4.1324209] → [4.1324209:1324268]
B:BD[4.1324463] → [4.1324463:1324478]
B:BD[4.1324478] → [8.4415:4450]
∅:D[8.4450] → [12.4514:4528]
B:BD[16.2742] → [12.4514:4528]
∅:D[12.4528] → [4.1324558:1324603]
B:BD[4.1324558] → [4.1324558:1324603]
B:BD[4.1324603] → [12.4529:4543]
∅:D[12.4543] → [4.1324643:1324644]
B:BD[4.1324643] → [4.1324643:1324644]
B:BD[4.1324644] → [8.4451:4486]
∅:D[17.132] → [4.1324710:1324767]
∅:D[18.3074] → [4.1324710:1324767]
∅:D[8.4486] → [4.1324710:1324767]
B:BD[4.1324710] → [4.1324710:1324767]
B:BD[4.1324793] → [4.1324793:1324807]
```
                whichm = MUT_NEGATIVE_ENERGY_RESISTANCE;
            }
            if (!muts[MUT_TORMENT_RESISTANCE] && one_chance_in(20))
            {
                whichm = MUT_CALL_TORMENT;
            }
            if (one_chance_in(12))
            {
                whichm = MUT_CONTROL_DEMONS;
            }
            if (one_chance_in(11))
            {
                whichm = MUT_DEATH_STRENGTH;
            }
            if (one_chance_in(11))
            {
                whichm = MUT_CHANNEL_HELL;
            }
```
[12.4468]
[4.1324807]
```
                // No redundancy, please
                if (muts[i] == muts[j])
                    goto try_again;
```

Replacement in crawl-ref/source/mutation.cc at line 2721 [4.1263003]

B:BD[4.1324808] → [8.4487:4522]

∅:D[14.3122] → [4.1324925:1324980]

∅:D[19.3686] → [4.1324925:1324980]

∅:D[8.4522] → [4.1324925:1324980]

B:BD[4.1324925] → [4.1324925:1324980]

B:BD[4.1325006] → [4.1325006:1325020]

            if (one_chance_in(10))
            {
                whichm = MUT_RAISE_DEAD;
            }

[4.1324808]

[4.1325020]

                // Prevent excessive scales
                if (_is_covering(muts[i]) && _is_covering(muts[j]))
                    goto try_again;

Replacement in crawl-ref/source/mutation.cc at line 2725 [4.1263003]

B:BD[4.1325021] → [8.4523:4558]

∅:D[20.2678] → [4.1325093:1325107]

∅:D[8.4558] → [4.1325093:1325107]

B:BD[4.1325093] → [4.1325093:1325107]

B:BD[4.1325107] → [8.4559:4600]

            if (one_chance_in(25))
            {
                whichm = MUT_DRAIN_LIFE;

[4.1325021]

[4.1325174]

                // Physiology conflict
                if ((muts[i] == MUT_SLOW_METABOLISM && muts[j] == MUT_REGENERATION)
                        || (muts[i] == MUT_REGENERATION && muts[j] == MUT_SLOW_METABOLISM))
                    goto try_again;

Replacement in crawl-ref/source/mutation.cc at line 2732 [4.1263003]

B:BD[4.1325199] → [12.4745:4814]

B:BD[12.4814] → [8.4601:4659]

∅:D[8.4659] → [9.2967:3003]

B:BD[9.2967] → [9.2967:3003]

        // check here so we can see if we need to extend our options
        if (whichm != NUM_MUTATIONS && muts[whichm] != 0)
            whichm = NUM_MUTATIONS;

[4.1325199]

[4.1325349]

        good_enough = true;

Replacement in crawl-ref/source/mutation.cc at line 2734 [4.1263003]
B:BD[4.1325350] → [8.4660:4683]
∅:D[8.4683] → [14.3161:3218]
B:BD[14.3161] → [14.3161:3218]
```
        if (level < 10
            || (counter > 0 && whichm == NUM_MUTATIONS))
```
[4.1325350]
[4.1325422]
```
        for (int i = 0; i < 6; ++i)
```
Replacement in crawl-ref/source/mutation.cc at line 2736 [4.1263003]
B:BD[4.1325432] → [8.4684:4849]
∅:D[8.4849] → [4.1325872:1325886]
B:BD[4.1325872] → [4.1325872:1325886]
B:BD[4.1325886] → [8.4850:4926]
∅:D[8.4926] → [4.1326278:1326293]
B:BD[4.1326278] → [4.1326278:1326293]
B:BD[4.1326293] → [12.5283:5345]
B:BD[12.5345] → [8.4927:4961]
∅:D[14.3330] → [21.1035:1049]
∅:D[8.4961] → [21.1035:1049]
B:BD[21.1035] → [21.1035:1049]
B:BD[21.1049] → [8.4962:5085]
∅:D[8.5085] → [4.1326613:1326662]
B:BD[4.1326613] → [4.1326613:1326662]
B:BD[4.1326662] → [12.5346:5360]
∅:D[12.5360] → [4.1326676:1326724]
B:BD[4.1326676] → [4.1326676:1326724]
B:BD[4.1326724] → [12.5361:5375]
∅:D[12.5375] → [4.1326764:1326799]
B:BD[4.1326764] → [4.1326764:1326799]
B:BD[4.1326799] → [12.5376:5390]
∅:D[12.5390] → [4.1326813:1326859]
B:BD[4.1326813] → [4.1326813:1326859]
B:BD[4.1326859] → [12.5391:5405]
∅:D[12.5405] → [4.1326899:1326934]
B:BD[4.1326899] → [4.1326899:1326934]
B:BD[4.1326934] → [12.5406:5420]
∅:D[12.5420] → [4.1326948:1326994]
B:BD[4.1326948] → [4.1326948:1326994]
B:BD[4.1326994] → [12.5421:5435]
∅:D[12.5435] → [4.1327034:1327069]
B:BD[4.1327034] → [4.1327034:1327069]
B:BD[4.1327069] → [12.5436:5450]
∅:D[12.5450] → [4.1327083:1327126]
B:BD[4.1327083] → [4.1327083:1327126]
B:BD[4.1327126] → [12.5451:5465]
∅:D[12.5465] → [4.1327166:1327167]
B:BD[4.1327166] → [4.1327166:1327167]
B:BD[4.1327167] → [8.5086:5120]
∅:D[8.5120] → [12.5466:5480]
B:BD[4.1327233] → [12.5466:5480]
∅:D[12.5480] → [4.1327247:1327289]
B:BD[4.1327247] → [4.1327247:1327289]
B:BD[4.1327289] → [12.5481:5495]
∅:D[12.5495] → [4.1327363:1327399]
B:BD[4.1327363] → [4.1327363:1327399]
B:BD[4.1327399] → [12.5496:5510]
∅:D[12.5510] → [4.1327413:1327451]
B:BD[4.1327413] → [4.1327413:1327451]
B:BD[4.1327451] → [12.5511:5525]
∅:D[12.5525] → [4.1327491:1327527]
B:BD[4.1327491] → [4.1327491:1327527]
B:BD[4.1327527] → [12.5526:5540]
∅:D[12.5540] → [4.1327541:1327588]
B:BD[4.1327541] → [4.1327541:1327588]
B:BD[4.1327588] → [12.5541:5555]
∅:D[12.5555] → [4.1327628:1327629]
B:BD[4.1327628] → [4.1327628:1327629]
B:BD[4.1327629] → [8.5121:5274]
∅:D[8.5274] → [4.1327885:1327981]
∅:D[13.5347] → [4.1327885:1327981]
∅:D[12.5709] → [4.1327885:1327981]
B:BD[4.1327885] → [4.1327885:1327981]
B:BD[4.1328007] → [4.1328007:1328022]
B:BD[4.1328022] → [8.5275:5310]
∅:D[8.5310] → [4.1328091:1328105]
B:BD[4.1328091] → [4.1328091:1328105]
B:BD[4.1328105] → [8.5311:5423]
∅:D[8.5423] → [4.1328273:1328288]
B:BD[4.1328273] → [4.1328273:1328288]
B:BD[4.1328288] → [8.5424:5443]
∅:D[10.2749] → [4.1328363:1328377]
∅:D[13.5411] → [4.1328363:1328377]
∅:D[8.5443] → [4.1328363:1328377]
∅:D[12.5775] → [4.1328363:1328377]
B:BD[4.1328363] → [4.1328363:1328377]
B:BD[4.1328481] → [4.1328481:1328520]
B:BD[4.1328520] → [12.5776:5794]
∅:D[12.5794] → [4.1328538:1328583]
B:BD[4.1328538] → [4.1328538:1328583]
B:BD[4.1328583] → [12.5795:5813]
∅:D[12.5813] → [4.1328652:1328692]
B:BD[4.1328652] → [4.1328652:1328692]
B:BD[4.1328692] → [12.5814:5832]
∅:D[12.5832] → [4.1328710:1328757]
B:BD[4.1328710] → [4.1328710:1328757]
B:BD[4.1328757] → [12.5833:5851]
∅:D[12.5851] → [4.1328826:1328866]
B:BD[4.1328826] → [4.1328826:1328866]
B:BD[4.1328866] → [12.5852:5870]
∅:D[12.5870] → [4.1328884:1328931]
B:BD[4.1328884] → [4.1328884:1328931]
B:BD[4.1328931] → [12.5871:5889]
∅:D[12.5889] → [4.1329000:1329040]
B:BD[4.1329000] → [4.1329000:1329040]
B:BD[4.1329040] → [12.5890:5908]
∅:D[12.5908] → [4.1329058:1329104]
B:BD[4.1329058] → [4.1329058:1329104]
B:BD[4.1329104] → [12.5909:5927]
∅:D[12.5927] → [4.1329173:1329231]
B:BD[4.1329173] → [4.1329173:1329231]
B:BD[4.1329231] → [9.3100:3243]
B:BD[4.1329974] → [4.1329974:1330032]
B:BD[4.1330032] → [12.5928:5946]
∅:D[12.5946] → [4.1330050:1330097]
B:BD[4.1330050] → [4.1330050:1330097]
B:BD[4.1330097] → [12.5947:5965]
∅:D[22.2629] → [4.1330267:1330317]
∅:D[10.2816] → [4.1330267:1330317]
∅:D[12.5965] → [4.1330267:1330317]
B:BD[4.1330267] → [4.1330267:1330317]
B:BD[4.1330317] → [12.5966:5980]
∅:D[12.5980] → [4.1330331:1330377]
B:BD[4.1330331] → [4.1330331:1330377]
B:BD[4.1330377] → [12.5981:5995]
∅:D[12.5995] → [4.1330436:1330437]
B:BD[4.1330436] → [4.1330436:1330437]
B:BD[4.1330437] → [8.5444:5500]
∅:D[8.5500] → [12.6067:6081]
B:BD[12.6067] → [12.6067:6081]
∅:D[13.5481] → [4.1330522:1330558]
∅:D[12.6081] → [4.1330522:1330558]
B:BD[4.1330522] → [4.1330522:1330558]
B:BD[4.1330558] → [12.6082:6096]
```
            if (!muts[MUT_THROW_FROST]         // only one of these
                    && !muts[MUT_THROW_FLAMES]
                    && !muts[MUT_BREATHE_FLAMES])
            {
                whichm = (coinflip() ? MUT_THROW_FLAMES : MUT_THROW_FROST);
            }
            // summoners and Makhlebites don't get summon imp
            if (one_chance_in(3))
            {
                whichm = (level < 10) ? MUT_SUMMON_MINOR_DEMONS
                                      : MUT_SUMMON_DEMONS;
            }
            if (one_chance_in(4))
            {
                whichm = MUT_POISON_RESISTANCE;
            }
            if (one_chance_in(4))
            {
                whichm = MUT_COLD_RESISTANCE;
            }
            if (one_chance_in(4))
            {
                whichm = MUT_HEAT_RESISTANCE;
            }
            if (one_chance_in(5))
            {
                whichm = MUT_ACUTE_VISION;
            }
            if (one_chance_in(7))
            {
                whichm = MUT_SPIT_POISON;
            }
            if (one_chance_in(10))
            {
                whichm = MUT_MAPPING;
            }
            if (one_chance_in(12))
            {
                whichm = MUT_TELEPORT_CONTROL;
            }
            if (!muts[MUT_THROW_FROST]         // not with these
                && !muts[MUT_THROW_FLAMES]
                && !muts[MUT_BREATHE_FLAMES]
                && one_chance_in(5))
            {
                whichm = MUT_BREATHE_FLAMES;
            }
            if (one_chance_in(12))
            {
                whichm = (level < 10) ? MUT_BLINK
                                      : MUT_TELEPORT_AT_WILL;
            }
            if (1)
            {
                if (one_chance_in(10))
                {
                    whichm = MUT_TOUGH_SKIN;
                }
                if (one_chance_in(24))
                {
                    whichm = MUT_GREEN_SCALES;
                }
                if (one_chance_in(24))
                {
                    whichm = MUT_BLACK_SCALES;
                }
                if (one_chance_in(24))
                {
                    whichm = MUT_GREY_SCALES;
                }
                if (one_chance_in(12))
                {
                    whichm = static_cast<mutation_type>(MUT_RED_SCALES +
                                                        random2(16));
                }
                if (one_chance_in(30))
                {
                    whichm = MUT_BONEY_PLATES;
                }
            }
            if (one_chance_in(25))
            {
                whichm = MUT_REPULSION_FIELD;
            }
            if (one_chance_in( (level < 10) ? 5 : 20 ))
            {
                whichm = MUT_HORNS;
            }
```
[4.1325432]
[4.1330712]
```
            facets[i][0] = facets[i][1] = facets[i][2] = muts[i];
```
Deletion in crawl-ref/source/mutation.cc at line 2738 [4.1263003]
B:BD[4.1330722] → [4.1330722:1330723]
B:BD[4.1330723] → [8.5501:5559]
∅:D[8.5559] → [9.3310:3346]
B:BD[9.3310] → [9.3310:3346]
∅:D[9.3346] → [4.1330803:1330823]
B:BD[4.1330803] → [4.1330803:1330823]
```
        if (whichm != NUM_MUTATIONS && muts[whichm] != 0)
            whichm = NUM_MUTATIONS;
        counter++;
```
Deletion in crawl-ref/source/mutation.cc at line 2739 [4.1263003]
B:BD[4.1330829] → [9.3347:3402]
```
    while (whichm == NUM_MUTATIONS && counter < 5000);
```

Replacement in crawl-ref/source/mutation.cc at line 2740 [4.1263003]

B:BD[4.1330874] → [8.5560:5654]

    if (whichm == NUM_MUTATIONS)
    {
        return MUT_STRONG;
    }
    return whichm;
}

[4.1330874]

[8.5654]

    you.demon_trait.init(NUM_MUTATIONS);

Replacement in crawl-ref/source/mutation.cc at line 2742 [4.1263003]

B:BD[8.5655] → [8.5655:5753]

void roll_demonspawn_mutations()
{
    FixedVector<int, NUM_MUTATIONS> muts;
    int npowers = 0;

[8.5655]

[8.5753]

    // Now give mutations from the facets in some order, consistent
    // with the internal order of the facets.

Replacement in crawl-ref/source/mutation.cc at line 2745 [4.1263003]

B:BD[8.5754] → [8.5754:5813]

    muts.init(0);
    you.demon_trait.init(NUM_MUTATIONS);

[8.5754]

[8.5813]

    FixedVector<int, 6> given;
    given.init(0);
    int ngiven = 0;

Replacement in crawl-ref/source/mutation.cc at line 2751 [4.1263003]

B:BD[4.1330935] → [8.5861:5926]

        // We want 17 (6*3 - 1) random attemps to raise or add a

[4.1330935]

[8.5926]

        // We want 18 (6*3) random attemps to raise or add a

Replacement in crawl-ref/source/mutation.cc at line 2753 [4.1263003]

B:BD[8.5991] → [8.5991:6054]

        // equivalent to taking a string of 17 1s and 9 0s and

[8.5991]

[8.6054]

        // equivalent to taking a string of 18 1s and 8 0s and

Replacement in crawl-ref/source/mutation.cc at line 2756 [4.1263003]

B:BD[8.6080] → [8.6080:6133]

        if (x_chance_in_y(17 - npowers, 28 - level))

[8.6080]

[8.6133]

        if (x_chance_in_y(18 - ngiven, 28 - level))

Replacement in crawl-ref/source/mutation.cc at line 2758 [4.1263003]

B:BD[8.6143] → [8.6143:6213]

            mutation_type newmut = _demonspawn(muts, npowers, level);

[8.6143]

[8.6213]

            int available_facets[6];
            int navailable_facets = 0;
            for (int i = 0; i < 6; ++i)
                if (given[i] != 3)
                    available_facets[navailable_facets++] = i;
            int which_facet = available_facets[random2(navailable_facets)];
            mutation_type newmut = facets[which_facet][given[which_facet]];

Replacement in crawl-ref/source/mutation.cc at line 2774 [4.1263003]

B:BD[8.6430] → [8.6430:6458]

            muts[newmut]++;

[8.6430]

[8.6458]


            ++given[which_facet];
            ++ngiven;