#include "ghost.h"

        std::string ghost_class = get_class_name(ghost.values[GVAL_CLASS]);

        std::string ghost_class = get_class_name(ghost.job);

#include "ghost.h"

static void marshallResists(tagHeader &, const mon_resist_def &);
static void unmarshallResists(tagHeader &, mon_resist_def &);
static void marshallSpells(tagHeader &, const monster_spells &);
static void unmarshallSpells(tagHeader &, monster_spells &);

    for (int j = 0; j < NUM_MONSTER_SPELL_SLOTS; ++j)
        marshallShort(th, m.spells[j]);

    marshallSpells(th, m.spells);

    for (int j = 0; j < NUM_MONSTER_SPELL_SLOTS; ++j)
        m.spells[j] = static_cast<spell_type>( unmarshallShort(th) );

    unmarshallSpells(th, m.spells);

static void marshallGhost(tagHeader &th, const ghost_demon &ghost)

static void marshallResists(tagHeader &th, const mon_resist_def &res)

    marshallString(th, ghost.name.c_str(), 20);

    marshallByte(th, res.elec);
    marshallByte(th, res.poison);
    marshallByte(th, res.fire);
    marshallByte(th, res.steam);
    marshallByte(th, res.cold);
    marshallByte(th, res.hellfire);
    marshallByte(th, res.asphyx);
    marshallByte(th, res.acid);
    marshallByte(th, res.sticky_flame);
    marshallByte(th, res.pierce);
    marshallByte(th, res.slice);
    marshallByte(th, res.bludgeon);
}

    // how many ghost values?
    marshallByte(th, NUM_GHOST_VALUES);

static void unmarshallResists(tagHeader &th, mon_resist_def &res)
{
    res.elec = unmarshallByte(th);
    res.poison = unmarshallByte(th);
    res.fire = unmarshallByte(th);
    res.steam = unmarshallByte(th);
    res.cold = unmarshallByte(th);
    res.hellfire = unmarshallByte(th);
    res.asphyx = unmarshallByte(th);
    res.acid = unmarshallByte(th);
    res.sticky_flame = unmarshallByte(th);
    res.pierce = unmarshallByte(th);
    res.slice = unmarshallByte(th);
    res.bludgeon = unmarshallByte(th);
}

    for (int i = 0; i < NUM_GHOST_VALUES; i++)
        marshallShort( th, ghost.values[i] );

