void equip_undead(const coord_def &a, int corps, int monster, int monnum);

// Try to equip the zombie/skeleton with the objects it died with.

// Try to equip the zombie/skeleton/etc. with the objects it died with.

static void _equip_undead(const coord_def &a, int corps, int monster,
                          int monnum)

void equip_undead(const coord_def &a, int corps, int monster, int monnum)

    // If the player picked up and dropped the corpse then all its

    // If the player picked up and dropped the corpse, then all its

    const bool smart_undead = mons_intel(mon) >= I_NORMAL;

                    else if (smart_undead)
                        mslot = MSLOT_ALT_WEAPON;

                        // The undead are too stupid to switch between
                        // weapons.

                    {
                        // Stupid undead can't switch between weapons.

                    }

        // The undead are too stupid to use these.

        // Stupid undead can't use wands.

            if (smart_undead)
            {
                mslot = MSLOT_WAND;
                break;
            }
            continue;
        // Stupid undead can't use scrolls.

            if (smart_undead)
            {
                mslot = MSLOT_SCROLL;
                break;
            }
            continue;
        // Stupid undead can't use potions.

            if (smart_undead)
            {
                mslot = MSLOT_POTION;
                break;
            }
            continue;
        // Stupid undead can't use miscellaneous objects.

            if (smart_undead)
            {
                mslot = MSLOT_MISCELLANY;
                break;
            }

                            item.props[MONSTER_NUMBER].get_short() : 0;

                           item.props[MONSTER_NUMBER].get_short() : 0;

        _equip_undead(a, corps, monster, monnum);

        equip_undead(a, corps, monster, monnum);

    const std::string name =

    monster_type soul_type = mons_species(type);
    const std::string whose =

    const std::string name_plain = mon->name(DESC_PLAIN);
    bool twisted = false;
    if ((allow_fail || mons_unusable_items(mon) > 0) && coinflip())
        twisted = true;

    const std::string name = mon->name(DESC_PLAIN);
    int corps = -1;
    bool twisted = allow_fail && coinflip();

        mprf("%s soul %s.", name.c_str(),

        mprf("%s soul %s.", whose.c_str(),

        mon->type = mons_zombie_size(mons_species(type)) == Z_BIG ?

        mon->type = mons_zombie_size(soul_type) == Z_BIG ?

        mon->base_monster = mons_species(mon->type);

        mon->base_monster = MONS_PROGRAM_BUG;

        // Drop the monster's corpse, so that it can be properly
        // re-equipped below.
        corps = place_monster_corpse(mon, true, true);

        mon->base_monster = mons_species(type);

        mon->base_monster = soul_type;

    // Drop the monster's equipment.
    monster_drop_ething(mon);

    mon->colour = EC_UNHOLY;
    mon->flags |= MF_ENSLAVED_SOUL;
    mon->flags |= MF_CREATED_FRIENDLY;

    {

    else if (corps != -1)
    {
        // Re-equip spectral things.
        equip_undead(mon->pos(), corps, monster_index(mon),
                     mon->base_monster);

        monster_drop_ething(mon);

        // Destroy the monster's corpse, as it's no longer needed.
        destroy_item(corps);

    mon->colour = EC_UNHOLY;
    mon->flags |= MF_ENSLAVED_SOUL;

    name_zombified_unique(mon, type, name_plain);

    name_zombified_unique(mon, type, name);

    // Wow, permanent enslaving!

    mon->flags |= MF_CREATED_FRIENDLY;

        mprf("%s soul %s.", name.c_str(),

        mprf("%s soul %s.", whose.c_str(),

int place_monster_corpse(const monsters *monster, bool silent,
                         bool force = true);

                move_item_to_grid( &item, monster->pos() );

                move_item_to_grid(&item, monster->pos());

        || mons_enslaved_body_and_soul(monster)

static void _place_monster_corpse(const monsters *monster, bool silent)

int place_monster_corpse(const monsters *monster, bool silent,
                         bool force)

    const bool force = mons_class_is_zombified(monster->type);

    if (mons_class_is_zombified(monster->type))
        force = true;

        return;

        return (-1);

        return;

        return (-1);

        return;

        return (-1);

    // Don't care if 'o' is changed, and it shouldn't be (corpses don't stack).
    move_item_to_grid( &o, monster->pos() );

    // Don't care if 'o' is changed, and it shouldn't be (corpses don't
    // stack).
    move_item_to_grid(&o, monster->pos());

}                               // end place_monster_corpse()

    return (o);
}

        if (monster->type == MONS_FIRE_VORTEX && !wizard
            && !mons_reset)

        if (monster->type == MONS_FIRE_VORTEX && !wizard && !mons_reset)

        {

        }

            _place_monster_corpse(monster, silent);

            place_monster_corpse(monster, silent);

        target = origin - coord_def(6,6) + delta;

        target = origin - coord_def(6, 6) + delta;

            return (holiness() != MH_UNDEAD
                    && holiness() != MH_NONLIVING

            return (holiness() != MH_NONLIVING