Implement a feature flags system.

* Scenarios contain a string map of feature flags. The flag names are the keys, and flag versions are the values, so a typical value might be "fixed" for bug fixes or for evolving features, "V1", "V2", etc.
* The game has a map of flags to lists of supported versions. The game can therefore signal that it supports a legacy behavior for a given feature flag. The last version in the list is considered to be this build version's default behavior.
* When launching a scenario, we check to make sure the game supports the scenario's required versions of its feature flags.
* When launching a replay, we make sure the game supports the feature flags that the version of the game that made the recording did.

Fix #555
Close #591

Author: NQNStudios

rsrc/schemas/scenario.xsd

@@ -40,6 +40,11 @@
 			<xs:element name="email" type="xs:string"/>
 		</xs:sequence>
 	</xs:complexType>
+	<xs:complexType name="feature-flags">
+		<xs:sequence>
+			<xs:any minOccurs="0" maxOccurs="unbounded"/>
+		</xs:sequence>
+	</xs:complexType>
 	<xs:complexType name="scenText">
 		<xs:sequence>
 			<xs:element name="teaser" minOccurs="0" maxOccurs="2" type="xs:string"/>
@@ -353,6 +358,7 @@
 				<xs:element name="version" type="xs:string"/>
 				<xs:element name="language" type="xs:language"/>
 				<xs:element name="author" type="author"/>
+				<xs:element name="feature-flags" type="feature-flags"/>
 				<xs:element name="text" type="scenText"/>
 				<xs:element name="ratings" type="ratings"/>
 				<xs:element name="flags" type="scenFlags"/>

src/fileio/fileio_scen.cpp

@@ -23,6 +23,7 @@
 #include "mathutil.hpp"
 #include "gzstream.h"
 #include "tarball.hpp"
+#include "replay.hpp"
 
 #include "porting.hpp"
 #include "fileio/resmgr/res_image.hpp"