static void marshallSpells(tagHeader &th, const monster_spells &spells)
{
    for (int j = 0; j < NUM_MONSTER_SPELL_SLOTS; ++j)
        marshallShort(th, spells[j]);

static void tag_construct_ghost(tagHeader &th)

static void unmarshallSpells(tagHeader &th, monster_spells &spells)

    // How many ghosts?
    marshallShort(th, ghosts.size());

    for (int j = 0; j < NUM_MONSTER_SPELL_SLOTS; ++j)
        spells[j] = static_cast<spell_type>( unmarshallShort(th) );
}
static void marshallGhost(tagHeader &th, const ghost_demon &ghost)
{
    marshallString(th, ghost.name.c_str(), 20);

    for (int i = 0, size = ghosts.size(); i < size; ++i)
        marshallGhost(th, ghosts[i]);

    marshallShort(th, ghost.species);
    marshallShort(th, ghost.job);
    marshallShort(th, ghost.best_skill);
    marshallShort(th, ghost.best_skill_level);
    marshallShort(th, ghost.xl);
    marshallShort(th, ghost.max_hp);
    marshallShort(th, ghost.ev);
    marshallShort(th, ghost.ac);
    marshallShort(th, ghost.damage);
    marshallShort(th, ghost.speed);
    marshallByte(th, ghost.see_invis);
    marshallShort(th, ghost.brand);
    marshallResists(th, ghost.resists);
    marshallByte(th, ghost.spellcaster);
    marshallByte(th, ghost.cycle_colours);
    marshallShort(th, ghost.fly);
    marshallSpells(th, ghost.spells);

    // how many ghost values?
    int count_c = unmarshallByte(th);

    ghost.species = static_cast<species_type>( unmarshallShort(th) );
    ghost.job = static_cast<job_type>( unmarshallShort(th) );
    ghost.best_skill = static_cast<skill_type>( unmarshallShort(th) );
    ghost.best_skill_level = unmarshallShort(th);
    ghost.xl = unmarshallShort(th);
    ghost.max_hp = unmarshallShort(th);
    ghost.ev = unmarshallShort(th);
    ghost.ac = unmarshallShort(th);
    ghost.damage = unmarshallShort(th);
    ghost.speed = unmarshallShort(th);
    ghost.see_invis = unmarshallByte(th);
    ghost.brand = static_cast<brand_type>( unmarshallShort(th) );

    if (count_c > NUM_GHOST_VALUES)
        count_c = NUM_GHOST_VALUES;
    
    for (int i = 0; i < count_c; i++)
        ghost.values[i] = unmarshallShort(th);

    unmarshallResists(th, ghost.resists);
    ghost.spellcaster = unmarshallByte(th);
    ghost.cycle_colours = unmarshallByte(th);
    ghost.fly = static_cast<flight_type>( unmarshallShort(th) );

    unmarshallSpells(th, ghost.spells);
    

static void tag_construct_ghost(tagHeader &th)
{
    // How many ghosts?
    marshallShort(th, ghosts.size());
    for (int i = 0, size = ghosts.size(); i < size; ++i)
        marshallGhost(th, ghosts[i]);
}

{
}
bool actor::has_equipped(equipment_type eq, int sub_type) const

    const item_def *item = slot_item(eq);
    return (item && item->sub_type == sub_type);

const item_def *player::slot_item(equipment_type eq) const
{
    return const_cast<player*>(this)->slot_item(eq);
}

int player::get_experience_level() const
{
    return (experience_level);
}

int player::res_steam() const
{
    return (player_res_steam());
}

void end_game( struct scorefile_entry &se )

void end_game( scorefile_entry &se )

    int i;

    if (!dump_char( morgue_name(se.death_time), !dead, true, &se ))
    {
        mpr("Char dump unsuccessful! Sorry about that.");
        if (!crawl_state.seen_hups)
            more();
        clrscr();
    }
    

    for ( i = 0; i < num_suffixes; ++i ) {

    for (int i = 0; i < num_suffixes; ++i) {

    for (i = 0; i < ENDOFPACK; i++)

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

    for (i = 0; i < ENDOFPACK; i++)

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

    if (!dump_char( morgue_name(se.death_time), !dead, true, &se ))
    {
        mpr("Char dump unsuccessful! Sorry about that.");
        if (!crawl_state.seen_hups)
            more();
        clrscr();
    }

#include "ghost.h"

    // instead berserkers attack nearest monsters

    // instead berserkers attack nearest monsters.

    if (monster_can_submerge(monster->type, grd[monster->x][monster->y])

    if (monster_can_submerge(monster, grd[monster->x][monster->y])

        if (monster->ghost->values[ GVAL_DEMONLORD_CYCLE_COLOUR ])

        if (monster->ghost->cycle_colours)

            && !monster->ghost->values[ GVAL_DEMONLORD_SPELLCASTER ])

            && !monster->ghost->spellcaster)

    if (mons_habitat(monster->type) != HT_LAND

    if (mons_habitat(monster) != HT_LAND

        if (monster_can_submerge(monster->type, grd[monster->x][monster->y])

        if (monster_can_submerge(monster, grd[monster->x][monster->y])

        if (grid == DNGN_LAVA && mons_res_fire(mons) > 0)

        if (grid == DNGN_LAVA && mons_res_fire(mons) >= 2)

static bool is_native_in_branch(const monsters *monster, const branch_type branch)

static bool is_native_in_branch(const monsters *monster,
                                const branch_type branch)

        case BRANCH_ELVEN_HALLS:
            if (mons_species(monster->type) == MONS_ELF)
                return true;
            return false;

    case BRANCH_ELVEN_HALLS:
        return (mons_species(monster->type) == MONS_ELF);

        case BRANCH_ORCISH_MINES:
            if (mons_species(monster->type) == MONS_ORC)
                return true;
            return false;

    case BRANCH_ORCISH_MINES:
        return (mons_species(monster->type) == MONS_ORC);

        case BRANCH_SHOALS:
            if (mons_species(monster->type) == MONS_CYCLOPS

    case BRANCH_SHOALS:
        return (mons_species(monster->type) == MONS_CYCLOPS

                || mons_species(monster->type) == MONS_MERMAID)
            {
                return true;
            }
            return false;

                || mons_species(monster->type) == MONS_MERMAID);

        case BRANCH_SLIME_PITS:
            if (mons_species(monster->type) == MONS_JELLY)
                return true;
            return false;

    case BRANCH_SLIME_PITS:
        return (mons_species(monster->type) == MONS_JELLY);

        case BRANCH_SNAKE_PIT:
            if (mons_species(monster->type) == MONS_NAGA
                || mons_species(monster->type) == MONS_SNAKE)
            {
                return true;
            }
            return false;

    case BRANCH_SNAKE_PIT:
        return (mons_species(monster->type) == MONS_NAGA
                || mons_species(monster->type) == MONS_SNAKE);

        case BRANCH_HALL_OF_ZOT:
            if (mons_species(monster->type) == MONS_DRACONIAN)
                return true;
            return false;

    case BRANCH_HALL_OF_ZOT:
        return (mons_species(monster->type) == MONS_DRACONIAN);

        case BRANCH_TOMB:
            if (mons_species(monster->type) == MONS_MUMMY)
                return true;
            return false;

    case BRANCH_TOMB:
        return (mons_species(monster->type) == MONS_MUMMY);

        case BRANCH_HIVE:
            if (monster->type == MONS_KILLER_BEE_LARVA

    case BRANCH_HIVE:
        return (monster->type == MONS_KILLER_BEE_LARVA

                || monster->type == MONS_QUEEN_BEE)
            {
                return true;
            }
            return false;

                || monster->type == MONS_QUEEN_BEE);

        case BRANCH_HALL_OF_BLADES:
            if (monster->type == MONS_DANCING_WEAPON)
                return true;
            return false;

    case BRANCH_HALL_OF_BLADES:
        return (monster->type == MONS_DANCING_WEAPON);

        default:
            return false;

    default:
        return false;

    const habitat_type habitat = mons_habitat(monster->type);

    const habitat_type habitat = mons_habitat(monster);

            if (mons_res_fire(monster) > 0)

            if (mons_res_fire(monster) > 1)

            if (mons_res_cold(monster) > 0)

            if (mons_res_cold(monster) > 1)

    const habitat_type habitat = mons_habitat(monster->type);

    const habitat_type habitat = mons_habitat(monster);

        if (mons_res_fire(monster) > 0)
            return;

        hurted += ((random2avg(16, 3) + 6) * 10) / speed;

        hurted +=
            resist_adjust_damage( monster,
                                  monster->res_fire(),
                                  ((random2avg(16, 3) + 6) * 10) / speed );

        if (mons_res_fire(monster) < 0)
            hurted += (random2(15) * 10) / speed;
        // remember that the above is in addition to the other you.damage.

        if (mons_res_cold(monster) > 0)
            return;
        hurted += ((6 + random2avg(16, 3)) * 10) / speed;

        hurted +=
            resist_adjust_damage( monster,
                                  monster->res_cold(),
                                  ((6 + random2avg(16, 3)) * 10) / speed );

        if (mons_res_cold(monster) < 0)
            hurted += (random2(15) * 10) / speed;
        // remember that the above is in addition to the other damage.

        if (mons_res_fire(monster) > 0)
            return;

        hurted += (random2avg(steam_base_damage, 2) * 10) / speed;
        if (mons_res_fire(monster) < 0)
            hurted += (random2(steam_base_damage / 2 + 1) * 10) / speed;

        hurted +=
            resist_adjust_damage(
                monster,
                monster->res_steam(),
                (random2avg(steam_base_damage, 2) * 10) / speed);

#include "ghost.h"

    std::string ghost_class = get_class_name(ghost.values[GVAL_CLASS]);

    std::string ghost_class = get_class_name(ghost.job);

bool monster_can_submerge(int monster_class, int grid);

bool monster_can_submerge(const monsters *mons, dungeon_feature_type grid);

#include "ghost.h"

    return (monster_habitable_grid(m->type, actual_grid, mons_flies(m),

    // Zombified monsters enjoy the same habitat as their original.
    const int type = mons_is_zombified(m)? mons_zombie_base(m) : m->type;
    return (monster_habitable_grid(type, actual_grid, mons_flies(m),

        habitat2grid( mons_habitat(monster_class) );

        habitat2grid( mons_habitat_by_type(monster_class) );

bool monster_can_submerge(int monster_class, int grid)

bool monster_can_submerge(const monsters *mons, dungeon_feature_type grid)

    const habitat_type habitat = mons_habitat(monster_class);

    switch (mons_habitat(mons))
    {
    case HT_WATER:
        // Monsters can submerge in shallow water - this is intentional.
        return grid_is_watery(grid);

    if (habitat == HT_WATER &&
           (grid == DNGN_DEEP_WATER || grid == DNGN_BLUE_FOUNTAIN))
    {
        return true;
    }

    case HT_LAVA:
        return (grid == DNGN_LAVA);

    if (habitat == HT_LAVA && grid == DNGN_LAVA)
    {
        return true;

    default:
        return false;

    return false;

        dungeon_feature_type grid_wanted = habitat2grid( mons_habitat(mon_type) );

        dungeon_feature_type grid_wanted =
            habitat2grid( mons_habitat_by_type(mon_type) );

        grid_wanted = habitat2grid( mons_habitat(mon_type) );

        grid_wanted = habitat2grid( mons_habitat_by_type(mon_type) );

    if (monster_can_submerge(mon_type, grd[fx][fy])

    if (monster_can_submerge(&menv[id], grd[fx][fy])

    dungeon_feature_type spcw = ((mons_class == RANDOM_MONSTER) ? DNGN_FLOOR
                                              : habitat2grid( mons_habitat(mons_class) ));

    dungeon_feature_type spcw =
        ((mons_class == RANDOM_MONSTER) ? DNGN_FLOOR
         : habitat2grid( mons_habitat_by_type(mons_class) ));

    MR_VUL_BLUDGEON      = (1<<16)

    MR_VUL_BLUDGEON      = (1<<16),
    // immune to stickiness of sticky flame.
    MR_RES_STICKY_FLAME  = (1 << 17),
    MR_RES_STEAM         = (1 << 18)

};
struct mon_resist_def
{
    // All values are actually saved as single-bytes, so practical
    // range is -128 - 127, and the game only distinguishes values in
    // the range -1 to 3.
    
    short elec;
    short poison;
    short fire;
    short steam;
    short cold;
    short hellfire;
    short asphyx;
    short acid;
    bool sticky_flame;
    // Physical damage resists (currently unused)
    short pierce;
    short slice;
    short bludgeon;
    mon_resist_def();
    mon_resist_def(int flags, short level = 1);
    mon_resist_def operator | (const mon_resist_def &other) const;
    const mon_resist_def &operator |= (const mon_resist_def &other);

typedef mon_resist_def mrd;

    unsigned long resists;

    mon_resist_def resists;

habitat_type mons_habitat(int mc);

// Use mons_habitat(const monster *) wherever possible since the other
// variant does not handle zombies correctly.
habitat_type mons_habitat(const monsters *m);
habitat_type mons_habitat_by_type(int mc);

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: beam - fight - monstuff
 * *********************************************************************** */

bool mons_res_sticky_flame( const monsters *mon );

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: beam - fight - spells4
 * *********************************************************************** */

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: beam - fight - monstuff
 * *********************************************************************** */

// last updated 12may2000 {dlb}
/* ***********************************************************************
 * called from: beam - monstuff - spells4
 * *********************************************************************** */

int mons_res_steam( const monsters *mon );

int mons_zombie_base(const monsters *monster);
bool mons_is_zombified(const monsters *monster);

#include "fight.h"
#include "ghost.h"

unsigned long get_mons_class_resists(int mc)

const mon_resist_def &get_mons_class_resists(int mc)

    return (smc->resists);

    const monsterentry *me = get_monster_data(mc);
    return (me? me->resists : get_monster_data(MONS_PROGRAM_BUG)->resists);

unsigned long get_mons_resists(const monsters *mon)

mon_resist_def get_mons_resists(const monsters *mon)

    unsigned long resists = get_mons_class_resists(mon->type);

    if (mon->type == MONS_PLAYER_GHOST || mon->type == MONS_PANDEMONIUM_DEMON)
        return (mon->ghost->resists);
    
    mon_resist_def resists = get_mons_class_resists(mon->type);

}
unsigned long mons_resist(const monsters *mon, unsigned long flags)
{
    return (get_mons_resists(mon) & flags);

    return (mons_habitat(mc) == HT_ROCK);

    return (mons_habitat_by_type(mc) == HT_ROCK);

        return (mon->ghost->values[ GVAL_SEE_INVIS ]);

        return (mon->ghost->see_invis);

            return mon_attack_def::attk(mons->ghost->values[GVAL_DAMAGE]);

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

    if (mc == MONS_PLAYER_GHOST || mc == MONS_PANDEMONIUM_DEMON)
        return (mon->ghost->values[ GVAL_RES_ELEC ]);

    if (mons_resist(mon, MR_RES_ELEC))
        u++;

    u += get_mons_resists(mon).elec;

                || mons_resist(mon, MR_RES_ASPHYX));

                || get_mons_resists(mon).asphyx > 0);

    const unsigned long f = get_mons_resists(mon);
    return ((f & MR_RES_ACID) != 0);

    return get_mons_resists(mon).acid;

    unsigned long u = 0, f = get_mons_resists(mon);

    int u = get_mons_resists(mon).poison;

    if (f & MR_RES_POISON)
        u++;
    if (f & MR_VUL_POISON)
        u--;

bool mons_res_sticky_flame( const monsters *mon )
{
    return (get_mons_resists(mon).sticky_flame
            || mon->has_equipped(EQ_BODY_ARMOUR, ARM_MOTTLED_DRAGON_ARMOUR));
}
int mons_res_steam( const monsters *mon )
{
    int res = get_mons_resists(mon).steam;
    if (mon->has_equipped(EQ_BODY_ARMOUR, ARM_STEAM_DRAGON_ARMOUR))
        res += 3;
    return (res + mons_res_fire(mon) / 2); 
}

    if (mc == MONS_PLAYER_GHOST || mc == MONS_PANDEMONIUM_DEMON)
        return (mon->ghost->values[ GVAL_RES_FIRE ]);
    int u = 0, f = get_mons_resists(mon);

    const mon_resist_def res = get_mons_resists(mon);
    
    int u = std::min(res.fire + res.hellfire * 3, 3);

    // no Big Prize (tm) here either if you set all three flags. It's a pity uh?
    //
    // Note that natural monster resistance is two levels, this is duplicate
    // the fact that having this flag used to be a lot better than armour
    // for monsters (it used to make them immune in a lot of cases) -- bwr
    if (f & MR_RES_HELLFIRE)
        u += 3;
    else if (f & MR_RES_FIRE)
        u += 2;
    else if (f & MR_VUL_FIRE)
        u--;

    if (mc == MONS_PLAYER_GHOST || mc == MONS_PANDEMONIUM_DEMON)
        return (mon->ghost->values[ GVAL_RES_COLD ]);
    int u = 0, f = get_mons_resists(mon);
    // Note that natural monster resistance is two levels, this is duplicate
    // the fact that having this flag used to be a lot better than armour
    // for monsters (it used to make them immune in a lot of cases) -- bwr
    if (f & MR_RES_COLD)
        u += 2;
    else if (f & MR_VUL_COLD)
        u--;

    int u = get_mons_resists(mon).cold;

        && mon->ghost->values[ GVAL_DEMONLORD_FLY ])

        && mon->ghost->fly)

        return (FL_FLY);

        return (mon->ghost->fly);

habitat_type mons_habitat(int mc)

habitat_type mons_habitat_by_type(int mc)
{
    const monsterentry *me = get_monster_data(mc);
    return (me? me->habitat : HT_LAND);
}
habitat_type mons_habitat(const monsters *m)

    return (smc->habitat);

    return mons_habitat_by_type(
        mons_is_zombified(m)? mons_zombie_base(m) : m->type );

        return m->ghost->values[ GVAL_BRAND ];

        return m->ghost->brand;

    // Keep friendly summoners from spamming summons constantly.
    if (mons_friendly(mon)
        && (!foe || foe == &you)
        && spell_typematch(monspell, SPTYP_SUMMONING))
    {
        return (true);
    }
    

// Empty destructor to keep auto_ptr happy with incomplete ghost_demon type.
monsters::~monsters()
{
}

    return (grid_is_watery(grid) && mons_habitat(type) == HT_WATER);

    return (grid_is_watery(grid) && mons_habitat(this) == HT_WATER);

            && mons_habitat(type) != HT_WATER

            && mons_habitat(this) != HT_WATER

        return (false);
    // Blademasters don't want to throw stuff.
    if (type == MONS_DEEP_ELF_BLADEMASTER)

}
int monsters::get_experience_level() const
{
    return (hit_dice);

                         name(DESC_NOCAP_YOUR).c_str()).c_str());

                         pronoun(PRONOUN_NOCAP_POSSESSIVE).c_str()).c_str());

int monsters::res_steam() const
{
    return (mons_res_steam(this));
}

    hit_dice = ghost->values[ GVAL_DEMONLORD_HIT_DICE ];
    hit_points = ghost->values[ GVAL_MAX_HP ];
    max_hit_points = ghost->values[ GVAL_MAX_HP ];
    ac = ghost->values[ GVAL_AC ];
    ev = ghost->values[ GVAL_EV ];
    speed = (one_chance_in(3) ? 10 : 6 + roll_dice(2, 9));

    hit_dice = ghost->xl;
    hit_points = ghost->max_hp;
    max_hit_points = ghost->max_hp;
    ac = ghost->ac;
    ev = ghost->ev;
    speed = (one_chance_in(3) ? 10 : 8 + roll_dice(2, 9));

    hit_dice = ghost->values[ GVAL_EXP_LEVEL ];
    hit_points = ghost->values[ GVAL_MAX_HP ];
    max_hit_points = ghost->values[ GVAL_MAX_HP ];
    ac = ghost->values[ GVAL_AC];
    ev = ghost->values[ GVAL_EV ];
    speed = ghost->values[ GVAL_SPEED ];

    hit_dice = ghost->xl;
    hit_points = ghost->max_hp;
    max_hit_points = ghost->max_hp;
    ac = ghost->ac;
    ev = ghost->ev;
    speed = ghost->speed;

    {
        for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; i++)
        {
            spells[i] =
                static_cast<spell_type>( ghost->values[ GVAL_SPELL_1 + i ] );
#if DEBUG_DIAGNOSTICS
            mprf( MSGCH_DIAGNOSTICS, "spell #%d: %d", i, spells[i] );
#endif
        }
    }

        spells = ghost->spells;

#if DEBUG_DIAGNOSTICS
    for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; i++)
        mprf( MSGCH_DIAGNOSTICS, "Spell #%d: %d (%s)",
              i, spells[i], spell_title(spells[i]) );
#endif

        int grid = grd[x][y];

        const dungeon_feature_type grid = grd[x][y];

        if (!monster_can_submerge(type, grid))

        if (!monster_can_submerge(this, grid))

        int dam = roll_dice( 2, 4 ) - 1;

        int dam =
            resist_adjust_damage(this, res_fire(), roll_dice( 2, 4 ) - 1);

        if (mons_res_fire( this ) < 0)
            dam += roll_dice( 2, 5 ) - 1;

        && !monster_can_submerge(type, grd[x][y]))

        && !monster_can_submerge(this, grd[x][y]))

        msg = replace_all(msg, "@says@", "bugilly says");

        msg = replace_all(msg, "@says@", "buggily says");

    switch(ghost.values[GVAL_SPECIES])

    switch (ghost.species)

    }

    return (MON_SHAPE_HUMANOID);

    default:
        return (MON_SHAPE_HUMANOID);
    }

/////////////////////////////////////////////////////////////////////////
// mon_resist_def
mon_resist_def::mon_resist_def()
    : elec(0), poison(0), fire(0), steam(0), cold(0), hellfire(0),
      asphyx(0), acid(0), sticky_flame(false), pierce(0),
      slice(0), bludgeon(0)
{
}
mon_resist_def::mon_resist_def(int flags, short level)
    : elec(0), poison(0), fire(0), steam(0), cold(0), hellfire(0),
      asphyx(0), acid(0), sticky_flame(false), pierce(0),
      slice(0), bludgeon(0)
{
    for (int i = 0; i < 32; ++i)
    {
        switch (flags & (1 << i))
        {
        case MR_RES_STEAM:   steam = 3; break; 
        case MR_RES_ELEC:    elec = level; break;
        case MR_RES_POISON:  poison = level; break;
        case MR_RES_FIRE:    fire = level; break;
        case MR_RES_HELLFIRE: hellfire = level; break;
        case MR_RES_COLD:    cold = level; break;
        case MR_RES_ASPHYX:  asphyx = level; break;
        case MR_RES_ACID:    acid = level; break;
        case MR_VUL_ELEC:    elec = -level; break;
        case MR_VUL_POISON:  poison = -level; break;
        case MR_VUL_FIRE:    fire = -level; break;
        case MR_VUL_COLD:    cold = -level; break;
        
        case MR_RES_PIERCE:  pierce = level; break;
        case MR_RES_SLICE:   slice = level; break;
        case MR_RES_BLUDGEON: bludgeon = level; break;
        case MR_VUL_PIERCE:  pierce = -level; break;
        case MR_VUL_SLICE:   slice = -level; break;
        case MR_VUL_BLUDGEON: bludgeon = -level; break;
        case MR_RES_STICKY_FLAME: sticky_flame = true; break;
        default: break;
        }
    }
}
const mon_resist_def &mon_resist_def::operator |= (const mon_resist_def &o)
{
    elec += o.elec;
    poison += o.poison;
    fire += o.fire;
    cold += o.cold;
    hellfire += o.hellfire;
    asphyx += o.asphyx;
    acid += o.acid;
    pierce += o.pierce;
    slice += o.slice;
    bludgeon += o.bludgeon;
    sticky_flame = sticky_flame || o.sticky_flame;
    return (*this);
}
mon_resist_def mon_resist_def::operator | (const mon_resist_def &o) const
{
    mon_resist_def c(*this);
    return (c |= o);
}

    MR_RES_POISON | MR_RES_FIRE,

    MR_RES_POISON | MR_RES_FIRE | MR_RES_STICKY_FLAME,

    MR_RES_FIRE,

    MR_RES_FIRE | MR_RES_STICKY_FLAME,

        if (!yesno("Enter next level anyways?", true, 0, true, false))

        if (!yesno("Enter next level anyway?", true, 0, true, false))

        char keypress = 0;

        int keypress = 0;

        while (keypress != ' ' && keypress != '\r' && keypress != '\n');

        while (keypress != ' ' && keypress != '\r' && keypress != '\n'
               && keypress != -1);

        return (c);

        // getch() returns -1 on EOF, convert that into an Escape. Evil hack,
        // but the alternative is to explicitly check for -1 everywhere where
        // we might otherwise spin in a tight keyboard input loop.
        return (c == -1? ESCAPE : c);

    SPWPN_RETURNING,

    MAX_PAN_LORD_BRANDS,               //   18
    
    SPWPN_RETURNING = MAX_PAN_LORD_BRANDS,

        && (ident || item_ident(*this, ISFLAG_KNOW_TYPE));

        && (ident || item_type_known(*this));

                (get_weapon_brand(*this) == SPWPN_VAMPIRICISM))

            (get_weapon_brand(*this) == SPWPN_VAMPIRICISM))

                buff << "vampiric ";

            buff << "vampiric ";

    if ( is_artefact(item) )

    if (is_artefact(item))

    // Poisoned missiles are always identified.
    if (item.base_type == OBJ_MISSILES)
    {
        int ammo_brand = get_ammo_brand(item);
        if (ammo_brand == SPMSL_POISONED || ammo_brand == SPMSL_CURARE)
            return (true);
    }

