TAG_MINOR_VERSION  =  8      // Current version.  (Keep equal to max.)

    TAG_MINOR_DSTRAITS =  9,     // Pre-calculate demonspawn mutations
    TAG_MINOR_VERSION  =  9      // Current version.  (Keep equal to max.)

    marshallByte(th, 26);
    for (j = 0; j < 26; j++)
    {
        marshallShort(th, you.demon_trait[j]);
    }

    if (minorVersion >= TAG_MINOR_DSTRAITS)
    {
        count_c = unmarshallByte(th);
        for (j = 0; j < count_c; ++j)
            you.demon_trait[j] = static_cast<mutation_type>(unmarshallShort(th));
    }

  // demon_trait[i] is the mutation increased at the i'th
  // levellup, or NUM_MUTATIONS
  FixedVector<mutation_type, 26> demon_trait;

                // We want 17 (6*3 - 1) random attemps to raise or add a
                // mutation in the 26 level ups.  The following check is
                // equivalent to taking a string of 17 1s and 9 0s and
                // shuffling it.
                if (x_chance_in_y(17 - you.attribute[ATTR_NUM_DEMONIC_POWERS],
                            28 - you.experience_level))

                if (you.demon_trait[you.experience_level - 2] != NUM_MUTATIONS)

                    demonspawn();

                    mpr("Your demonic ancestry asserts itself...", MSGCH_INTRINSIC_GAIN);
                    perma_mutate(you.demon_trait[you.experience_level - 2], 1);

    demon_trait.init(NUM_MUTATIONS);

#include "mutation.h"

    if (you.species == SP_DEMONSPAWN)
        roll_demonspawn_mutations();

void demonspawn();

void roll_demonspawn_mutations();

