you.where_are_you = unmarshallByte(th);

    you.where_are_you = static_cast<branch_type>( unmarshallByte(th) );

    you.level_type = unmarshallByte(th);

    you.level_type = static_cast<level_area_type>( unmarshallByte(th) );

            int cont_points = nastiness / 500;
            // handle fraction
            if (random2(500) < (nastiness % 500))
                cont_points++;

            const int cont_points = div_rand_round(nastiness, 500);

            miscast_effect( sptype, spell_mana(spc2), spell_fail(spc2) - spfl, 100 );

            miscast_effect( sptype, spell_mana(spc2),
                            spell_fail(spc2) - spfl, 100 );

        default:
            break;

    case DESC_NOCAP_ITS:

                                      false, false ).c_str());

                                      LEVEL_DUNGEON, false ).c_str());

    // temp level, if any
    unlink( make_filename( you.your_name, 0, 0, true, false ).c_str() );

    // temp levels, if any
    unlink( make_filename( you.your_name, 0, 0, LEVEL_ABYSS, false ).c_str() );
    unlink( make_filename( you.your_name, 0, 0,
                           LEVEL_PANDEMONIUM, false ).c_str() );
    unlink( make_filename( you.your_name, 0, 0,
                           LEVEL_LABYRINTH, false ).c_str() );

m_transit_list *get_transit_list(level_id where);
void add_monster_to_transit(level_id dest, const monsters &m);

m_transit_list *get_transit_list(const level_id &where);
void add_monster_to_transit(const level_id &dest, const monsters &m);

m_transit_list *get_transit_list(level_id lid)

m_transit_list *get_transit_list(const level_id &lid)

void add_monster_to_transit(level_id lid, const monsters &m)

void add_monster_to_transit(const level_id &lid, const monsters &m)

static std::vector<int> monsters_by_habitat[NUM_HABITATS];

static std::vector<monster_type> monsters_by_habitat[NUM_HABITATS];

#define MONDATASIZE (sizeof(mondata)/sizeof(struct monsterentry))

#define MONDATASIZE (sizeof(mondata)/sizeof(monsterentry))

                monsters_by_habitat[i].push_back(m);

                monsters_by_habitat[i].push_back(static_cast<monster_type>(m));

    const std::vector<int> &valid_mons = monsters_by_habitat[ht];

    const std::vector<monster_type> &valid_mons = monsters_by_habitat[ht];

                 : monster_type(valid_mons[ random2(valid_mons.size()) ]);

                 : valid_mons[ random2(valid_mons.size()) ];

    return (ptr_monam(this, desc));

    const bool possessive =
        (desc == DESC_NOCAP_YOUR || desc == DESC_NOCAP_ITS);
    if (possessive)
        desc = DESC_NOCAP_THE;
    std::string mname = ptr_monam(this, desc);
    return (possessive? apostrophise(mname) : mname);

    return (pluralize(verb));

    return (pluralise(verb));

void monsters::set_transit(level_id dest)

void monsters::set_transit(const level_id &dest)

    unsigned char stair_find = grd[you.x_pos][you.y_pos];
    char old_where = you.where_are_you;
    bool was_a_labyrinth = false;

    int stair_find = grd[you.x_pos][you.y_pos];
    const branch_type old_where = you.where_are_you;
    const bool was_a_labyrinth = you.level_type != LEVEL_DUNGEON;

    unsigned char old_level  = you.your_level;

    int old_level  = you.your_level;

    {

        was_a_labyrinth = true;
    }

    bool was_a_labyrinth = false;

    const bool was_a_labyrinth = you.level_type != LEVEL_DUNGEON;

    char old_where = you.where_are_you;

    branch_type old_where = you.where_are_you;

    if (you.level_type == LEVEL_PANDEMONIUM
            && stair_find == DNGN_TRANSIT_PANDEMONIUM)
    {
        was_a_labyrinth = true;
    }
    else

    if (you.level_type != LEVEL_DUNGEON
        && (you.level_type != LEVEL_PANDEMONIUM
            || stair_find != DNGN_TRANSIT_PANDEMONIUM))

        if (you.level_type != LEVEL_DUNGEON)
            was_a_labyrinth = true;

                                          true, false );

                                          you.level_type, false );

        snprintf( info, INFO_SIZE, "Deleting: %s", lname.c_str() );
    mpr( info, MSGCH_DIAGNOSTICS );

        mprf( MSGCH_DIAGNOSTICS, "Deleting: %s", lname.c_str() );

    announce_ghost(player);

                    announce_ghost(*m.ghost);

}
void ghost_demon::announce_ghost(const ghost_demon &g)
{
#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS, "Saving ghost: %s", g.name.c_str());
#endif

            announce_ghost(*menv[i].ghost);

void load( unsigned char stair_taken, int load_mode, bool was_a_labyrinth, 
           char old_level, char where_were_you2 );

void load( int stair_taken, int load_mode, bool was_a_labyrinth, 
           int old_level, branch_type where_were_you2 );

std::string make_filename( const char *prefix, int level, int where,
                           bool isLabyrinth, bool isGhost );

std::string make_filename( const char *prefix, int level, int branch,
                           level_area_type lt, bool isGhost );

void save_level(int level_saved, bool was_a_labyrinth, char where_were_you);

void save_level(int level_saved, level_area_type lt,
                branch_type where_were_you);

static std::string get_level_suffix(int level, int where, level_area_type lt)
{
    switch (lt)
    {
    default:
    case LEVEL_DUNGEON:
        return (make_stringf("%02d%c", level, where + 'a'));
    case LEVEL_LABYRINTH:
        return ("lab");
    case LEVEL_ABYSS:
        return ("abs");
    case LEVEL_PANDEMONIUM:
        return ("pan");
    }
}

                           bool isLabyrinth, bool isGhost )

                           level_area_type ltype, bool isGhost )

    char suffix[4], lvl[5];
    strcpy(suffix, (level < 10) ? "0" : "");
    itoa(level, lvl, 10);
    strcat(suffix, lvl);
    suffix[2] = where + 97;
    suffix[3] = 0;
    return get_savedir_filename( prefix, "", isLabyrinth ? "lab" : suffix,

    return get_savedir_filename( prefix, "",
                                 get_level_suffix(level, where, ltype),

                                          false, false).c_str(), "rb");

                                          LEVEL_DUNGEON, false).c_str(), "rb");