#ifndef GHOST_H
#define GHOST_H
#include "externs.h"
#include "enum.h"
#include "itemprop.h"
#include "mon-util.h"
struct ghost_demon
{
public:
    std::string name;
    species_type species;
    job_type job;
    skill_type best_skill;
    short best_skill_level;
    short xl;
    
    short max_hp, ev, ac, damage, speed;
    bool see_invis;
    brand_type brand;
    mon_resist_def resists;
    bool spellcaster, cycle_colours;
    flight_type fly;
    monster_spells spells;
public:
    ghost_demon();
    void reset();
    void init_random_demon();
    void init_player_ghost();
public:
    static std::vector<ghost_demon> find_ghosts();
private:
    static int n_extra_ghosts();
    static void find_extra_ghosts(std::vector<ghost_demon> &ghosts, int n);
    static void find_transiting_ghosts(std::vector<ghost_demon> &gs, int n);
    static void announce_ghost(const ghost_demon &g);
    
private:
    void add_spells();
    spell_type translate_spell(spell_type playerspell) const;
};
extern std::vector<ghost_demon> ghosts;
#endif

#include "ghost.h"

ghost_demon::ghost_demon() : name(), values()

ghost_demon::ghost_demon()

    values.init(0);
    values[GVAL_SPEED] = 10;

    species = SP_UNKNOWN;
    job = JOB_UNKNOWN;
    best_skill = SK_FIGHTING;
    best_skill_level = 0;
    xl = 0;
    max_hp = 0;
    ev = 0;
    ac = 0;
    damage = 0;
    speed = 10;
    see_invis = false;
    brand = SPWPN_NORMAL;
    resists = mon_resist_def();
    spellcaster = false;
    cycle_colours = false;
    fly = FL_NONE;

    values[ GVAL_MAX_HP ] = 100 + roll_dice( 3, 50 );

    max_hp = 100 + roll_dice( 3, 50 );

    values[ GVAL_EV ] = 5 + random2(20);
    values[ GVAL_AC ] = 5 + random2(20);

    ev = 5 + random2(20);
    ac = 5 + random2(20);

    values[ GVAL_SEE_INVIS ] = (one_chance_in(10) ? 0 : 1);

    see_invis = !one_chance_in(10);

        values[ GVAL_RES_FIRE ] = (coinflip() ? 2 : 3);

        resists.fire = random_range(1, 2);

        values[ GVAL_RES_FIRE ] = 0;    /* res_fire */

        resists.fire = 0;    /* res_fire */

            values[ GVAL_RES_FIRE ] = -1;

            resists.fire = -1;

        values[ GVAL_RES_COLD ] = 2;

        resists.cold = random_range(1, 2);

        values[ GVAL_RES_COLD ] = 0;    /* res_cold */

        resists.cold = 0;

            values[ GVAL_RES_COLD ] = -1;

            resists.cold = -1;

    values[ GVAL_RES_ELEC ] = !one_chance_in(3);

    resists.elec = one_chance_in(3);

    values[ GVAL_DAMAGE ] = 20 + roll_dice( 2, 20 );

    damage = 20 + roll_dice( 2, 20 );

    values[ GVAL_BRAND ] = SPWPN_NORMAL;

    brand = SPWPN_NORMAL;

            values[ GVAL_BRAND ] = random2(17);

            brand = static_cast<brand_type>( random2(MAX_PAN_LORD_BRANDS) );

        } while (values[ GVAL_BRAND ] == SPWPN_HOLY_WRATH 
                 || (values[ GVAL_BRAND ] == SPWPN_ORC_SLAYING

        } while (brand == SPWPN_HOLY_WRATH 
                 || (brand == SPWPN_ORC_SLAYING

                 || (values[ GVAL_BRAND ] == SPWPN_DRAGON_SLAYING

                 || (brand == SPWPN_DRAGON_SLAYING

                 || values[ GVAL_BRAND ] == SPWPN_PROTECTION 
                 || values[ GVAL_BRAND ] == SPWPN_FLAME 
                 || values[ GVAL_BRAND ] == SPWPN_FROST);

                 || brand == SPWPN_PROTECTION 
                 || brand == SPWPN_FLAME 
                 || brand == SPWPN_FROST);

    values[GVAL_DEMONLORD_SPELLCASTER] = !one_chance_in(10);

    spellcaster = !one_chance_in(10);

    // does demon fly? (0 = no, 1 = fly, 2 = levitate)
    values[GVAL_DEMONLORD_FLY] = (one_chance_in(3) ? 0 : 
                                  one_chance_in(5) ? 2 : 1);
    // vacant <ghost best skill level>:
    values[GVAL_DEMONLORD_UNUSED] = 0;

    // does demon fly?
    fly = (one_chance_in(3)? FL_NONE :
           one_chance_in(5)? FL_LEVITATE : FL_FLY);
    

    values[GVAL_DEMONLORD_HIT_DICE] = 10 + roll_dice(2, 10);

    xl = 10 + roll_dice(2, 10);

    values[GVAL_DEMONLORD_CYCLE_COLOUR] = (one_chance_in(10) ? 1 : 0);

    cycle_colours = one_chance_in(10);

    for (int i = GVAL_SPELL_1; i <= GVAL_SPELL_6; i++)
        values[i] = SPELL_NO_SPELL;

    spells.init(SPELL_NO_SPELL);

    if (values[ GVAL_DEMONLORD_SPELLCASTER ] == 1)

    if (spellcaster)

            values[GVAL_SPELL_1] = RANDOM_ELEMENT(search_order_conj);

            spells[0] = RANDOM_ELEMENT(search_order_conj);

            values[GVAL_SPELL_2] = RANDOM_ELEMENT(search_order_conj);

            spells[1] = RANDOM_ELEMENT(search_order_conj);

            values[GVAL_SPELL_3] = RANDOM_ELEMENT(search_order_third);

            spells[2] = RANDOM_ELEMENT(search_order_third);

            values[GVAL_SPELL_4] = RANDOM_ELEMENT(search_order_misc);
            if ( values[GVAL_SPELL_4] == SPELL_DIG )
                values[GVAL_SPELL_4] = SPELL_NO_SPELL;

            spells[3] = RANDOM_ELEMENT(search_order_misc);
            if ( spells[3] == SPELL_DIG )
                spells[3] = SPELL_NO_SPELL;

            values[GVAL_SPELL_5] = RANDOM_ELEMENT(search_order_misc);

            spells[4] = RANDOM_ELEMENT(search_order_misc);

            values[ GVAL_SPELL_6 ] = SPELL_BLINK;

            spells[5] = SPELL_BLINK;

            values[ GVAL_SPELL_6 ] = SPELL_TELEPORT_SELF;

            spells[5] = SPELL_TELEPORT_SELF;

        for (int i = GVAL_SPELL_1; i <= GVAL_SPELL_6; i++)
            values[i] = translate_spell( values[i] );

        for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; i++)
            spells[i] = translate_spell( spells[i] );

            values[GVAL_SPELL_1] = SPELL_HELLFIRE_BURST;

            spells[0] = SPELL_HELLFIRE_BURST;

            values[GVAL_SPELL_1] = SPELL_METAL_SPLINTERS;

            spells[0] = SPELL_METAL_SPLINTERS;

            values[GVAL_SPELL_1] = SPELL_ENERGY_BOLT;  /* eye of devas */

            spells[0] = SPELL_ENERGY_BOLT;  /* eye of devas */

            values[GVAL_SPELL_2] = SPELL_STEAM_BALL;

            spells[1] = SPELL_STEAM_BALL;

            values[GVAL_SPELL_2] = SPELL_ISKENDERUNS_MYSTIC_BLAST;

            spells[1] = SPELL_ISKENDERUNS_MYSTIC_BLAST;

            values[GVAL_SPELL_2] = SPELL_HELLFIRE;

            spells[1] = SPELL_HELLFIRE;

            values[GVAL_SPELL_3] = SPELL_SMITING;

            spells[2] = SPELL_SMITING;

            values[GVAL_SPELL_3] = SPELL_HELLFIRE_BURST;

            spells[2] = SPELL_HELLFIRE_BURST;

            values[GVAL_SPELL_3] = SPELL_SUMMON_GREATER_DEMON;

            spells[2] = SPELL_SUMMON_GREATER_DEMON;

            values[GVAL_SPELL_3] = SPELL_SUMMON_DEMON;

            spells[2] = SPELL_SUMMON_DEMON;

            values[GVAL_SPELL_4] = SPELL_SUMMON_GREATER_DEMON;

            spells[3] = SPELL_SUMMON_GREATER_DEMON;

            values[GVAL_SPELL_4] = SPELL_SUMMON_DEMON;

            spells[3] = SPELL_SUMMON_DEMON;

        if (values[GVAL_SPELL_4] == SPELL_NO_SPELL)
            values[GVAL_SPELL_4] = SPELL_SUMMON_DEMON;

        if (spells[3] == SPELL_NO_SPELL)
            spells[3] = SPELL_SUMMON_DEMON;

            values[GVAL_SPELL_5] = SPELL_DIG;

            spells[4] = SPELL_DIG;

    values[ GVAL_MAX_HP ]    = ((you.hp_max >= 400) ? 400 : you.hp_max);
    values[ GVAL_EV ]        = player_evasion();
    values[ GVAL_AC ]        = player_AC();

    max_hp = ((you.hp_max >= 400) ? 400 : you.hp_max);
    ev     = player_evasion();
    ac     = player_AC();

    if (values[GVAL_EV] > 40)
        values[GVAL_EV] = 40;
    
    values[ GVAL_SEE_INVIS ] = player_see_invis();
    values[ GVAL_RES_FIRE ]  = player_res_fire();
    values[ GVAL_RES_COLD ]  = player_res_cold();
    values[ GVAL_RES_ELEC ]  = player_res_electricity();
    values[ GVAL_SPEED ]     = player_ghost_base_movement_speed();

    if (ev > 60)
        ev = 60;
    see_invis = player_see_invis();
    resists.fire = player_res_fire();
    resists.cold = player_res_cold();
    resists.elec = player_res_electricity();
    speed = player_ghost_base_movement_speed();

    int e = 0;

    int e = SPWPN_NORMAL;

    values[ GVAL_DAMAGE ] = d;
    values[ GVAL_BRAND ]  = e;
    values[ GVAL_SPECIES ] = you.species;
    values[ GVAL_BEST_SKILL ] = best_skill(SK_FIGHTING, (NUM_SKILLS - 1), 99);
    values[ GVAL_SKILL_LEVEL ] =
        you.skills[best_skill(SK_FIGHTING, (NUM_SKILLS - 1), 99)];
    values[ GVAL_EXP_LEVEL ] = you.experience_level;
    values[ GVAL_CLASS ] = you.char_class;

    damage = d;
    brand  = static_cast<brand_type>( e );
    species = you.species;
    best_skill = ::best_skill(SK_FIGHTING, (NUM_SKILLS - 1), 99);
    best_skill_level = you.skills[best_skill];
    xl = you.experience_level;
    job = you.char_class;

static int search_first_list(int ignore_spell)

static spell_type search_first_list(int ignore_spell)

static int search_second_list(int ignore_spell)

static spell_type search_second_list(int ignore_spell)

static int search_third_list(int ignore_spell)

static spell_type search_third_list(int ignore_spell)

    for (i = GVAL_SPELL_1; i <= GVAL_SPELL_6; i++)
        values[i] = SPELL_NO_SPELL;

    spells.init(SPELL_NO_SPELL);

    values[ GVAL_SPELL_1 ] = search_first_list(SPELL_NO_SPELL);
    values[ GVAL_SPELL_2 ] = search_first_list(values[GVAL_SPELL_1]);
    values[ GVAL_SPELL_3 ] = search_second_list(SPELL_NO_SPELL);
    values[ GVAL_SPELL_4 ] = search_third_list(SPELL_DIG);

    spells[ 0 ] = search_first_list(SPELL_NO_SPELL);
    spells[ 1 ] = search_first_list(spells[0]);
    spells[ 2 ] = search_second_list(SPELL_NO_SPELL);
    spells[ 3 ] = search_third_list(SPELL_DIG);

    if (values[ GVAL_SPELL_4 ] == SPELL_NO_SPELL)
        values[ GVAL_SPELL_4 ] = search_first_list(SPELL_NO_SPELL);

    if (spells[ 3 ] == SPELL_NO_SPELL)
        spells[ 3 ] = search_first_list(SPELL_NO_SPELL);

    values[ GVAL_SPELL_5 ] = search_third_list(values[GVAL_SPELL_4]);

    spells[ 4 ] = search_third_list(spells[3]);

    if (values[ GVAL_SPELL_5 ] == SPELL_NO_SPELL)
        values[ GVAL_SPELL_5 ] = search_first_list(values[GVAL_SPELL_4]);

    if (spells[ 4 ] == SPELL_NO_SPELL)
        spells[ 4 ] = search_first_list(spells[3]);

        values[ GVAL_SPELL_5 ] = SPELL_DIG;

        spells[ 4 ] = SPELL_DIG;

        values[ GVAL_SPELL_6 ] = SPELL_CONTROLLED_BLINK;

        spells[ 5 ] = SPELL_CONTROLLED_BLINK;

        values[ GVAL_SPELL_6 ] = SPELL_TELEPORT_SELF;

        spells[ 5 ] = SPELL_TELEPORT_SELF;

    for (i = GVAL_SPELL_1; i <= GVAL_SPELL_6; i++)
        values[i] = translate_spell( values[i] );

    for (i = 0; i < NUM_MONSTER_SPELL_SLOTS; i++)
        spells[i] = translate_spell( spells[i] );

int ghost_demon::translate_spell(int spel) const

spell_type ghost_demon::translate_spell(spell_type spel) const

#include "ghost.h"

const short GHOST_SIGNATURE = static_cast<short>( 0xDC55 );

static void write_version( FILE *dataFile, int majorVersion, int minorVersion,
                           bool extended_version )
{
    // write version
    tagHeader versionTag;
    versionTag.offset = 0;
    versionTag.tagID = TAG_VERSION;
    marshallByte(versionTag, majorVersion);
    marshallByte(versionTag, minorVersion);
    // extended_version just pads the version out to four 32-bit words.
    // This makes the bones file compatible with Hearse with no extra
    // munging needed.
    if (extended_version)
    {
        // Use a single signature 16-bit word to indicate that this is
        // Stone Soup and to disambiguate this (unmunged) bones file
        // from the munged bones files offered by the old Crawl-aware
        // hearse.pl. Crawl-aware hearse.pl will prefix the bones file
        // with the first 16-bits of the Crawl version, and the following
        // 7 16-bit words set to 0.
        marshallShort(versionTag, GHOST_SIGNATURE);
        
        // Write the three remaining 32-bit words of padding.
        for (int i = 0; i < 3; ++i)
            marshallLong(versionTag, 0);
    }
    tag_write(versionTag, dataFile);
}

                               char minorVersion, int fileType )

                               char minorVersion, int fileType,
                               bool extended_version = false )

    // write version
    struct tagHeader versionTag;
    versionTag.offset = 0;
    versionTag.tagID = TAG_VERSION;
    marshallByte(versionTag, majorVersion);
    marshallByte(versionTag, minorVersion);
    tag_write(versionTag, dataFile);

    write_version( dataFile, majorVersion, minorVersion, extended_version );

    // check for pre-v4 -- simply started right in with ghost name.
    if (isprint(buf[0]) && buf[0] > 4)
    {
        majorVersion = 0;
        minorVersion = 0;
        rewind(ghostFile);
        return true;
    }

    if (majorVersion == SAVE_MAJOR_VERSION)
        return true;

    // check for the DCSS ghost signature.
    if (readShort(ghostFile) != GHOST_SIGNATURE)
        return (false);
    if (majorVersion == SAVE_MAJOR_VERSION
        && minorVersion <= GHOST_MINOR_VERSION)
    {
        // Discard three more 32-bit words of padding.
        for (int i = 0; i < 3; ++i)
            readLong(ghostFile);
        
        return !feof(ghostFile);
    }

                       GHOST_MINOR_VERSION, TAGTYPE_GHOST );

                       GHOST_MINOR_VERSION, TAGTYPE_GHOST,
                       true );

