// remember (!!!) - if a member of the monster array isn't specified

// Remember (!!!) - if a member of the monster array isn't specified

// make sure that vault_n, where n is a number, is a vault which can be put

// Make sure that vault_n, where n is a number, is a vault which can be put

int vault_main(
        map_type vgrid,
        vault_placement &place,
        int which_vault,
        bool check_place,
        bool clobber)

int vault_main( map_type vgrid,
                vault_placement &place,
                int which_vault,
                bool check_place,
                bool clobber)

    // first, fill in entirely with walls and null-terminate {dlb}:

    // First, fill in entirely with walls and null-terminate {dlb}:

    bool patrolling;

              bool _fixmons = false, bool awaken = false)

              bool _fixmons = false, bool awaken = false, bool patrol = false)

          fix_mons(_fixmons), generate_awake(awaken), colour(BLACK), items()

          fix_mons(_fixmons), generate_awake(awaken), patrolling(false),
          colour(BLACK), items()

    unsigned long flags_set, flags_unset; 

    unsigned long flags_set, flags_unset;

// 

//

// 

//

// 

//

//   

//

// 

//

    clear_transforms(map_transformer::TT_SUBST);    

    clear_transforms(map_transformer::TT_SUBST);

    dlua.callfn("dgn_set_map", "m", map);    

    dlua.callfn("dgn_set_map", "m", map);

    {        

    {

        const int nrots = sizeof(clockrotate_orients) 

        const int nrots = sizeof(clockrotate_orients)

        mspec.patrolling = strip_tag(mon_str, "patrolling");

//    

//

    
    return (error);    

    return (error);

                       bool generate_awake);

                       bool generate_awake, bool patrolling = false);

    // Now do per-square by-symbol masking

    // Now do per-square by-symbol masking.

    // blank level with DNGN_ROCK_WALL

    // Blank level with DNGN_ROCK_WALL.

    // delete all traps

    // Delete all traps.

    // initialize all items

    // Initialize all items.

    // reset all monsters

    // Reset all monsters.

    // reset all shops

    // Reset all shops.

    // clear all markers

    // Clear all markers.

    // Set default level flags

    // Set default level flags.

    // If level part of Dis -> all walls metal;
    // If part of vaults -> walls depend on level;
    // If part of crypt -> all walls stone:

    // If level part of Dis -> all walls metal.
    // If part of vaults -> walls depend on level.
    // If part of crypt -> all walls stone.

    // bottom level of branch - replaces down stairs with up ladders:
    if ( player_branch_depth() == your_branch().depth &&
         you.level_type == LEVEL_DUNGEON &&
         you.where_are_you != BRANCH_VESTIBULE_OF_HELL )

    // Bottom level of branch - replaces down stairs with up ladders:
    if (player_branch_depth() == your_branch().depth
        && you.level_type == LEVEL_DUNGEON
        && you.where_are_you != BRANCH_VESTIBULE_OF_HELL )

    // hall of blades (1 level deal) - no down staircases, thanks!

    // Hall of blades (1 level deal) - no down staircases, thanks!

            if (grd(c) >= DNGN_STONE_STAIRS_DOWN_I &&
                grd(c) <= DNGN_STONE_STAIRS_DOWN_III &&
                num_down_stairs < max_stairs)

            if (grd(c) >= DNGN_STONE_STAIRS_DOWN_I
                && grd(c) <= DNGN_STONE_STAIRS_DOWN_III
                && num_down_stairs < max_stairs)

            else if (grd(c) >= DNGN_STONE_STAIRS_UP_I &&
                grd(c) <= DNGN_STONE_STAIRS_UP_III &&
                num_up_stairs < max_stairs)

            else if (grd(c) >= DNGN_STONE_STAIRS_UP_I
                     && grd(c) <= DNGN_STONE_STAIRS_UP_III
                     && num_up_stairs < max_stairs)

    // hook up the special room (if there is one, and it hasn't

    // Hook up the special room (if there is one, and it hasn't

    // now place items, monster, gates, etc.
    // stairs must exist by this point. Some items and monsters

    // Now place items, monster, gates, etc.
    // Stairs must exist by this point. Some items and monsters

    // time to make the swamp or shoals {dlb}:

    // Time to make the swamp or shoals {dlb}:

    // place shops, if appropriate. This must be protected by the connectivity

    // Place shops, if appropriate. This must be protected by the connectivity

    // any vault-placement activity must happen before this check.

    // Any vault-placement activity must happen before this check.

    // Translate stairs for pandemonium levels:

    // Translate stairs for pandemonium levels.

