void marshallString(struct tagHeader &th, const char *data, int maxSize = 0);

void marshallString(struct tagHeader &th, const std::string &data,
                    int maxSize = 0);

void unmarshallString(struct tagHeader &th, char *data, int maxSize);
std::string unmarshallString(tagHeader &th, int maxSize);

void unmarshallCString(struct tagHeader &th, char *data, int maxSize);
std::string unmarshallString(tagHeader &th, int maxSize = 1000);

template<typename T, typename T_iter>

template<typename T, typename T_iter, typename T_marshal>

                              void (*T_marshall)(struct tagHeader&, const T&));

                              T_marshal marshal);

template<typename T, typename T_iter>

template<typename T_iter, typename T_marshall_t>

                              void (*T_marshall)(struct tagHeader&, const T&))

                              T_marshall_t T_marshall)

}
template <typename T_container, typename T_inserter, typename T_unmarshall>
static void unmarshall_container(tagHeader &th, T_container &container,
                                 T_inserter inserter, T_unmarshall unmarshal)
{
    container.clear();
    const long num_to_read = unmarshallLong(th);
    for (long i = 0; i < num_to_read; ++i)
        (container.*inserter)(unmarshal(th));

void marshallString(struct tagHeader &th, const char *data, int maxSize)

void marshallString(struct tagHeader &th, const std::string &data, int maxSize)

    // allow for very long strings.
    short len = strlen(data);

    // allow for very long strings (well, up to 32K).
    int len = data.length();

    memcpy(&tagBuffer[th.offset], data, len);

    memcpy(&tagBuffer[th.offset], data.c_str(), len);

void unmarshallString(struct tagHeader &th, char *data, int maxSize)

void unmarshallCString(struct tagHeader &th, char *data, int maxSize)

    unmarshallString(th, buffer, maxSize);

    unmarshallCString(th, buffer, maxSize);

    marshall_iterator(th, you.uniq_map_tags.begin(), you.uniq_map_tags.end(),
                      marshallString);
    marshall_iterator(th, you.uniq_map_names.begin(), you.uniq_map_names.end(),
                      marshallString);

    unmarshallString(th, you.your_name, 30);

    unmarshallCString(th, you.your_name, 30);

    unmarshallString(th, you.class_name, 30);

    unmarshallCString(th, you.class_name, 30);

    unmarshallString( th, buff, 20 );

    unmarshallCString( th, buff, 20 );

    typedef std::set<std::string> string_set;
    typedef std::pair<string_set::iterator, bool> ssipair;
    unmarshall_container(th, you.uniq_map_tags,
                         (ssipair (string_set::*)(const std::string &))
                         &string_set::insert,
                         unmarshallString);
    unmarshall_container(th, you.uniq_map_names,
                         (ssipair (string_set::*)(const std::string &))
                         &string_set::insert,
                         unmarshallString);

bool mons_behaviour_perceptible(const monsters *mons);

}
bool mons_behaviour_perceptible(const monsters *mons)
{
    return (!mons_class_flag(mons->type, M_NO_EXP_GAIN)
            && !mons_is_mimic(mons->type)
            && !mons_is_statue(mons->type)    
            && mons->type != MONS_OKLOB_PLANT);

    return (!mons_class_flag(m->type, M_NO_EXP_GAIN)
                && !mons_is_mimic(m->type)
                && !mons_is_statue(m->type)
                && !mons_friendly(m)
                && mons_is_sleeping(m));

    return (mons_behaviour_perceptible(m)
            && !mons_friendly(m)
            && mons_is_sleeping(m));

    return (!mons_class_flag(m->type, M_NO_EXP_GAIN)
                && !mons_is_mimic(m->type)
                && !mons_is_statue(m->type)

    return (mons_behaviour_perceptible(m)

const int              MAP_CACHE_VERSION = 1005;

const int              MAP_CACHE_VERSION = 1006;

template <typename I>
static bool map_has_no_tags(const map_def &map, I begin, I end)
{
    for ( ; begin != end; ++begin)
        if (map.has_tag(*begin))
            return (false);
    return (true);
}
static bool vault_unforbidden(const map_def &map)
{
    return (you.uniq_map_names.find(map.name) == you.uniq_map_names.end()
            && map_has_no_tags(map, you.uniq_map_tags.begin(),
                               you.uniq_map_tags.end()));
}

            && vdefs[i].is_minivault() == want_minivault)

            && vdefs[i].is_minivault() == want_minivault
            && vault_unforbidden(vdefs[i]))

    if (mapindex != -1 && vdefs[mapindex].has_tag("dummy"))
        mapindex = -1;
    

            && !vdefs[i].has_tag("unrand"))

            && !vdefs[i].has_tag("unrand")
            && vault_unforbidden(vdefs[i]))

                || vdefs[i].is_usable_in(level_id::current())))

                || vdefs[i].is_usable_in(level_id::current()))
            && vault_unforbidden(vdefs[i]))

    writeShort(file, length);

    writeLong(file, length);

    short length = readShort(file);

    const int length = readLong(file);

  std::set<std::string> uniq_map_tags;
  std::set<std::string> uniq_map_names;

static void place_altars();

