bool slime_split_merge(monsters * thing);

bool slime_split_merge(monsters *thing);

        for(adjacent_iterator ai(monster->pos()); ai; ++ai)

        for (adjacent_iterator ai(monster->pos()); ai; ++ai)

        for(adjacent_iterator ai(monster->pos()); ai; ++ai)

        for (adjacent_iterator ai(monster->pos()); ai; ++ai)

// leaving durations unchanged I guess. -cao
static void _split_ench_durations(monsters * initial_slime, monsters * split_off)

// leaving durations unchanged, I guess. -cao
static void _split_ench_durations(monsters *initial_slime, monsters *split_off)

    for( i=initial_slime->enchantments.begin();
        i!=initial_slime->enchantments.end(); ++i)

    for (i = initial_slime->enchantments.begin();
         i != initial_slime->enchantments.end(); ++i)

// What to do about any enchantments these two slimes may have?
// For now we are averaging the durations -cao
static void _merge_ench_durations(monsters * initial_slime, monsters * merge_to)

// What to do about any enchantments these two slimes may have?  For
// now, we are averaging the durations. -cao
static void _merge_ench_durations(monsters *initial_slime, monsters *merge_to)

        // does the other slime have this enchantment as well?

        // Does the other slime have this enchantment as well?

        // If not use duration 0 for their part of the average.

        // If not, use duration 0 for their part of the average.

        if(!i->second.duration)
            i->second.duration=1;

        if (!i->second.duration)
            i->second.duration = 1;

        if(initial_slime->enchantments.find(i->first)
           != initial_slime->enchantments.end()
           && i->second.duration > 1)

        if (initial_slime->enchantments.find(i->first)
                != initial_slime->enchantments.end()
            && i->second.duration > 1)

                                  /total_count;

                                  / total_count;

static void _stats_from_blob_count(monsters * slime, float hp_per_blob)

static void _stats_from_blob_count(monsters *slime, float hp_per_blob)

    slime->max_hit_points = int(slime->number * hp_per_blob);

    slime->max_hit_points = (int)(slime->number * hp_per_blob);

static bool _split_slime(monsters * thing, coord_def & target)

static bool _split_slime(monsters *thing, coord_def& target)

    // create a new slime

    // Create a new slime.

    if(slime_idx == -1)
        return false;

    if (slime_idx == -1)
        return (false);

    monsters * new_slime = &env.mons[slime_idx];

    monsters *new_slime = &env.mons[slime_idx];

    // Inflict the new slime with any enchantments on the parent

    // Inflict the new slime with any enchantments on the parent.

    if(!new_slime)
        return false;

    if (!new_slime)
        return (false);

    if(you.can_see(thing))
    {

    if (you.can_see(thing))

    }

    return true;

    return (true);

static bool _merge_slimes(monsters * initial_slime, monsters * merge_to)

