From 9cfcde86bb92957d658e51d1955777f8db73cff1 Mon Sep 17 00:00:00 2001 From: dshaligram Date: Tue, 27 Mar 2007 08:50:19 +0000 Subject: Allow SHUFFLE: and SUBST: to be mixed freely; they will be applied in order of declaration (used to be all shuffles first, then all substs). git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@1106 c06c8d41-db1a-0410-9941-cceddc491573 --- crawl-ref/source/dat/splev.des | 8 +-- crawl-ref/source/dat/vaults.des | 8 +-- crawl-ref/source/mapdef.cc | 114 ++++++++++++++++++++++++++++++++-------- crawl-ref/source/mapdef.h | 46 +++++++++++++--- 4 files changed, 139 insertions(+), 37 deletions(-) diff --git a/crawl-ref/source/dat/splev.des b/crawl-ref/source/dat/splev.des index 9ffc48b165..1b3df123bc 100644 --- a/crawl-ref/source/dat/splev.des +++ b/crawl-ref/source/dat/splev.des @@ -168,8 +168,8 @@ # SHUFFLE: 12/3w (i.e. list of slash-separated blocks of same size) # will either do nothing or swap all "1" with "3" and then also # swap "2" with "w" everywhere. -# Several SHUFFLE: lines can be used, and the shuffles will be applied in -# order. +# Several SHUFFLE: lines can be used, and mixed with SUBST:, and the shuffles +# and substitutions will be applied in order. # # SUBST: # ------ @@ -194,8 +194,8 @@ # # SUBST: w = wW # -# Multiple SUBST: lines can be used, and will be applied in order. -# Substitutions are performed after any declared shuffles. +# Multiple SUBST: lines can be used, and mixed with SHUFFLE:, and will be +# applied in order. # # KFEAT: # ----- diff --git a/crawl-ref/source/dat/vaults.des b/crawl-ref/source/dat/vaults.des index 8a34132890..748e9130fd 100644 --- a/crawl-ref/source/dat/vaults.des +++ b/crawl-ref/source/dat/vaults.des @@ -168,8 +168,8 @@ # SHUFFLE: 12/3w (i.e. list of slash-separated blocks of same size) # will either do nothing or swap all "1" with "3" and then also # swap "2" with "w" everywhere. -# Several SHUFFLE: lines can be used, and the shuffles will be applied in -# order. +# Several SHUFFLE: lines can be used, and mixed with SUBST:, and the shuffles +# and substitutions will be applied in order. # # SUBST: # ------ @@ -194,8 +194,8 @@ # # SUBST: w = wW # -# Multiple SUBST: lines can be used, and will be applied in order. -# Substitutions are performed after any declared shuffles. +# Multiple SUBST: lines can be used, and mixed with SHUFFLE:, and will be +# applied in order. # # KFEAT: # ----- diff --git a/crawl-ref/source/mapdef.cc b/crawl-ref/source/mapdef.cc index b121b361fa..1989cd704d 100644 --- a/crawl-ref/source/mapdef.cc +++ b/crawl-ref/source/mapdef.cc @@ -83,6 +83,11 @@ int strip_number_tag(std::string &s, const std::string &tagprefix) return atoi(argument.c_str()); } +static int find_weight(std::string &s) +{ + return strip_number_tag(s, "weight:"); +} + static std::string split_key_item(const std::string &s, int *key, int *separator, @@ -150,16 +155,62 @@ int level_range::span() const return (deepest - shallowest); } -/////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////// +// map_transformer + +map_transformer::~map_transformer() +{ +} + +//////////////////////////////////////////////////////////////////////// // map_lines -// map_lines::map_lines() - : lines(), map_width(0), solid_north(false), solid_east(false), - solid_south(false), solid_west(false), solid_checked(false) + : transforms(), lines(), map_width(0), solid_north(false), + solid_east(false), solid_south(false), solid_west(false), + solid_checked(false) { } +map_lines::map_lines(const map_lines &map) +{ + init_from(map); +} + +map_lines &map_lines::operator = (const map_lines &map) +{ + if (this != &map) + init_from(map); + return (*this); +} + +map_lines::~map_lines() +{ + release_transforms(); +} + +void map_lines::init_from(const map_lines &map) +{ + release_transforms(); + lines = map.lines; + map_width = map.map_width; + solid_north = map.solid_north; + solid_east = map.solid_east; + solid_south = map.solid_south; + solid_west = map.solid_west; + solid_checked = map.solid_checked; + + for (int i = 0, size = map.transforms.size(); i < size; ++i) + transforms.push_back( map.transforms[i]->clone() ); +} + +void map_lines::release_transforms() +{ + for (int i = 0, size = transforms.size(); i < size; ++i) + delete transforms[i]; + transforms.clear(); +} + const std::vector &map_lines::get_lines() const { return (lines); @@ -252,8 +303,7 @@ std::string map_lines::add_subst(const std::string &sub) if (!err.empty()) return (err); - substitutions.push_back( - subst_spec( key, sep == ':', repl ) ); + transforms.push_back( new subst_spec( key, sep == ':', repl ) ); return (""); } @@ -264,7 +314,7 @@ std::string map_lines::add_shuffle(const std::string &raws) const std::string err = check_shuffle(s); if (err.empty()) - shuffles.push_back(s); + transforms.push_back( new shuffle_spec(s) ); return (err); } @@ -336,8 +386,7 @@ bool map_lines::solid_borders(map_section_type border) void map_lines::clear() { - substitutions.clear(); - shuffles.clear(); + release_transforms(); lines.clear(); map_width = 0; } @@ -349,13 +398,10 @@ void map_lines::subst(std::string &s, subst_spec &spec) s[pos++] = spec.value(); } -void map_lines::subst() +void map_lines::subst(subst_spec &spec) { - for (int i = 0, size = substitutions.size(); i < size; ++i) - { - for (int y = 0, ysize = lines.size(); y < ysize; ++y) - subst(lines[y], substitutions[i]); - } + for (int y = 0, ysize = lines.size(); y < ysize; ++y) + subst(lines[y], spec); } std::string map_lines::block_shuffle(const std::string &s) @@ -414,10 +460,10 @@ void map_lines::resolve_shuffle(const std::string &shufflage) } } -void map_lines::resolve_shuffles() +void map_lines::apply_transforms() { - for (int i = 0, size = shuffles.size(); i < size; ++i) - resolve_shuffle( shuffles[i] ); + for (int i = 0, size = transforms.size(); i < size; ++i) + transforms[i]->apply_transform(*this); } void map_lines::normalise(char fillch) @@ -729,8 +775,7 @@ void map_def::normalise() void map_def::resolve() { - map.resolve_shuffles(); - map.subst(); + map.apply_transforms(); } void map_def::fixup() @@ -856,7 +901,7 @@ mons_list::mons_spec_slot mons_list::parse_mons_spec(std::string spec) for (int i = 0, ssize = specs.size(); i < ssize; ++i) { std::string s = specs[i]; - int weight = strip_number_tag(s, "weight:"); + int weight = find_weight(s); if (weight == TAG_UNFOUND || weight <= 0) weight = 10; @@ -1013,7 +1058,7 @@ item_spec item_list::parse_single_spec(std::string s) item_spec result; // If there's a colon, this must be a generation weight. - int weight = strip_number_tag(s, "weight:"); + int weight = find_weight(s); if (weight != TAG_UNFOUND) { result.genweight = weight; @@ -1171,6 +1216,29 @@ int subst_spec::value() return (chosen); } +void subst_spec::apply_transform(map_lines &map) +{ + map.subst(*this); +} + +map_transformer *subst_spec::clone() const +{ + return new subst_spec(*this); +} + +////////////////////////////////////////////////////////////////////////// +// shuffle_spec + +void shuffle_spec::apply_transform(map_lines &map) +{ + map.resolve_shuffle(shuffle); +} + +map_transformer *shuffle_spec::clone() const +{ + return new shuffle_spec(*this); +} + ////////////////////////////////////////////////////////////////////////// // keyed_mapspec @@ -1237,7 +1305,7 @@ feature_spec keyed_mapspec::parse_shop(std::string s, int weight) feature_spec_list keyed_mapspec::parse_feature(const std::string &str) { std::string s = str; - int weight = strip_number_tag(s, "weight:"); + int weight = find_weight(s); if (weight == TAG_UNFOUND || weight <= 0) weight = 10; trim_string(s); diff --git a/crawl-ref/source/mapdef.h b/crawl-ref/source/mapdef.h index 5c5ec9b810..c96d6df9bb 100644 --- a/crawl-ref/source/mapdef.h +++ b/crawl-ref/source/mapdef.h @@ -43,7 +43,16 @@ public: typedef std::pair glyph_weighted_replacement_t; typedef std::vector glyph_replacements_t; -class subst_spec +class map_lines; +class map_transformer +{ +public: + virtual ~map_transformer() = 0; + virtual void apply_transform(map_lines &map) = 0; + virtual map_transformer *clone() const = 0; +}; + +class subst_spec : public map_transformer { public: subst_spec(int torepl, bool fix, const glyph_replacements_t &repls); @@ -54,6 +63,9 @@ public: } int value(); + + void apply_transform(map_lines &map); + map_transformer *clone() const; private: int foo; // The thing to replace. @@ -63,10 +75,27 @@ private: glyph_replacements_t repl; }; +struct shuffle_spec : public map_transformer +{ + std::string shuffle; + + shuffle_spec(const std::string &spec) + : shuffle(spec) + { + } + + void apply_transform(map_lines &map); + map_transformer *clone() const; +}; + class map_lines { public: map_lines(); + map_lines(const map_lines &); + ~map_lines(); + + map_lines &operator = (const map_lines &); void add_line(const std::string &s); std::string add_subst(const std::string &st); @@ -81,9 +110,8 @@ public: bool is_solid(int gly) const; bool solid_borders(map_section_type border); - - void subst(); - void resolve_shuffles(); + + void apply_transforms(); // Make all lines the same length. void normalise(char fillc = 'x'); @@ -98,8 +126,12 @@ public: const std::vector &get_lines() const; private: + void init_from(const map_lines &map); + void release_transforms(); + void resolve_shuffle(const std::string &shuffle); void subst(std::string &s, subst_spec &spec); + void subst(subst_spec &); void check_borders(); std::string shuffle(std::string s); std::string block_shuffle(const std::string &s); @@ -109,9 +141,11 @@ private: std::string parse_glyph_replacements(std::string s, glyph_replacements_t &gly); + friend class subst_spec; + friend class shuffle_spec; + private: - std::vector substitutions; - std::vector shuffles; + std::vector transforms; std::vector lines; int map_width; bool solid_north, solid_east, solid_south, solid_west; -- cgit v1.2.3-54-g00ecf