void load( unsigned char stair_taken, int load_mode, bool was_a_labyrinth,
           char old_level, char where_were_you2 )

void load( int stair_taken, int load_mode, bool was_a_labyrinth,
           int old_level, branch_type where_were_you2 )

                                         you.level_type != LEVEL_DUNGEON,

                                         you.level_type,

                snprintf( info, INFO_SIZE, "%s is following.", 
                          ptr_monam( fmenv, DESC_CAP_THE ) );
                mpr( info, MSGCH_DIAGNOSTICS );

                mprf( "%s is following.", ptr_monam( fmenv, DESC_CAP_THE ) );

            save_level( old_level, false, where_were_you2 );

            save_level( old_level, LEVEL_DUNGEON, where_were_you2 );

        if (you.your_level > 1

        if ((you.your_level > 1 || you.level_type != LEVEL_DUNGEON)

    save_level( you.your_level, (you.level_type != LEVEL_DUNGEON),
                you.where_are_you );

    save_level( you.your_level, you.level_type, you.where_are_you );

void save_level(int level_saved, bool was_a_labyrinth, char where_were_you)

void save_level(int level_saved, level_area_type old_ltype,
                branch_type where_were_you)

                                         where_were_you, was_a_labyrinth,

                                         where_were_you, old_ltype,

    save_level(you.your_level, (you.level_type != LEVEL_DUNGEON),
               you.where_are_you);

    save_level(you.your_level, you.level_type, you.where_are_you);

                                        (you.level_type != LEVEL_DUNGEON),

                                        you.level_type,

                                         (you.level_type != LEVEL_DUNGEON),

                                         you.level_type,

                 atk_name(DESC_NOCAP_YOUR).c_str());

                 atk_name(DESC_NOCAP_ITS).c_str());

                     def_name(DESC_NOCAP_YOUR).c_str());

                     def_name(DESC_NOCAP_ITS).c_str());

  char level_type;

  level_area_type level_type;

  char where_are_you;

  branch_type where_are_you;

    void set_transit(level_id destination);

    void set_transit(const level_id &destination);

    static void announce_ghost(const ghost_demon &g);

    const int old_where = you.where_are_you;

    const branch_type old_where = you.where_are_you;

    you.where_are_you = pos.id.branch;

    you.where_are_you = static_cast<branch_type>(pos.id.branch);

std::string pluralize(const std::string &name, 

std::string pluralise(const std::string &name, 

std::string apostrophise(const std::string &name);

// For monster names ending with these suffixes, we pluralize directly without

std::string apostrophise(const std::string &name)
{
    if (name.empty())
        return (name);
    const char lastc = name[ name.length() - 1 ];
    return (name + (lastc == 's' || lastc == 'x'? "'" : "'s"));
}
// For monster names ending with these suffixes, we pluralise directly without

// Pluralizes a monster name. This'll need to be updated for correctness

// Pluralises a monster name. This'll need to be updated for correctness

std::string pluralize(const std::string &name, 

std::string pluralise(const std::string &name, 

    // Pluralize first word of names like 'eye of draining', but only if the

    // Pluralise first word of names like 'eye of draining', but only if the

        return pluralize(name.substr(0, pos)) + name.substr(pos);

        return pluralise(name.substr(0, pos)) + name.substr(pos);

// kill, else prefixes a kill count and pluralizes the monster name.

// kill, else prefixes a kill count and pluralises the monster name.

        return buf + pluralize(name, modifier_suffixes);

        return buf + pluralise(name, modifier_suffixes);

        // Pluralize as needed

        // Pluralise as needed

        // has to be done after doing pluralize(), else we get very odd plurals

        // has to be done after doing pluralise(), else we get very odd plurals