int energy_gained = (monster->speed * you.time_taken) / 10;
    // Slow monsters might get 0 here. Maybe we should factor in
    // *how* slow it is...but a 10-to-1 move ratio seems more than
    // enough.
    if (energy_gained == 0 && monster->speed != 0)
        energy_gained = 1;
    monster->speed_increment += energy_gained;

    if (monster->speed > 0)
    {
        // Randomise to make counting off monster moves harder:
        const int energy_gained =
            std::max(1, div_rand_round(monster->speed * you.time_taken, 10));
        monster->speed_increment += energy_gained;
    }

public:

public:
    mon_energy_usage(int mv = 10, int sw = 10, int att = 10, int miss = 10,
                     int spl = 10, int spc = 10, int itm = 10, int pick = 100)
        : move(mv), swim(sw), attack(att), missile(miss),
          spell(spl), special(spc), item(itm), pickup_percent(pick)
    {
    }
    static mon_energy_usage attack_cost(int cost)
    {
        mon_energy_usage me;
        me.attack = cost;
        return me;
    }
    static mon_energy_usage missile_cost(int cost)
    {
        mon_energy_usage me;
        me.missile = cost;
        return me;
    }
    static mon_energy_usage move_cost(int mv, int sw = 10)
    {
        const mon_energy_usage me(mv, sw);
        return me;
    }
    mon_energy_usage operator | (const mon_energy_usage &o) const
    {
        return mon_energy_usage( combine(move, o.move),
                                 combine(swim, o.swim),
                                 combine(attack, o.attack),
                                 combine(missile, o.missile),
                                 combine(spell, o.spell),
                                 combine(special, o.special),
                                 combine(item, o.item),
                                 combine(pickup_percent, o.pickup_percent,
                                         100) );
    }
private:
    char combine(char a, char b, char def = 10) const {
        return (b != def? b : a);
    }

static monsterentry mondata[] = {

};

        case EUT_SWIM:    return mu.swim;

        case EUT_SWIM:
            // [ds] Amphibious monsters get a significant speed boost
            // when swimming, as discussed with dpeg. We do not
            // distinguish between amphibians that favour land
            // (HT_LAND, such as hydras) and those that favour water
            // (HT_WATER, such as merfolk), but that's something we
            // can think about.
            if (mons_class_flag(type, M_AMPHIBIOUS))
                return div_rand_round(mu.swim * 7, 10);
            else
                return mu.swim;

const mon_energy_usage DEFAULT_ENERGY;

#define DEFAULT_ENERGY {10, 10, 10, 10, 10, 10, 10, 100}
#define MOVE_ENERGY(x) {(x), (x), 10, 10, 10, 10, 10, 100}

static inline mon_energy_usage MOVE_ENERGY(int me)
{
    return mon_energy_usage::move_cost(me, me);
}
static inline mon_energy_usage ATTACK_ENERGY(int ae)
{
    return mon_energy_usage::attack_cost(ae);
}
static inline mon_energy_usage MISSILE_ENERGY(int ae)
{
    return mon_energy_usage::missile_cost(ae);
}
static monsterentry mondata[] = {

    HT_LAND, 11, DEFAULT_ENERGY, MONUSE_WEAPONS_ARMOUR, SIZE_MEDIUM

    HT_LAND, 11, MISSILE_ENERGY(4), MONUSE_WEAPONS_ARMOUR, SIZE_MEDIUM

};