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

    TAG_MINOR_UGLY     = 21,     // More ghost bits for (very) ugly things.
    TAG_MINOR_VERSION  = 21      // Current version.  (Keep equal to max.)

    marshallShort(th, ghost.att_type);
    marshallShort(th, ghost.att_flav);

    marshallByte(th, ghost.colour);

    if (minorVersion >= TAG_MINOR_UGLY)
    {
        ghost.att_type     = static_cast<mon_attack_type>( unmarshallShort(th) );
        ghost.att_flav     = static_cast<mon_attack_flavour>( unmarshallShort(th) );
    }

    if (minorVersion >= TAG_MINOR_UGLY)
        ghost.colour       = unmarshallByte(th);

unsigned char make_low_colour(unsigned char colour);
unsigned char make_high_colour(unsigned char colour);

}
unsigned char make_low_colour(unsigned char colour)
{
    if (colour >= 8 && colour <= 15)
        return (colour - 8);
    return (colour);
}
unsigned char make_high_colour(unsigned char colour)
{
    if (colour >= 0 && colour <= 7)
        return (colour + 8);
    return (colour);

    // Initialise pandemonium demons.
    if (menv[id].type == MONS_PANDEMONIUM_DEMON)

    // Initialise (very) ugly things and pandemonium demons.
    if (menv[id].type == MONS_UGLY_THING
        || menv[id].type == MONS_VERY_UGLY_THING)
    {
        ghost_demon ghost;
        ghost.init_ugly_thing(menv[id].type == MONS_VERY_UGLY_THING);
        menv[id].set_ghost(ghost, false);
        menv[id].uglything_init();
    }
    else if (menv[id].type == MONS_PANDEMONIUM_DEMON)

    if (mon->type == MONS_UGLY_THING || mon->type == MONS_VERY_UGLY_THING)
        return (true);

    return (mc == MONS_PLAYER_GHOST

    return (mc == MONS_UGLY_THING
            || mc == MONS_VERY_UGLY_THING
            || mc == MONS_PLAYER_GHOST

            return (mon_attack_def::attk(mon->ghost->damage));

        {
            return (mon_attack_def::attk(mon->ghost->damage,
                                         mon->ghost->att_type,
                                         mon->ghost->att_flav));
        }

void monsters::set_ghost(const ghost_demon &g)

void monsters::set_ghost(const ghost_demon &g, bool has_name)

    mname = ghost->name;

    if (has_name)
        mname = ghost->name;

        colour = random_colour(); // demon's colour

        colour = ghost->colour;

    colour          = mons_class_colour(MONS_PLAYER_GHOST);

    colour          = ghost->colour;

void monsters::uglything_init()
{
    hit_dice        = ghost->xl;
    hit_points      = ghost->max_hp;
    max_hit_points  = ghost->max_hp;
    ac              = ghost->ac;
    ev              = ghost->ev;
    speed           = ghost->speed;
    speed_increment = 70;
    colour          = ghost->colour;
}

    MONS_UGLY_THING, 'u', BROWN, "ugly thing",

    MONS_UGLY_THING, 'u', BLACK, "ugly thing",

    mrd(MR_RES_COLD, 2),

    MR_NO_FLAGS,

    MONS_VERY_UGLY_THING, 'u', RED, "very ugly thing",

    MONS_VERY_UGLY_THING, 'u', BLACK, "very ugly thing",

    mrd(MR_RES_COLD, 2),

    MR_NO_FLAGS,

    4, 8, MST_NO_SPELLS, CE_MUTAGEN_RANDOM, Z_BIG, S_ROAR, I_ANIMAL,
    HT_AMPHIBIOUS_LAND, 8, DEFAULT_ENERGY, MONUSE_OPEN_DOORS, MONEAT_NOTHING, SIZE_LARGE

    4, 10, MST_NO_SPELLS, CE_MUTAGEN_RANDOM, Z_BIG, S_ROAR, I_ANIMAL,
    HT_AMPHIBIOUS_LAND, 10, DEFAULT_ENERGY, MONUSE_OPEN_DOORS, MONEAT_NOTHING, SIZE_LARGE

#include "ghost.h"

    // An ugly thing is the only ghost demon monster that can level up.
    // If one has leveled up to a very ugly thing, upgrade it properly.
    //
    // XXX: There should be a better way to do this!
    if (type == MONS_VERY_UGLY_THING)
    {
        ghost->ugly_thing_to_very_ugly_thing();
        uglything_init();
    }

    mon_attack_type att_type;
    mon_attack_flavour att_flav;

    unsigned char colour;

    void init_ugly_thing(bool very_ugly);
    void ugly_thing_to_very_ugly_thing();

    void ugly_thing_add_resistance();

#include "view.h"

    att_type         = AT_HIT;
    att_flav         = AF_PLAIN;

    colour           = BLACK;

    colour = random_colour();

    colour = mons_class_colour(MONS_PLAYER_GHOST);

}
static unsigned char _ugly_thing_random_colour()
{
    const unsigned char colours[] =
    {
        CYAN, GREEN, RED, LIGHTGREY, BROWN, MAGENTA
    };
    return (colours[random2(sizeof(colours) / sizeof(*colours))]);
}
static mon_attack_flavour _ugly_thing_colour_to_flavour(unsigned char u_colour)
{
    mon_attack_flavour u_att_flav = AF_PLAIN;
    switch (u_colour)
    {
    case CYAN:
        u_att_flav = AF_ELEC;
        break;
    case GREEN:
        u_att_flav = AF_POISON;
        break;
    case RED:
        u_att_flav = AF_FIRE;
        break;
    case LIGHTGREY:
        u_att_flav = AF_COLD;
        break;
    case BROWN:
        u_att_flav = AF_ACID;
        break;
    case MAGENTA:
        u_att_flav = AF_DISEASE;
        break;
    default:
        break;
    }
    return (u_att_flav);
}
static mon_attack_flavour _ugly_thing_flavour_upgrade(mon_attack_flavour u_att_flav)
{
    switch (u_att_flav)
    {
    case AF_POISON:
        u_att_flav = AF_POISON_MEDIUM;
        break;
    case AF_FIRE:
        u_att_flav = AF_NAPALM;
        break;
    case AF_DISEASE:
        u_att_flav = AF_ROT;
        break;
    default:
        break;
    }
    return (u_att_flav);
}
void ghost_demon::init_ugly_thing(bool very_ugly)
{
    // Midpoint: 10, as in mon-data.h.
    speed = 9 + random2(3);
    // Midpoint: 10, as in mon-data.h.
    ev = 9 + random2(3);
    // Midpoint: 3, as in mon-data.h.
    ac = 2 + random2(3);
    // Midpoint: 12, as in mon-data.h.
    damage = 11 + random2(3);
    // Experience level: 8, the same as in mon-data.h.
    xl = 8;
    // Hit dice: {8, 3, 5, 0}, the same as in mon-data.h.
    max_hp = hit_points(xl, 3, 5);
    resists.elec = 0;
    resists.poison = 0;
    resists.fire = 0;
    resists.cold = 0;
    resists.acid = 0;
    resists.sticky_flame = false;
    // An ugly thing gets one random resistance.
    ugly_thing_add_resistance();
    const mon_attack_type att_types[] =
    {
        AT_BITE, AT_STING, AT_CLAW, AT_PUNCH, AT_KICK, AT_TENTACLE_SLAP,
        AT_TAIL_SLAP, AT_BUTT
    };
    att_type = att_types[random2(sizeof(att_types) / sizeof(*att_types))];
    // An ugly thing always gets a low-intensity colour.
    colour = _ugly_thing_random_colour();
    // Pick a compatible attack flavour for this colour.
    att_flav = _ugly_thing_colour_to_flavour(colour);
    // If this is a very ugly thing, upgrade it properly.
    if (very_ugly)
        ugly_thing_to_very_ugly_thing();
}
void ghost_demon::ugly_thing_to_very_ugly_thing()
{
    // Midpoint when added to an ugly thing: 4, as in mon-data.h.
    ac++;
    // Midpoint when added to an ugly thing: 17, as in mon-data.h.
    damage += 5;
    // Experience level when added to an ugly thing: 12, the same as in
    // mon-data.h.
    xl += 4;
    // Hit dice when added to an ugly thing: {12, 3, 5, 0}, the same as
    // in mon-data.h.
    max_hp += hit_points(4, 3, 5);
    // A very ugly thing always gets a high-intensity colour.
    colour = make_high_colour(colour);
    // A very ugly thing sometimes gets a stronger attack flavour.
    if (one_chance_in(3))
        att_flav = _ugly_thing_flavour_upgrade(att_flav);
    // A very ugly thing gets one more random resistance, and another
    // possible resistance based on its stronger attack flavour.
    ugly_thing_add_resistance();

void ghost_demon::ugly_thing_add_resistance()
{
    int base_rand = 6;
    if (resists.sticky_flame)
        base_rand--;
    switch (random2(base_rand))
    {
        case 0:
            resists.elec++;
            break;
        case 1:
            resists.poison++;
            break;
        case 2:
            resists.fire++;
            break;
        case 3:
            resists.cold++;
            break;
        case 4:
            resists.acid++;
            break;
        case 5:
            resists.sticky_flame = true;
            break;
    }
    // Guarantee certain resistances for stronger attack flavours.
    if (att_flav == AF_POISON_MEDIUM && !resists.poison)
        resists.poison++;
    else if (att_flav == AF_ACID && !resists.acid)
        resists.acid++;
    else if (att_flav == AF_NAPALM && !resists.sticky_flame)
        resists.sticky_flame = true;
}

    void set_ghost(const ghost_demon &ghost);

    void set_ghost(const ghost_demon &ghost, bool has_name = true);

    void uglything_init();

    // This doesn't give anything away since all ghosts can fly, and
    // for demons it's already mentioned in their flavour description.

    // This doesn't give anything away since no (very) ugly things can
    // fly, all ghosts can fly, and for demons it's already mentioned in
    // their flavour description.

        mprf(MSGCH_DIAGNOSTICS, "Ghost damage: %d; brand: %d",
             ghost.damage, ghost.brand);

        mprf(MSGCH_DIAGNOSTICS, "Ghost damage: %d; brand: %d; att_type: %d; "
                                "att_flav: %d",
             ghost.damage, ghost.brand, ghost.att_type, ghost.att_flav);

An ugly thing. Yuck.

An ugly thing. According to legend, this mutated creature is the spawn of an otherworldly wizard's breeding experiment. Yuck.

A very ugly thing. Double yuck.

A very ugly thing. According to legend, this hideously mutated creature is the spawn of an otherworldly wizard's breeding experiment. Double yuck.