// Used to nuke shafts placed in corridors on low levels - it's just too
// nasty otherwise.

    // first check horizontal neighbouring squares

    // First check horizontal neighbouring squares.

    // now check vertical neighbouring squares

    // Now check vertical neighbouring squares.

    // no corridor found

    // No corridor found.

        // traps can be placed in vaults

        // Traps can be placed in vaults.

                // choose again!

                // Choose again!

    // place actual branch entrances

    // Place actual branch entrances.

        // Put something in to make it go to parts of map it isn't in now

        // Put something in to make it go to parts of map it isn't in now.

        // corridor length.. change only when going vertical?

        // Corridor length... change only when going vertical?

            // 0 to random2(3) - 1 to avoid getting stuck on the "stuck!" bit

            // 0 to random2(3) - 1 to avoid getting stuck on the "stuck!" bit.

            // don't interfere with special rooms

            // Don't interfere with special rooms.

            // see if we stop due to intersection with another corridor/room

            // See if we stop due to intersection with another corridor/room.

// return TRUE if a room was made successfully

// Returns TRUE if a room was made successfully.

    // check top & bottom for possible doors

    // Check top & bottom for possible doors.

    // look for 'special' rock walls - don't interrupt them

    // Look for 'special' rock walls - don't interrupt them.

    // convert the area to floor

    // Convert the area to floor.

    // put some doors on the sides (but not in corners),

    // Put some doors on the sides (but not in corners),

    // put some doors on the top & bottom

    // Put some doors on the top & bottom.

            // sometimes, we just quit if a unique is already placed.

            // Sometimes, we just quit if a unique is already placed.

        // usually, we'll have quit after a few tries. Make sure we don't

        // Usually, we'll have quit after a few tries. Make sure we don't

    // count the number of lava and water tiles {dlb}:

    // Count the number of lava and water tiles {dlb}:

            swimming_things[i] =
                static_cast<monster_type>(
                    MONS_LAVA_WORM + random2(3) );

            swimming_things[i] = static_cast<monster_type>(
                                     MONS_LAVA_WORM + random2(3) );

            // Guarantee that the knife is uncursed and non-special

            // Guarantee that the knife is uncursed and non-special.

// the entire intent of this function is to find a

