level_id place;

    level_id place;

        : mid(id), monbase(base), number(num), genweight(gw), mlevel(ml),
          fix_mons(_fixmons), generate_awake(awaken), patrolling(false),
          colour(BLACK), items()

        : mid(id), place(), monbase(base), number(num), genweight(gw),
          mlevel(ml), fix_mons(_fixmons), generate_awake(awaken),
          patrolling(false), colour(BLACK), items()

        // place:Elf:7 to choose monsters appropriate for that level,
        // for example.
        const std::string place = strip_tag_prefix(mon_str, "place:");
        if (!place.empty())
        {
            try
            {
                mspec.place = level_id::parse_level_id(place);
            }
            catch (const std::string &err)
            {
                error = err;
                return (slot);
            }
        }
        mspec.mlevel = strip_number_tag(mon_str, "lev:");
        if (mspec.mlevel == TAG_UNFOUND)
            mspec.mlevel = 0;

        else if (mspec.place.is_valid())
        {
            // For monster specs such as place:Orc:4 zombie, we may
            // have a monster modifier, in which case we set the
            // modifier in monbase.
            const mons_spec nspec = mons_by_name("orc " + mon_str);
            if (nspec.mid != MONS_PROGRAM_BUG)
            {
                // Is this a modified monster?
                if (nspec.monbase != MONS_PROGRAM_BUG
                    && mons_class_is_zombified(nspec.mid))
                {
                    mspec.monbase = static_cast<monster_type>(nspec.mid);
                }
            }
        }

        " zombie", " skeleton", " simulacrum", NULL

        " zombie", " skeleton", " simulacrum", " spectre", NULL

        { MONS_SIMULACRUM_SMALL, MONS_SIMULACRUM_LARGE }

        { MONS_SIMULACRUM_SMALL, MONS_SIMULACRUM_LARGE },
        { MONS_SPECTRAL_THING,   MONS_SPECTRAL_THING },

        if (mg.cls == RANDOM_MONSTER && mspec.place.is_valid())
        {
            int lev = monster_level;
            if (mspec.place.level_type == LEVEL_DUNGEON)
                lev = absdungeon_depth(mspec.place.branch, mspec.place.depth);
            if (mlev == -8)
                lev = 4 + lev * 2;
            else if (mlev == -9)
                lev += 5;
            int tries = 100;
            do
            {
                mg.cls = pick_random_monster(mspec.place, lev, lev);
            } while (mg.cls != MONS_PROGRAM_BUG
                     && mons_class_is_zombified(mspec.monbase)
                     && !mons_zombie_size(mg.cls)
                     && tries-- > 0);
            if (mg.cls == MONS_PROGRAM_BUG
                || (mons_class_is_zombified(mspec.monbase)
                    && !mons_zombie_size(mg.cls)))
            {
                mg.cls = RANDOM_MONSTER;
            }
        }

        if (mons_class_is_zombified(mg.base_type))
        {
            if (mons_class_is_zombified(mg.cls))
                mg.base_type = MONS_PROGRAM_BUG;
            else
                std::swap(mg.base_type, mg.cls);
        }

          If you want to place a random monster suitable for the level
          the map is generated on, you can use
              MONS: random
          If you want to place a random monster suitable for some other
          place, you can use a place: tag in the monster spec:
              MONS: place:Abyss
          or
              MONS: place:Slime:6
          Using place: with MONS implies that you want a random monster.
          You can also request zombies from random monsters suitable
          for some other depth as:
              MONS: place:Elf:7 zombie
          or
              MONS: place:Zot:5 simulacrum
          or
              MONS: place:Vault:8 spectre

          The available modifiers are "zombie", "skeleton",
          "simulacrum" and "spectre".