static void place_altars()
{
    // No altars before level 5.
    if (you.your_level < 4)
        return;
    if ( you.level_type == LEVEL_DUNGEON )
    {
        int prob = your_branch().altar_chance;
        while (prob)
        {
            if (random2(100) >= prob)
                break;
#ifdef DEBUG_DIAGNOSTICS
            mprf(MSGCH_DIAGNOSTICS, "Placing an altar");
#endif
            place_altar();
            // Reduce the chance and try to place another.
            prob /= 5;
        }
    }
}

    const std::set<std::string> uniq_tags = you.uniq_map_tags;
    const std::set<std::string> uniq_names = you.uniq_map_names;
    

        you.uniq_map_tags  = uniq_tags;
        you.uniq_map_names = uniq_names;

}
static void dgn_register_vault(const map_def &map)
{
    if (map.has_tag("uniq"))
        you.uniq_map_names.insert(map.name);
    std::vector<std::string> tags = split_string(" ", map.tags);
    for (int t = 0, ntags = tags.size(); t < ntags; ++t)
    {
        const std::string &tag = tags[t];
        if (tag.find("uniq_") == 0)
            you.uniq_map_tags.insert(tag);
    }

static void apply_place_masks(const vault_placement &place)

static void register_place(const vault_placement &place)

    dgn_register_vault(place.map);
    

        const dungeon_feature_type exit = your_branch().exit_stairs;

                    grd[x][y] = your_branch().exit_stairs;

                {
                    if (grd[x][y] == DNGN_STONE_STAIRS_UP_I)
                        env.add_marker(
                            new map_feature_marker(coord_def(x,y),
                                                   grd[x][y]));
                    grd[x][y] = exit;
                }

    apply_place_masks(place);

    register_place(place);

    apply_place_masks(place);

    register_place(place);

static void place_altars()
{
    // No altars before level 5.
    if (you.your_level < 4)
        return;
    if ( you.level_type == LEVEL_DUNGEON )
    {
        int prob = your_branch().altar_chance;
        while (prob)
        {
            if (random2(100) >= prob)
                break;
#ifdef DEBUG_DIAGNOSTICS
            mprf(MSGCH_DIAGNOSTICS, "Placing an altar");
#endif
            place_altar();
            // Reduce the chance and try to place another.
            prob /= 5;
        }
    }
}

#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS, "Placing PC on %s",
         dungeon_feature_name(
             static_cast<dungeon_feature_type>(stair_to_find)));
#endif    

    const bool branch_exit = stair_to_find == your_branch().exit_stairs;

            if (grd[xpos][ypos] == stair_to_find)

            if (grd[xpos][ypos] == stair_to_find
                && (!branch_exit
                    || env.find_marker(coord_def(xpos, ypos),
                                       MAT_FEATURE)))

        else if (!mons_class_flag(menv[i].type, M_NO_EXP_GAIN)
                 && !mons_is_statue(menv[i].type))

        else if (mons_behaviour_perceptible(&menv[i]))

##############################################################################
##############################################################################
# Elf:1 arrival vaults
#
# The concept:
# There are no entry vaults for the Elven Halls. Instead, there is a "border
# check" vault on the other side, in the Elf:1 level. Note that elves and orcs
# are not necessarily at war or have big enmities against each other. It's
# just a border check.
#
# The intention:
# I (Eino here, hi!) lost a lot of characters trying to do the Halls right
# after the Mines until I realized the Halls are significantly harder. A
# welcoming party on the other side will hopefully warn the player about this.
#
# Honor this intention. Lots of space between the monsters and the stairs, so
# the players have many turns to realize their mistake. Note that designing
# can be a challenge with the eight space LOS. What might make the player
# realize it's better to flee: facing a nasty summon, taking a few hits from
# conjurations.. they might engage melee opponents, at which point it's quite
# difficult to flee. Please keep that in mind. Note also, that a corridor is
# usually easier for the player than an open space.
#
# This is an instance where an entry (arrival) vault really does benefit from
# having monsters, even a nasty bunch. However, don't go overboard trying to
# make it really hard. And try to make it seem like a plausible border guard.
#
##############################################################################
##############################################################################
# Dummy Elf arrival vault
NAME:   elf_arrival_dummy
TAGS:   dummy
PLACE:  Elf:1
CHANCE: 50
ORIENT: float
MAP
{
ENDMAP
##############################################################################
# Elf arrival vault: corridor one (with the hidden toll cashbox)
NAME:    elf_arrival_001
PLACE:   Elf:1
ORIENT:  float
SHUFFLE: asd/v$=
SHUFFLE: fgh/v$=
SUBST:   a = v, s = v, d = v, f = v, g = v, h = v
MONS:    deep elf soldier, deep elf mage, deep elf conjurer / deep elf priest / deep elf fighter
MONS:    deep elf summoner / deep elf knight w:2
MAP
                  aaa
                  asa
vvvvvvvvvvvvvvvvvvvvdv
v...vvvvv..12..3.....@
v.{........v12..v.4..v
v...vvvvv..12..3.....@
vvvvvvvvvvvvvvvvvvvvhv
                  fgf
                  fff
ENDMAP

# Elf arrival vault: open area

NAME:    elf_arrival_002
PLACE:   Elf:1
ORIENT:  float
FLAGS:   no_rotate
MONS:    deep elf soldier, deep elf mage, deep elf conjurer / deep elf priest / deep elf fighter
MONS:    deep elf summoner / deep elf knight w:2
MAP
xxxxx@xxx@xxx@xxxxx
xxxx...........xxxx
xx....G.3.3.G....xx
x...1.........1...x
x.G...2..4..2...G.x
x.................x
x.......G.G.......x
x.................x
x.....G.....G.....x
xx.1.....{.....1.xx
xxxx...........xxxx
xxxxxxxxxxxxxxxxxxx
ENDMAP