// The entire intent of this function is to find a

    // paranoia -- how did we get here if there's no actual special room??

    // Paranoia -- how did we get here if there's no actual special room??

        // quit if we run off the map before finding floor

        // Quit if we run off the map before finding floor.

    // make distribution cumulative

    // Make distribution cumulative.

    // calculate die_size, factoring in the density% of the pit

    // Calculate die_size, factoring in the density% of the pit.

    // put the boss monster down

    // Put the boss monster down.

    // place monsters and give them items {dlb}:

    // Place monsters and give them items {dlb}:

            // avoid the boss (or anyone else we may have dropped already)

            // Avoid the boss (or anyone else we may have dropped already).

            // run throught the cumulative chances and place a monster

            // Run throught the cumulative chances and place a monster.

    int temp_rand = 0;          // probability determination {dlb}

    int temp_rand = 0;      // probability determination {dlb}

    // overwrites anything;  this function better be called early on during
    // creation..

    // Overwrites anything: this function better be called early on during
    // creation.

    // do special walls & floor

    // Do special walls & floor.

    // set up passed in spec_room structure
    sr.created = true;

    // Set up passed in spec_room structure.
    sr.created   = true;

        if ((level_number > 13 && spec_room_type == SROOM_LAIR_KOBOLD)
            || (level_number < 16 && spec_room_type == SROOM_MORGUE)
            || (level_number < 14 && spec_room_type == SROOM_JELLY_PIT)
            || (level_number < 17 && one_chance_in(4)))

        // Replace overly dangerous special rooms with a room full of orcs.
        if (level_number > 13 && spec_room_type == SROOM_LAIR_KOBOLD
            || level_number < 16 && spec_room_type == SROOM_MORGUE
            || level_number < 14 && spec_room_type == SROOM_JELLY_PIT
            || level_number < 17 && one_chance_in(4))

        // determine which monster array to generate {dlb}:

        // Determine which monster array to generate {dlb}:

        // fill with baseline monster type {dlb}:

        // Fill with baseline monster type {dlb}:

        // fill in with special monster types {dlb}:

        // Fill in with special monster types {dlb}:

        // place monsters and give them items {dlb}:

        // Place monsters and give them items {dlb}:

        // determine which monster array to generate {dlb}:

        // Determine which monster array to generate {dlb}:

        // fill with baseline monster type {dlb}:

        // Fill with baseline monster type {dlb}:

        // fill in with special monster types {dlb}:
        // in this case, they are uniformly the same {dlb}:

        // Fill in with special monster types {dlb}:
        // In this case, they are uniformly the same {dlb}:

        // place monsters and give them items {dlb}:

        // Place monsters and give them items {dlb}:

                // we'll put the boss down later.

                // We'll put the boss down later.

        // put the boss monster down

        // Put the boss monster down.

        // Should only appear in deep levels, with a guardian

        // Should only appear in deep levels, with a guardian.

        // If wandering, the guardian should return to the treasure room.

// fills a special room with bees

// Fills a special room with bees

            // the hive is chock full of bees!

            // The hive is chock full of bees!

            MG_PATROLLING));

            MG_PATROLLING)); // Queen bees will return to their hive.

// used for placement of vaults

// Used for placement of vaults.

    // floor, and closed/secret doors may always be overwritten

    // Floor, and closed/secret doors may always be overwritten.

    // watery grids may be overwritten if water_ok == true

    // Watery grids may be overwritten if water_ok == true.

    // Otherwise, don't overwrite this feature.

// used for placement of rivers/lakes

// Used for placement of rivers/lakes.

    /* must not be completely isolated: */

    // must not be completely isolated:

    /* find a target area which can be safely overwritten: */

    // Find a target area which can be safely overwritten.

    if (in_bounds(where)) // not map_bounds, minivaults should never touch edge

    // Not map_bounds, minivaults should never touch edge.
    if (in_bounds(where))

    // these two are throwaways:

    // These two are throwaways:

    // paint the minivault onto the grid

    // Paint the minivault onto the grid.

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

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

    // note: assumes *no* previous item (I think) or monster (definitely)
    // placement

    // NOTE: assumes *no* previous item (I think) or monster (definitely)
    // placement.

        // Don't give monster a randart, and don't radnomly give

        // Don't give monster a randart, and don't randomly give

                       bool generate_awake)

                       bool generate_awake, bool patrolling)

        const bool m_patrolling     = (patrolling || mspec.patrolling);

        if (m_patrolling)
            mg.flags |= MG_PATROLLING;

    return dgn_place_monster(mspec, monster_level, vx, vy, generate_awake);

    const bool patrolling
        = mspec.patrolling || place.map.has_tag("patrolling");
    return dgn_place_monster(mspec, monster_level, vx, vy, generate_awake,
                             patrolling);

// returns altar_count - seems rather odd to me to force such a return

// Returns altar_count - seems rather odd to me to force such a return

// temple - oh, well... {dlb}

// temple - oh, well... {dlb} (XXX)

    keyed_mapspec *mapsp = following? NULL : place.map.mapspec_for_key(vgrid);

    keyed_mapspec *mapsp = (following ? NULL
                                      : place.map.mapspec_for_key(vgrid));

    // then, handle grids that place "stuff" {dlb}:
    switch (vgrid)              // yes, I know this is a bit ugly ... {dlb}

    // Then, handle grids that place "stuff" {dlb}:
    // yes, I know this is a bit ugly ... {dlb}
    switch (vgrid)

    // finally, handle grids that place monsters {dlb}:

    // Finally, handle grids that place monsters {dlb}:

    // again, this seems odd, given that this is just one of many

    // Again, this seems odd, given that this is just one of many