// Use an attribute counter for how many demonic mutations a demonspawn has.
void demonspawn()

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

    const int covered = _body_covered();

    powers++;

    you.attribute[ATTR_NUM_DEMONIC_POWERS]++;
    mpr("Your demonic ancestry asserts itself...", MSGCH_INTRINSIC_GAIN);

        if (! you.demon_pow[whichm])

        if (! muts[whichm])

        if (you.demon_pow[whichm] < mutation_defs[whichm].levels)

        if (muts[whichm] < mutation_defs[whichm].levels)

        ASSERT(you.demon_pow[mut_to_increase] < mdef.levels);

        if (you.mutation[mut_to_increase] == mdef.levels)
        {
            // The player has our mutation as a temporary thing.  Make
            // it permanent.  I want to put something like NetHack's "Your
            // quickness feels more natural" here, but there doesn't seem
            // to be a good way to do that.
            mpr(mdef.gain[you.demon_pow[mut_to_increase]], MSGCH_MUTATION);
            ++you.demon_pow[mut_to_increase];
        }
        else
        {
            // None of the current demonspawn mutations is capable of
            // failing.  Be very careful if others are added; for instance,
            // talons can fail to mutate if the player already has hooves.
            // You'll need to add a case for clearing mutations in
            // _handle_conflicting_mutations above.
            ASSERT(perma_mutate(mut_to_increase, 1));
        }

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

        return;

        return mut_to_increase;

        if (you.experience_level >= 10)

        if (level >= 10)

            if (you.skills[SK_CONJURATIONS] < 5)

            if (1)

            if (you.skills[SK_CONJURATIONS] < 10 && one_chance_in(4))

            if (one_chance_in(4))

            if ((you.religion != GOD_MAKHLEB ||
                you.piety < piety_breakpoint(3)) &&
                you.skills[SK_SUMMONINGS] < 5 && one_chance_in(3))

            if (one_chance_in(3))

            if (!you.mutation[MUT_CALL_TORMENT] && one_chance_in(15))

            if (!muts[MUT_CALL_TORMENT] && one_chance_in(15))

            if (!you.mutation[MUT_TORMENT_RESISTANCE] && one_chance_in(20))

            if (!muts[MUT_TORMENT_RESISTANCE] && one_chance_in(20))

            if (you.skills[SK_SUMMONINGS] < 5 && you.skills[SK_NECROMANCY] < 5
                && one_chance_in(12))

            if (one_chance_in(12))

            if (you.religion != GOD_MAKHLEB && one_chance_in(11))

            if (one_chance_in(11))

            // Theoretically, you could use this with Trog (for rods and
            // some misc. items), but in general it's going to be much more
            // useful for someone capable of casting spells.
            if (you.religion != GOD_TROG
                && you.religion != GOD_SIF_MUNA && one_chance_in(11))

            if (one_chance_in(11))

            // Yredelemnulites have the raise dead invocation
            if (you.religion != GOD_YREDELEMNUL
                && you.skills[SK_SUMMONINGS] < 3
                && you.skills[SK_NECROMANCY] < 3 && one_chance_in(10))

            if (one_chance_in(10))

            if (you.skills[SK_UNARMED_COMBAT] > 5)

            if (one_chance_in(25))

                // Drain Life only works if you're unarmed, so only
                // give it if unarmed is your best attacking skill.
                skill_type wpn_skill = best_skill(SK_SHORT_BLADES, SK_STAVES);
                if ((you.skills[SK_UNARMED_COMBAT] > you.skills[wpn_skill])
                    && one_chance_in(14))
                {
                    whichm = MUT_DRAIN_LIFE;
                }

                whichm = MUT_DRAIN_LIFE;

        if (whichm != NUM_MUTATIONS && you.mutation[whichm] != 0)

        if (whichm != NUM_MUTATIONS && muts[whichm] != 0)

        if (you.experience_level < 10

        if (level < 10

            if ((!you.mutation[MUT_THROW_FROST]         // only one of these
                    && !you.mutation[MUT_THROW_FLAMES]
                    && !you.mutation[MUT_BREATHE_FLAMES])
                && (!you.skills[SK_CONJURATIONS]        // conjurers seldomly
                    || one_chance_in(5))
                // Makhlebites seldom
                && (you.religion != GOD_MAKHLEB || one_chance_in(4))
                && (!you.skills[SK_ICE_MAGIC]           // already ice & fire?
                    || !you.skills[SK_FIRE_MAGIC]))

            if (!muts[MUT_THROW_FROST]         // only one of these
                    && !muts[MUT_THROW_FLAMES]
                    && !muts[MUT_BREATHE_FLAMES])

                // try to give the flavour the character doesn't have
                // neither
                if (!you.skills[SK_FIRE_MAGIC] && !you.skills[SK_ICE_MAGIC])
                    whichm = (coinflip() ? MUT_THROW_FLAMES : MUT_THROW_FROST);
                else if (!you.skills[SK_FIRE_MAGIC])
                    whichm = MUT_THROW_FLAMES;
                else if (!you.skills[SK_ICE_MAGIC])
                    whichm = MUT_THROW_FROST;
                // both
                else
                    whichm = (coinflip() ? MUT_THROW_FLAMES : MUT_THROW_FROST);

                whichm = (coinflip() ? MUT_THROW_FLAMES : MUT_THROW_FROST);

            if (!you.skills[SK_SUMMONINGS] && you.religion != GOD_MAKHLEB
                && one_chance_in(3))

            if (one_chance_in(3))

                whichm = (you.experience_level < 10) ? MUT_SUMMON_MINOR_DEMONS
                                                     : MUT_SUMMON_DEMONS;

                whichm = (level < 10) ? MUT_SUMMON_MINOR_DEMONS
                                      : MUT_SUMMON_DEMONS;

            if (!you.skills[SK_POISON_MAGIC] && one_chance_in(7))

            if (one_chance_in(7))

            if (!you.mutation[MUT_THROW_FROST]         // not with these
                && !you.mutation[MUT_THROW_FLAMES]
                && !you.mutation[MUT_BREATHE_FLAMES]
                && !you.skills[SK_FIRE_MAGIC]          // or with fire already

            if (!muts[MUT_THROW_FROST]         // not with these
                && !muts[MUT_THROW_FLAMES]
                && !muts[MUT_BREATHE_FLAMES]

            if (!you.skills[SK_TRANSLOCATIONS] && one_chance_in(12))

            if (one_chance_in(12))

                whichm = (you.experience_level < 10) ? MUT_BLINK
                                                     : MUT_TELEPORT_AT_WILL;

                whichm = (level < 10) ? MUT_BLINK
                                      : MUT_TELEPORT_AT_WILL;

            if (covered < 3 && one_chance_in( 1 + covered * 5 ))

            if (1)

            if (one_chance_in( (you.experience_level < 10) ? 5 : 20 ))

            if (one_chance_in( (level < 10) ? 5 : 20 ))

        if (whichm != NUM_MUTATIONS && you.mutation[whichm] != 0)

        if (whichm != NUM_MUTATIONS && muts[whichm] != 0)

    if (whichm == NUM_MUTATIONS || !perma_mutate( whichm, 1 ))

    if (whichm == NUM_MUTATIONS)
    {
        return MUT_STRONG;
    }
    return whichm;
}
void roll_demonspawn_mutations()
{
    FixedVector<int, NUM_MUTATIONS> muts;
    int npowers = 0;
    muts.init(0);
    you.demon_trait.init(NUM_MUTATIONS);
    for (int level = 2; level <= 27; ++level)

        // Unlikely but remotely possible; I know this is a cop-out.
        modify_stat(STAT_STRENGTH, 1, true, "demonspawn mutation");
        modify_stat(STAT_INTELLIGENCE, 1, true, "demonspawn mutation");
        modify_stat(STAT_DEXTERITY, 1, true, "demonspawn mutation");
        mpr("You feel much better now.", MSGCH_INTRINSIC_GAIN);

        // We want 17 (6*3 - 1) random attemps to raise or add a
        // mutation in the 26 level ups.  The following check is
        // equivalent to taking a string of 17 1s and 9 0s and
        // shuffling it.
        if (x_chance_in_y(17 - npowers, 28 - level))
        {
            mutation_type newmut = _demonspawn(muts, npowers, level);
#ifdef DEBUG_DIAGNOSTICS
            mprf(MSGCH_DIAGNOSTICS, "Demonspawn will gain %s at level %d",
                    get_mutation_def(newmut).wizname, level);
#endif
            you.demon_trait[level-2] = newmut;
            muts[newmut]++;
        }

    you.attribute[ATTR_NUM_DEMONIC_POWERS] = 0;

        int powers = 0;

        roll_demonspawn_mutations();
        for (i = 2; i <= you.experience_level; ++i)
        {
            mutation_type m = you.demon_trait[i-2];

        if (you.experience_level < 4)
            powers = 0;
        else if (you.experience_level < 9)
            powers = 1;
        else if (you.experience_level < 14)
            powers = 2;
        else if (you.experience_level < 19)
            powers = 3;
        else if (you.experience_level < 24)
            powers = 4;
        else if (you.experience_level == 27)
            powers = 5;
        int levels[] = {4, 9, 14, 19, 27};
        int real_level = you.experience_level;

            if (m == NUM_MUTATIONS)
                continue;

        for (i = 0; i < powers; ++i)
        {
            // The types of demonspawn mutations you get depends on your
            // experience level at the time of gaining it.
            you.experience_level = levels[i];
            demonspawn();

            ++you.mutation[m];
            ++you.demon_pow[m];

        you.experience_level = real_level;

                       "<w>[</w>      : get a demonspawn mutation\n"

    case '[': demonspawn();                          break;