int resist_adjust_damage(actor *defender, int res, int rawdamage,
                         bool ranged = false);

    int resist_adjust_damage(int res, int rawdamage);

int melee_attack::resist_adjust_damage(int res, int rawdamage)

int resist_adjust_damage(actor *defender, int res, int rawdamage,
                         bool ranged)

    if (defender->atype() == ACT_MONSTER && res >= 3)
        return (0);
    

    {
        if (defender->atype() == ACT_MONSTER)
            rawdamage = 0;
        else
            rawdamage /= 1 + res * res;
    }

        rawdamage /= 1 + res * res;

        rawdamage *= 2;

        rawdamage = rawdamage * (ranged? 15 : 20) / 10;

    special_damage = resist_adjust_damage(res, random2(damage_done) / 2 + 1);

    special_damage =
        resist_adjust_damage(defender, res, random2(damage_done) / 2 + 1);

        // FIXME: Generalise.
        if (defender->atype() != ACT_MONSTER || attacker->atype() != ACT_PLAYER)
            break;
        

        if (hdcheck >= def->hit_dice)

        if (hdcheck >= defender->get_experience_level())

            beam_temp.thrower = KILL_YOU;
            beam_temp.flavour = BEAM_CONFUSION;        

            beam_temp.thrower =
                attacker->atype() == ACT_PLAYER? KILL_YOU : KILL_MON;
            beam_temp.flavour = BEAM_CONFUSION;
            beam_temp.beam_source =
                attacker->atype() == ACT_PLAYER? MHITYOU
                : monster_index(atk);

        you.duration[DUR_CONFUSING_TOUCH] -= roll_dice(3, 5);

        if (attacker->atype() == ACT_PLAYER)
        {
            you.duration[DUR_CONFUSING_TOUCH] -= roll_dice(3, 5);

        if (you.duration[DUR_CONFUSING_TOUCH] < 1)
            you.duration[DUR_CONFUSING_TOUCH] = 1;

            if (you.duration[DUR_CONFUSING_TOUCH] < 1)
                you.duration[DUR_CONFUSING_TOUCH] = 1;
        }

        if (mons_res_elec(def))
            break;
        special_damage = player_staff_damage(SK_AIR_MAGIC);

        special_damage =
            resist_adjust_damage(defender,
                                 defender->res_elec(),
                                 player_staff_damage(SK_AIR_MAGIC));

        if (mons_res_cold(def) > 0)
            break;
        special_damage = player_staff_damage(SK_ICE_MAGIC);
        if (mons_res_cold(def) < 0)
            special_damage += player_staff_damage(SK_ICE_MAGIC);

        special_damage =
            resist_adjust_damage(defender,
                                 defender->res_cold(),
                                 player_staff_damage(SK_ICE_MAGIC));

        if (mons_res_fire(def) > 0)
            break;
        special_damage = player_staff_damage(SK_FIRE_MAGIC);
        if (mons_res_fire(def) < 0)
            special_damage += player_staff_damage(SK_FIRE_MAGIC);

        special_damage =
            resist_adjust_damage(defender,
                                 defender->res_fire(),
                                 player_staff_damage(SK_FIRE_MAGIC));

        dec_mp(staff_cost);

            resist_adjust_damage(defender->res_fire(),

            resist_adjust_damage(defender,
                                 defender->res_fire(),

            resist_adjust_damage(defender->res_cold(),

            resist_adjust_damage(defender,
                                 defender->res_cold(),

                defender,

    virtual int       get_experience_level() const = 0;

    virtual const item_def *slot_item(equipment_type eq) const
    {
        return const_cast<actor*>(this)->slot_item(eq);
    }
    virtual bool has_equipped(equipment_type eq, int sub_type) const;

    virtual int res_steam() const = 0;

    const item_def *slot_item(equipment_type eq) const;

    int       get_experience_level() const;

    int res_steam() const;

    ~monsters();

    int       get_experience_level() const;    

    int res_steam() const;    

struct ghost_demon
{
public:
    std::string name;
    FixedVector< short, NUM_GHOST_VALUES > values;
public:
    ghost_demon();
    void reset();
    void init_random_demon();
    void init_player_ghost();
public:
    static std::vector<ghost_demon> find_ghosts();
private:
    static int n_extra_ghosts();
    static void find_extra_ghosts(std::vector<ghost_demon> &ghosts, int n);
    static void find_transiting_ghosts(std::vector<ghost_demon> &gs, int n);
    static void announce_ghost(const ghost_demon &g);
    
private:
    void add_spells();
    int  translate_spell(int playerspell) const;
};

extern std::vector<ghost_demon> ghosts;

enum ghost_value_type
{
    GVAL_MAX_HP,        // 0
    GVAL_EV,
    GVAL_AC,
    GVAL_SEE_INVIS,
    GVAL_RES_FIRE,
    GVAL_RES_COLD,      // 5
    GVAL_RES_ELEC,
    GVAL_DAMAGE,
    GVAL_BRAND,
    GVAL_SPECIES,
    GVAL_BEST_SKILL,    // 10
    GVAL_SKILL_LEVEL,
    GVAL_EXP_LEVEL,
    GVAL_CLASS,
    GVAL_SPELL_1,       // 14
    GVAL_SPELL_2,
    GVAL_SPELL_3,
    GVAL_SPELL_4,
    GVAL_SPELL_5,
    GVAL_SPELL_6,       // 19
    GVAL_SPEED,
    NUM_GHOST_VALUES,   // should always be last value
    // these values are for demonlords, which override the above:
    GVAL_DEMONLORD_SPELLCASTER = 9,
    GVAL_DEMONLORD_FLY,                 // 10
    GVAL_DEMONLORD_UNUSED,              // 11
    GVAL_DEMONLORD_HIT_DICE,            // 12
    GVAL_DEMONLORD_CYCLE_COLOUR         // 13
};

// Sets foe target of friendly monsters.
static void set_friendly_foes()
{
    for (int i = 0; i < MAX_MONSTERS; ++i)
    {
        monsters *mon(&menv[i]);
        if (!mon->alive() || !mons_near(mon) || !mons_friendly(mon))
            continue;
        mon->foe = you.pet_target;
    }
}

                mprf("You feel a strong urge to %s, but you are unable to make a sound!",

                mprf("You feel a strong urge to %s, but "
                     "you are unable to make a sound!",

                mprf("You feel a %s rip itself from your throat, but you make no sound!",

                mprf("You feel a %s rip itself from your throat, "
                     "but you make no sound!",

            struct monsters *target = &menv[you.prev_targ];
            if (mons_near(target) && player_monster_visible(target))

            monsters *target = &menv[you.prev_targ];
            if (target->alive() && mons_near(target)
                && player_monster_visible(target))

    you.pet_target = mons_targd;

    if (mons_targd != MHITNOT)
    {
        you.pet_target = mons_targd;
        set_friendly_foes();
    }

        if (mons_habitat( mon->type ) != HT_LAND

        if (mons_habitat( mon ) != HT_LAND

    // for some weird reason can't put a vault on level 1, because monster equip
    // isn't generated.

    // hack - passing chars through '...' promotes them to ints, which
    // barfs under gcc in fixvec.h.  So don't.

            const habitat_type habitat = mons_habitat(mid);

            const habitat_type habitat = mons_habitat_by_type(mid);

                      yesno("Are you sure you want to fizzle?") )

                      yesno("Are you sure you want to fizzle?", false, 'n') )

#include "ghost.h"

    switch (ghost.values[GVAL_DEMONLORD_FLY])

    switch (ghost.fly)

    case 1:

    case FL_FLY:

    case 2: // levitation

    case FL_LEVITATE:

    default:  // does not fly

    case FL_NONE:  // does not fly

    const species_type gspecies =
        static_cast<species_type>(ghost.values[GVAL_SPECIES]);

    const species_type gspecies = ghost.species;

         << skill_title( ghost.values[GVAL_BEST_SKILL], 
                         ghost.values[GVAL_SKILL_LEVEL],

         << skill_title( ghost.best_skill,
                         ghost.best_skill_level,

         << ((ghost.values[GVAL_EXP_LEVEL] <  4) ? " weakling" :
             (ghost.values[GVAL_EXP_LEVEL] <  7) ? "n average" :
             (ghost.values[GVAL_EXP_LEVEL] < 11) ? "n experienced" :
             (ghost.values[GVAL_EXP_LEVEL] < 16) ? " powerful" :
             (ghost.values[GVAL_EXP_LEVEL] < 22) ? " mighty" :
             (ghost.values[GVAL_EXP_LEVEL] < 26) ? " great" :
             (ghost.values[GVAL_EXP_LEVEL] < 27) ? "n awesomely powerful"
                                                 : " legendary")

         << ((ghost.xl <  4) ? " weakling" :
             (ghost.xl <  7) ? "n average" :
             (ghost.xl < 11) ? "n experienced" :
             (ghost.xl < 16) ? " powerful" :
             (ghost.xl < 22) ? " mighty" :
             (ghost.xl < 26) ? " great" :
             (ghost.xl < 27) ? "n awesomely powerful"
                             : " legendary")

             << get_class_abbrev(ghost.values[GVAL_CLASS]);

             << get_class_abbrev(ghost.job);

                             ghost.values[GVAL_EXP_LEVEL])

                             ghost.xl)

             << get_class_name(ghost.values[GVAL_CLASS]);

             << get_class_name(ghost.job);

               "still use deck?"))

               "still use deck?", true, 'n'))

#include "ghost.h"

        ghost.values.init(0);

        ghost.values[GVAL_CLASS] = class_id;

        ghost.job = static_cast<job_type>(class_id);