//   where it will turn the stone walls into clear rock walls
//   once the royal jelly has been killed.

// where it will turn the stone walls into clear rock walls
// once the royal jelly has been killed.

    // don't place LAVA pools in crypt.. use shallow water instead.

    // Don't place LAVA pools in crypt.. use shallow water instead.

//jmf: generate altar based on where you are, or possibly randomly

//jmf: Generate altar based on where you are, or possibly randomly.

        // no extra altars in temple, none at all in slime pits or labyrinth

        // No extra altars in temple, none at all in slime pits or labyrinth.

        case BRANCH_ORCISH_MINES:       // violent gods

        case BRANCH_ORCISH_MINES:    // violent gods

    // allow bargains in bazaars, prices randomly between 60% and 95%

    // Allow bargains in bazaars, prices randomly between 60% and 95%.

        // need to calculate with factor as greed (unsigned char) is capped at 255

        // Need to calculate with factor as greed (unsigned char)
        // is capped at 255.

    // for books shops, store how many copies of a given book are on display

    // For books shops, store how many copies of a given book are on display.
    // This increases the diversity of books in a shop.

        // make bazaar items more valuable (up to double value)
        if (you.level_type == LEVEL_PORTAL_VAULT && you.level_type_name == "bazaar")

        // Make bazaar items more valuable (up to double value).
        if (you.level_type == LEVEL_PORTAL_VAULT
            && you.level_type_name == "bazaar")

        // don't generate gold in shops!  This used to be possible with
        // General Stores (see item_in_shop() below)   (GDL)

        // Don't generate gold in shops! This used to be possible with
        // general stores (see item_in_shop() below)   (GDL)

            // try for a better selection

            // Try for a better selection.

            // reset object and try again

            // Reset object and try again.

        // increase stock of this subtype by 1, unless it is an artefact

        // Increase stock of this subtype by 1, unless it is an artefact

        // - the latter is currently unused but would apply to e.g. jewellery

        // - the latter is currently unused but would apply to e.g. jewellery.

        // set object 'position' (gah!) & ID status

        // Set object 'position' (gah!) & ID status.

    // assumes starting with a level full of rock walls (1)

    // Assumes starting with a level full of rock walls (1).

    // boxy levels have more clearing, so they get fewer iterations:

    // Boxy levels have more clearing, so they get fewer iterations.

// various plan_xxx functions

// Various plan_xxx functions.

    /* Draws a room, then another and links them together, then another and etc
       Of course, this can easily end up looking just like a make_trail level.
     */

    // Draws a room, then another and links them together, then another and etc.
    // Of course, this can easily end up looking just like a make_trail level.

// A more chaotic version of city level.

    // a more chaotic version of city level

}                               // end plan_5()

}

// Octagon with pillars in middle.

    dgn_Layout_Type  = "open"; // Octagon with pillars in middle

    dgn_Layout_Type  = "open";

}                               // end plan_6()

}

    // hack - avoid lava in the crypt {gdl}

    // Hack - avoid lava in the crypt {gdl}

    // check octagonal room for special; avoid if exists

    // Check octagonal room for special; avoid if exists.

}                               // end octa_room()

}

    // if there is a door near us embedded in rock, we have to be a door too.

    // If there is a door near us embedded in rock, we have to be a door too.

    // to be a good spot for a door, we need non-wall on two sides and

    // To be a good spot for a door, we need non-wall on two sides and

    // go through, building list of good door spots, and replacing wall

    // Go through, building list of good door spots, and replacing wall

        // try not to put a door in the same place twice

        // Try not to put a door in the same place twice.

    // hack -- avoid lava in the crypt. {gdl}

    // Hack -- avoid lava in the crypt. {gdl}

    // do top & bottom walls

    // Do top & bottom walls.

    // do left & right walls

    // Do left & right walls.

    // sometimes we have to place doors, or else we shut in other
    // buildings' doors

    // Sometimes we have to place doors, or else we shut in other
    // buildings' doors.

    // small rooms don't have as many doors

    // Small rooms don't have as many doors.

    // remember, can have many wall types in one level

    // Remember, can have many wall types in one level.

                // inner room - neat.

                // Inner room - neat.

                    // treasure area.. neat.

                    // Treasure area... neat.

}                               // end treasure_area()

}

    }                           // end "for(bk...)"
}                               // end diamond_rooms()

    }
}

        // usually floor, except at higher levels

        // Usually floor, except at higher levels.

        // default is lava.

        // Default is lava.

    // what now?

    // What now?

    // check for previous special

    // Check for previous special.

    // make the big room.

    // Make the big room.

    // no lava in the Crypt or Tomb, thanks!

    // No lava in the Crypt or Tomb, thanks!

    // sometimes make it a chequerboard

    // Sometimes make it a chequerboard.

    // sometimes make an inside room w/ stone wall.

    // Sometimes make an inside room w/ stone wall.