static bool _merge_slimes(monsters *initial_slime, monsters *merge_to)

    // Combine enchantment durations

    // Combine enchantment durations.

    // Merge monster flags (mostly so that MF_CREATUED_NEUTRAL etc. are
    // passed on if the merged slime subsequently splits. Hopefully

    // Merge monster flags (mostly so that MF_CREATED_NEUTRAL, etc. are
    // passed on if the merged slime subsequently splits.  Hopefully

    // This is dumb. With that said, the idea is that if 2 slimes merge
    // you can gain a space by moving away the turn after (maybe this
    // is too nice but there will probably be a lot of complaints about
    // the damage on higher level slimes). So we subtracted some energy
    // above but if merge_to hasn't moved yet this turn that will just
    // cancel its turn in this round of world_reacts. So we are going
    // to see if merge_to has gone already by checking its mindex
    // (this works because handle_monsters just iterates over env.mons
    // in ascending order)
    if(initial_slime->mindex() < merge_to->mindex())

    // This is dumb.  With that said, the idea is that if 2 slimes merge
    // you can gain a space by moving away the turn after (maybe this is
    // too nice but there will probably be a lot of complaints about the
    // damage on higher level slimes).  So we subtracted some energy
    // above, but if merge_to hasn't moved yet this turn, that will just
    // cancel its turn in this round of world_reacts().  So we are going
    // to see if merge_to has gone already by checking its mindex (this
    // works because handle_monsters just iterates over env.mons in
    // ascending order).
    if (initial_slime->mindex() < merge_to->mindex())

    // Overwrite the state of the slime getting merged into because
    // it might have been resting or something.

    // Overwrite the state of the slime getting merged into, because it
    // might have been resting or something.

    // Messaging
    if(you.can_see(merge_to))

    // Messaging.
    if (you.can_see(merge_to))

        if(you.can_see(initial_slime))

        if (you.can_see(initial_slime))

            mprf("A slime creatures suddenly becomes %s.",

            mprf("A slime creature suddenly becomes %s.",

    // have to 'kill' the slime doing the merging

    // Have to 'kill' the slime doing the merging.

    return true;

    return (true);

bool slime_split_merge(monsters * thing)

bool slime_split_merge(monsters *thing)

    // No merging/splitting shapeshifters
    if(mons_is_shapeshifter(thing))
        return false;

    // No merging/splitting shapeshifters.
    if (mons_is_shapeshifter(thing))
        return (false);

    int compass_idx[8] = {0, 1, 2, 3, 4, 5, 6 ,7};
    std::random_shuffle(compass_idx, compass_idx+8);

    int compass_idx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
    std::random_shuffle(compass_idx, compass_idx + 8);

    // We can split if in an 'inactive' state (wandering or sleeping for now)

    // We can split if in an 'inactive' state (wandering or sleeping for
    // now).

            // Anywhere we can place a offspring?
            // If so split.
            for (int i = 0; i < 8; i++)

            // Anywhere we can place am offspring?  If so, split.
            for (int i = 0; i < 8; ++i)

                if(mons_class_can_pass(MONS_SLIME_CREATURE,
                                       env.grid(target))
                   && !actor_at(target))

                if (mons_class_can_pass(MONS_SLIME_CREATURE,
                                        env.grid(target))
                    && !actor_at(target))

                    return _split_slime(thing, target);

                    return (_split_slime(thing, target));

    else if(!mons_is_fleeing(thing))

    else if (!mons_is_fleeing(thing))

        for(int i=0;i<8;i++)

        for (int i = 0; i < 8; ++i)

            coord_def target=origin + Compass[compass_idx[i]];
            monsters * other_thing = monster_at(target);

            coord_def target = origin + Compass[compass_idx[i]];
            monsters *other_thing = monster_at(target);

            // We can merge if we find another adjacent slime which isn't
            // already at the merge cap and is closer to the target than
            // our current position.
            if(other_thing
               && other_thing->mons_species() == MONS_SLIME_CREATURE
               && other_thing->attitude == thing->attitude
               && other_thing->is_summoned() == thing->is_summoned()
               && !mons_is_shapeshifter(other_thing))

            // We can merge if we find another adjacent slime which
            // isn't already at the merge cap and is closer to the
            // target than our current position.
            if (other_thing
                && other_thing->mons_species() == MONS_SLIME_CREATURE
                && other_thing->attitude == thing->attitude
                && other_thing->is_summoned() == thing->is_summoned()
                && !mons_is_shapeshifter(other_thing))

                if(new_blob_count <= max_slime_merge
                   && grid_distance(thing->target, thing->pos()) >
                      grid_distance(thing->target, target))

                if (new_blob_count <= max_slime_merge
                    && grid_distance(thing->target, thing->pos()) >
                       grid_distance(thing->target, target))

                    return _merge_slimes(thing, other_thing);

                    return (_merge_slimes(thing, other_thing));

    // Couldn't merge or split
    return false;

    // Couldn't merge or split.
    return (false);

         && monster->mons_species() != MONS_SLIME_CREATURE)

             && monster->mons_species() != MONS_SLIME_CREATURE)

        // Slime creatures may split or merge depending on the situation

        // Slime creatures may split or merge depending on the
        // situation.

        if(!monster->alive())
            return true;

        if (!monster->alive())
            return (true);

    for(adjacent_iterator ai(monster->pos()); ai; ++ai)

    for (adjacent_iterator ai(monster->pos()); ai; ++ai)

            // Slime creatures can split while wandering or resting
            || monster->type == MONS_SLIME_CREATURE)

                // Slime creatures can split while wandering or resting.
                || monster->type == MONS_SLIME_CREATURE)

            // Prevents unfriendlies from nuking you from offscreen.
            // How nice!

            // Prevents unfriendlies from nuking you from offscreen.
            // How nice!
            // Slime creatures can split when offscreen
            if (friendly_or_near || monster->type == MONS_TEST_SPAWNER

            if (friendly_or_near
                || monster->type == MONS_TEST_SPAWNER
                // Slime creatures can split when offscreen.

                // [ds] Special abilities shouldn't overwhelm spellcasting
                // in monsters that have both. This aims to give them both
                // roughly the same weight.

                // [ds] Special abilities shouldn't overwhelm
                // spellcasting in monsters that have both.  This aims
                // to give them both roughly the same weight.

    if(mon->mons_species() == MONS_SLIME_CREATURE)
    {

    if (mon->mons_species() == MONS_SLIME_CREATURE)

    }

    // Hacks to make merged slime creatures not worth so much
    // exp. We will calculate the experience we would get for 1
    // blob then just multiply it so that exp is linear with blobs
    // merged. -cao
    if(monster->mons_species() == MONS_SLIME_CREATURE)
    {

    // Hacks to make merged slime creatures not worth so much exp.  We
    // will calculate the experience we would get for 1 blob, and then
    // just multiply it so that exp is linear with blobs merged. -cao
    if (monster->mons_species() == MONS_SLIME_CREATURE)

    }

    // to reduce the inappropriate amount of XP that results. -- bwr

    // to reduce the inappropriate amount of XP that results. - bwr

    // Slime creature exp hack part 2, scale exp back up by the
    // number of blobs merged. -cao
    if(monster->mons_species() == MONS_SLIME_CREATURE)
    {

    // Slime creature exp hack part 2: Scale exp back up by the number
    // of blobs merged. -cao
    if (monster->mons_species() == MONS_SLIME_CREATURE)

    }

    // Reductions for big values. -- bwr

    // Reductions for big values. - bwr

    if(mon.mons_species() == MONS_SLIME_CREATURE && desc != DESC_DBNAME)

    if (mon.mons_species() == MONS_SLIME_CREATURE && desc != DESC_DBNAME)

        ASSERT(mon.number <=5);

        ASSERT(mon.number <= 5);

        ghost.reset(new ghost_demon( *mon.ghost ));

        ghost.reset(new ghost_demon(*mon.ghost));

    for(adjacent_iterator ai(you.pos()); ai; ++ai)

    for (adjacent_iterator ai(you.pos()); ai; ++ai)

            return true;
    return false;

            return (true);
    return (false);

    if(m1type == MONS_SLIME_CREATURE)
    {

    if (m1type == MONS_SLIME_CREATURE)

    }