%token <i>      DEFAULT_DEPTH SHUFFLE SUBST TAGS KFEAT KITEM KMONS KMASK

%token <i>      DEFAULT_DEPTH SHUFFLE SUBST TAGS KFEAT KITEM KMONS KMASK KPROP

                | kprop

                            quote_lua_string($2).c_str()));
                }
kprop           : KPROP { }
                | KPROP STRING
                {
                    lc_map.main.add(
                        yylineno,
                        make_stringf("kprop(\"%s\")",

KPROP:              { CBEGIN(ARGUMENT); return KPROP; }

};
typedef std::pair<int, int> map_weighted_fprop;
class map_fprop_list : public std::vector<map_weighted_fprop>
{
public:
    bool parse(const std::string &fp, int weight);
};
class fprop_spec
{
public:
    fprop_spec(int _key, bool _fix, const map_fprop_list &flist)
        : key(_key), fix(_fix), fixed_prop(FPROP_NONE), fprops(flist)
    {
    }
    int get_property();
public:
    int key;
    bool fix;
    int fixed_prop;
    map_fprop_list fprops;

    std::string add_fproperty(const std::string &sub);

    void overlay_fprops(fprop_spec &);

        overlay_def() : colour(0), rocktile(0), floortile(0) {}

        overlay_def() : colour(0), rocktile(0), floortile(0), property(0) {}

        int property;

            const int property = (*overlay)(x, y).property;
            if (property >= FPROP_BLOODY)
                // Over-ride whatever property is already there.
               env.map(gc).property |= property;

bool map_fprop_list::parse(const std::string &fp, int weight)
{
    const int fprop = fp == "none" ? FPROP_NONE : str_to_fprop(fp);
    if (fprop == -1)
        return false;
    push_back(map_weighted_fprop(fprop, weight));
    return true;
}
std::string map_lines::add_fproperty(const std::string &sub)
{
    std::string s = trimmed_string(sub);
    if (s.empty())
        return ("");
    int sep = 0;
    std::string key;
    std::string substitute;

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute);
    if (!err.empty())
        return (err);
    map_fprop_list fprops;
    err = parse_weighted_str<map_fprop_list>(substitute, fprops);
    if (!err.empty())
        return (err);
    fprop_spec spec(key[0], sep == ':', fprops);
    overlay_fprops(spec);
    return ("");
}

void map_lines::overlay_fprops(fprop_spec &spec)
{
    if (!overlay.get())
        overlay.reset(new overlay_matrix(width(), height()));

    for (int y = 0, ysize = lines.size(); y < ysize; ++y)
    {
        std::string::size_type pos = 0;
        while ((pos = lines[y].find(spec.key, pos)) != std::string::npos)
        {
            (*overlay)(pos, y).property |= spec.get_property();
            ++pos;
        }
    }
}

// fprop_spec
int fprop_spec::get_property()
{
    if (fixed_prop != FPROP_NONE)
        return (fixed_prop);
    int chosen = FPROP_NONE;
    int cweight = 0;
    for (int i = 0, size = fprops.size(); i < size; ++i)
        if (x_chance_in_y(fprops[i].second, cweight += fprops[i].second))
            chosen = fprops[i].first;
    if (fix)
        fixed_prop = chosen;
    return (chosen);
}
//////////////////////////////////////////////////////////////////////////

}
static int dgn_kprop(lua_State *ls)
{
    return dgn_map_add_transform(ls, &map_lines::add_fproperty);

{ "kprop", dgn_kprop },

int str_to_fprop (const std::string &str);

}
int str_to_fprop ( const std::string &str)
{
    if (str == "bloody")
        return (FPROP_BLOODY);
    return (FPROP_NONE);