@@ -769,6 +770,9 @@ void readScenarioFromXml(ticpp::Document&& data, cScenario& scenario) {
 		} else if(type == "author") {
 			elem->FirstChildElement("name")->GetText(&scenario.contact_info[0], false);
 			elem->FirstChildElement("email")->GetText(&scenario.contact_info[1], false);
+		} else if(type == "feature-flags") {
+			// If the function fits, use it
+			scenario.feature_flags = info_from_action(*elem);
 		} else if(type == "text") {
 			Iterator<Element> info;
 			int found_teasers = 0, found_intro = 0;

src/game/boe.global.hpp

@@ -8,6 +8,7 @@
 #include <sstream>
 #include <map>
 #include "boe.consts.hpp"
+#include "universe/universe.hpp"
 
 #define ASB	add_string_to_buf
 #define	PSD	univ.party.stuff_done
@@ -31,4 +32,28 @@ extern std::map<std::string, int> startup_button_indices;
 extern std::map<int, std::string> startup_button_names;
 extern std::map<int, std::string> startup_button_names_v1;
 
+extern cUniverse univ;
+extern std::map<std::string, std::vector<std::string>> feature_flags;
+
+inline bool has_feature_flag(std::string flag, std::string version) {
+	auto iter = feature_flags.find(flag);
+	if(iter == feature_flags.end()) return false;
+	std::vector<std::string> versions = iter->second;
+	return std::find(versions.begin(), versions.end(), version) != versions.end();
+}
+
+// Return the version of a feature that SHOULD BE USED in the currently running game.
+inline std::string get_feature_version(std::string flag) {
+	// If a scenario is loaded and specifies the flag, use that version.
+	if(!univ.party.scen_name.empty()){
+		std::string scenario_flag = univ.scenario.get_feature_flag(flag);
+		if(!scenario_flag.empty()) return scenario_flag;
+	}
+	// Otherwise, use the most recent version of the feature supported by this build,
+	// or by the build that recorded the current replay.
+	auto iter = feature_flags.find(flag);
+	if(iter == feature_flags.end()) return "";
+	return iter->second.back();
+}
+
 #endif

src/game/boe.main.cpp

@@ -89,6 +89,15 @@ boost::optional<location> scen_arg_out_sec, scen_arg_loc;
 extern std::string last_load_file;
 std::string help_text_rsrc = "help";
 
+/*
+// Example feature flags:
+{
+	// A build which supports both V2 and V3 of the updated graphics sheet:
+	{"graphics-sheet", {"V2", "V3"}}
+}
+*/
+std::map<std::string,std::vector<std::string>> feature_flags = {};
+
 struct cParseEntrance {
 	boost::optional<short>& opt;
 	cParseEntrance(boost::optional<short>& opt) : opt(opt) {}
@@ -925,6 +934,50 @@ static void replay_next_action() {
 	replay_action(pop_next_action());
 }
 
+static void record_feature_flags() {
+	Element next_action("feature_flags");
+	for(auto& p : feature_flags){
+		Element next_flag(p.first);
+		std::vector<std::string> supported_versions = p.second;
+		for(std::string version : supported_versions){
+			Element next_version("version");
+			Text version_text(version);
+			next_version.InsertEndChild(version_text);
+			next_flag.InsertEndChild(next_version);
+		}
+		next_action.InsertEndChild(next_flag);
+	}
+	record_action(next_action);
+}
+
+static void replay_feature_flags() {
+	std::map<std::string,std::vector<std::string>> recorded_flags = {};
+	if(has_next_action("feature_flags")){
+		Element action = pop_next_action();
+		Element* next_flag = action.FirstChildElement(false);
+		while(next_flag){
+			std::string flag = next_flag->Value();
+			std::vector<std::string> supported_versions;
+			Element* next_version = next_flag->FirstChildElement(false);
+			while(next_version){
+				std::string version = next_version->GetText();
+				// The game build needs to support the feature version that the replay had
+				if(!has_feature_flag(flag, version)){
+					std::string error = "This replay requires a feature that is not supported in your version of Blades of Exile: " + flag + " should support '" + version + "'";
+					throw error;
+				}
+				supported_versions.push_back(version);
+				next_version = next_version->NextSiblingElement(false);
+			}
+			recorded_flags[flag] = supported_versions;
+			next_flag = next_flag->NextSiblingElement(false);
+		}
+	}
+
+	feature_flags = recorded_flags;
+}
+
+
 void init_boe(int argc, char* argv[]) {
 	set_up_apple_events();
 	init_directories(argv[0]);
@@ -947,6 +1000,12 @@ void init_boe(int argc, char* argv[]) {
 	set_cursor(watch_curs);
 	init_buf();
 
+	if(recording){
+		record_feature_flags();
+	}else if(replaying){
+		replay_feature_flags();
+	}
+
 	// Seed the RNG
 	if(replaying) {
 		Element& srand_element = pop_next_action("srand");

src/game/boe.party.cpp

@@ -171,6 +171,14 @@ void put_party_in_scen(std::string scen_name, bool force) {
 			show_get_items("Choose stored items to keep:", saved_item_refs, pc, true);
 		}
 
+	// Make sure the game build supports all the scenario's features
+	for(auto pair : univ.scenario.feature_flags){
+		if(!has_feature_flag(pair.first, pair.second)){
+			showError("This scenario requires a feature that is not supported in your version of Blades of Exile: " + pair.first + " should support '" + pair.second + "'");
+			return;
+		}
+	}
+
 	univ.enter_scenario(scen_name);
 
 	// if at this point, startup must be over, so make this call to make sure we're ready,

src/scenario/scenario.cpp

@@ -590,4 +590,14 @@ std::vector<town_entrance_t> cScenario::find_town_entrances(int town_num) {
 		}
 	}
 	return matching_entrances;
+}
+
+bool cScenario::has_feature_flag(std::string flag) {
+	return this->feature_flags.find(flag) != this->feature_flags.end();
+}
+
+std::string cScenario::get_feature_flag(std::string flag) {
+	std::map<std::string, std::string>::const_iterator iter = this->feature_flags.find(flag);
+	if(iter == this->feature_flags.end()) return "";
+	return iter->second;
 }

src/scenario/scenario.hpp

@@ -65,6 +65,10 @@ class cScenario {
 	location where_start,out_sec_start,out_start;
 	size_t which_town_start;
 	spec_num_t init_spec;
+	std::map<std::string,std::string> feature_flags;
+	bool has_feature_flag(std::string flag);
+	std::string get_feature_flag(std::string flag);
+
 	std::array<spec_loc_t,10> town_mods;
 	std::array<rectangle,3> store_item_rects;
 	std::array<short,3> store_item_towns;

src/scenedit/scen.core.cpp

@@ -2960,6 +2960,8 @@ bool build_scenario() {
 	scenario.contact_info[0] = author;
 	scenario.default_ground = grass ? 2 : 0;
 
+	scenario.feature_flags = {};
+
 	fs::path basePath = progDir/"Blades of Exile Base"/"bladbase.boes";
 	if(!fs::exists(basePath)) {
 		basePath = basePath.parent_path()/"bladbase.exs";

src/scenedit/scen.fileio.cpp

@@ -133,6 +133,11 @@ void writeScenarioToXml(ticpp::Printer&& data, cScenario& scenario) {
 	data.PushElement("name", scenario.contact_info[0]);
 	data.PushElement("email", scenario.contact_info[1]);
 	data.CloseElement("author");
+	data.OpenElement("feature-flags");
+	for(auto& p : scenario.feature_flags){
+		data.PushElement(p.first, p.second);
+	}
+	data.CloseElement("feature-flags");
 	data.OpenElement("text");
 	data.PushElement("teaser", scenario.who_wrote[0]);
 	data.PushElement("teaser", scenario.who_wrote[1]);

src/tools/replay.cpp

@@ -141,6 +141,12 @@ void record_action(std::string action_type, std::map<std::string,std::string> in
 	log_document.SaveFile(log_file);
 }
 
+void record_action(Element& action) {
+	Element* root = log_document.FirstChildElement();
+	root->InsertEndChild(action);
+	log_document.SaveFile(log_file);
+}
+
 void record_field_input(cKey key) {
 	std::map<std::string,std::string> info;
 	info["spec"] = bool_to_str(key.spec);

src/tools/replay.hpp

@@ -10,8 +10,12 @@
 #include "game/boe.newgraph.hpp"
 
 // Input recording system
-namespace ticpp { class Element; }
+namespace ticpp {
+    class Element;
+    class Text;
+}
 using ticpp::Element;
+using ticpp::Text;
 
 struct word_rect_t;
 
@@ -30,6 +34,7 @@ extern std::string last_action_type;
 extern bool init_action_log(std::string command, std::string file);
 extern void record_action(std::string action_type, std::string inner_text, bool cdata = false);
 extern void record_action(std::string action_type, std::map<std::string,std::string> info);
+extern void record_action(Element& action);
 extern void record_field_input(cKey key);
 extern bool has_next_action(std::string type = "");
 extern std::string next_action_type();