const monsterentry *entry       = get_monster_data(monster->type);
    const int          throw_energy = entry->energy_usage.missile;
    monster->speed_increment       -= throw_energy;

    monster->lose_energy(EUT_MISSILE);
    const int throw_energy = monster->action_energy(EUT_MISSILE);

    {
        monsterentry *entry = get_monster_data(monster->type);
        monster->speed_increment -= entry->energy_usage.special;
    }

        monster->lose_energy(EUT_SPECIAL);

            monsterentry *entry = get_monster_data(monster->type);
            monster->speed_increment -= entry->energy_usage.item;

            monster->lose_energy(EUT_ITEM);

            monsterentry *entry = get_monster_data(monster->type);
            monster->speed_increment -= entry->energy_usage.item;

            monster->lose_energy(EUT_ITEM);

            monsterentry *entry = get_monster_data(monster->type);
            monster->speed_increment -= entry->energy_usage.item;

            monster->lose_energy(EUT_ITEM);

                monsterentry *entry = get_monster_data(monster->type);
                monster->speed_increment -= entry->energy_usage.spell;

                monster->lose_energy(EUT_SPELL);

            monsterentry *entry = get_monster_data(monster->type);
            monster->speed_increment -= entry->energy_usage.spell;

            monster->lose_energy(EUT_SPELL);

    monsterentry        *entry = get_monster_data(mon->type);
    dungeon_feature_type feat  = grd[mon->x][mon->y];
    if (feat >= DNGN_LAVA && feat <= DNGN_SHALLOW_WATER
        && !mon->airborne())
    {
        mon->speed_increment -= entry->energy_usage.swim;
    }
    else
        mon->speed_increment -= entry->energy_usage.move;

    const dungeon_feature_type feat = grd[mon->x][mon->y];
    // FIXME: Replace check with mons_is_swimming()?
    mon->lose_energy(
        feat >= DNGN_LAVA && feat <= DNGN_SHALLOW_WATER
        && !mon->airborne() ? EUT_SWIM : EUT_MOVE );

    if (!entry)
        return;

    monsterentry *entry = get_monster_data(monster->type);
    monster->speed_increment -= entry->energy_usage.move;

    monster->lose_energy(EUT_MOVE);

    char pickup_percent; 

    char pickup_percent;

    monsterentry* entry = get_monster_data(type);
    int           delta = speed * entry->energy_usage.pickup_percent / 100;
    if (speed_increment > 25 && delta < speed_increment)
        speed_increment -= delta;

    if (const monsterentry* entry = find_monsterentry())
    {
        const int delta = speed * entry->energy_usage.pickup_percent / 100;
        if (speed_increment > 25 && delta < speed_increment)
            speed_increment -= delta;
    }

        monsterentry *entry = get_monster_data(type);
        speed_increment -= div_rand_round(entry->energy_usage.attack, 5);

        if (const monsterentry *entry = find_monsterentry())
            speed_increment -= div_rand_round(entry->energy_usage.attack, 5);

}
const monsterentry *monsters::find_monsterentry() const
{
    return (type == -1 || type == MONS_PROGRAM_BUG) ? NULL
        : get_monster_data(type);
}
int monsters::action_energy(energy_use_type et) const
{
    if (const monsterentry *me = find_monsterentry())
    {
        const mon_energy_usage &mu = me->energy_usage;
        switch (et)
        {
        case EUT_MOVE:    return mu.move;
        case EUT_SWIM:    return mu.swim;
        case EUT_MISSILE: return mu.missile;
        case EUT_ITEM:    return mu.item;
        case EUT_SPECIAL: return mu.special;
        case EUT_SPELL:   return mu.spell;
        case EUT_ATTACK:  return mu.attack;
        case EUT_PICKUP:  return mu.pickup_percent;
        }
    }
    return 10;

void monsters::lose_energy(energy_use_type et)
{
    speed_increment -= action_energy(et);
}

        if (attacker->atype() == ACT_MONSTER)
        {
            // Make sure the monster uses up some energy, even though
            // it didn't actually attack.
            monsterentry *entry   = get_monster_data(atk->type);
            atk->speed_increment -= entry->energy_usage.attack;
        }

        // Make sure the monster uses up some energy, even though
        // it didn't actually attack.
        attacker->lose_energy(EUT_ATTACK);

            monsterentry *entry   = get_monster_data(atk->type);
            atk->speed_increment -= entry->energy_usage.attack;

            attacker->lose_energy(EUT_ATTACK);

            // Make sure the monster uses up some energy, even
            // though it didn't actually attack.

            {
                // Make sure the monster uses up some energy, even
                // though it didn't actually attack.
                monsterentry *entry   = get_monster_data(atk->type);
                atk->speed_increment -= entry->energy_usage.attack;
            }

                atk->lose_energy(EUT_ATTACK);

    monsterentry *entry = get_monster_data(attacker->type);
    char         atk_speed = entry->energy_usage.attack;

        attacker->speed_increment -= atk_speed;

        attacker->lose_energy(EUT_ATTACK);

        const int atk_speed = attacker->action_energy(EUT_ATTACK);

    // Need not be implemented for the player - player action costs
    // are explicitly calculated.
    virtual void lose_energy(energy_use_type)
    {
    }

struct monsterentry;

    void lose_energy(energy_use_type et);

    int action_energy(energy_use_type et) const;    

    bool has_spell_of_type(unsigned) const;    

    bool has_spell_of_type(unsigned) const;
    const monsterentry *find_monsterentry() const;

};
enum energy_use_type
{
    EUT_MOVE,
    EUT_SWIM,
    EUT_ATTACK,
    EUT_MISSILE,
    EUT_SPELL,
    EUT_SPECIAL,
    EUT_ITEM,
    EUT_PICKUP