// helper function for chequerboard rooms
// note that box boundaries are INclusive

// Helper function for chequerboard rooms.
// Note that box boundaries are INclusive.

    // is one of them a special room?

    // Is one of them a special room?

        // make the room 'special' so it doesn't get overwritten
        // by something else (or put monsters in walls, etc..).

        // Make the room 'special' so it doesn't get overwritten
        // by something else (or put monsters in walls, etc...)

}                               // end morgue()

}

}                               // end place_specific_trap()

}

}                               // end build_river()

}

}                               // end lake()

}

    // scan around the player's position first

    // Scan around the player's position first.

    // check for illegal starting point
    if ( !in_bounds(basex, basey) )

    // Check for illegal starting point.
    if (!in_bounds(basex, basey))

    // First pass: look for an exact match

    // First pass: look for an exact match.

            // note that due to the wrapping above, we can't just use
            // xdiff*xdiff + ydiff*ydiff

            // Note that due to the wrapping above, we can't just use
            // xdiff*xdiff + ydiff*ydiff.

    // Second pass: find a staircase in the proper direction

    // Second pass: find a staircase in the proper direction.

                good_stair = (looking_at >= DNGN_STONE_STAIRS_DOWN_I &&
                              looking_at <= DNGN_ESCAPE_HATCH_DOWN);

                good_stair = (looking_at >= DNGN_STONE_STAIRS_DOWN_I
                              && looking_at <= DNGN_ESCAPE_HATCH_DOWN);

                good_stair =  (looking_at >= DNGN_STONE_STAIRS_UP_I &&
                               looking_at <= DNGN_ESCAPE_HATCH_UP);

                good_stair =  (looking_at >= DNGN_STONE_STAIRS_UP_I
                               && looking_at <= DNGN_ESCAPE_HATCH_UP);

            if ( good_stair )

            if (good_stair)

        && (between(pos.y, other.pos.y, other.pos.y + other.size.y - 1)
               || between(pos.y + size.y - 1, other.pos.y,
                          other.pos.y + other.size.y - 1));

            && (between(pos.y, other.pos.y, other.pos.y + other.size.y - 1)
                || between(pos.y + size.y - 1, other.pos.y,
                           other.pos.y + other.size.y - 1));

KMONS:   1 = Orb Guardian

KMONS:   1 = patrolling Orb Guardian

MONS:    Orb Guardian, Killer Klown, electric golem, orb of fire, ancient lich
MONS:    orange crystal statue / silver statue / ice statue

MONS:    patrolling Orb Guardian, Killer Klown, electric golem, orb of fire
MONS:    ancient lich, orange crystal statue / silver statue / ice statue

          * "patrolling": Monsters placed (using MONS, KMONS) in this vault
             will be generated with their starting position as patrol point.
             If not otherwise occupied (fighting, seeking) they will patrol
             the area.

          Individual monsters may be prefixed with the "patrolling"
          (without the quotes). Use this sparingly:
              MONS: patrolling naga guardian

          unless the item's race type is explicitly set otherwise.        

          unless the item's race type is explicitly set otherwise.