1 files changed, 79 insertions, 108 deletions

diff --git a/src/openvic-simulation/history/CountryHistory.cpp b/src/openvic-simulation/history/CountryHistory.cpp
index ed72f52..cd682bd 100644
--- a/src/openvic-simulation/history/CountryHistory.cpp
+++ b/src/openvic-simulation/history/CountryHistory.cpp
@@ -7,7 +7,7 @@ using namespace OpenVic::NodeTools;
 
 CountryHistory::CountryHistory(
 	Culture const* new_primary_culture, std::vector<Culture const*>&& new_accepted_cultures, Religion const* new_religion,
-	CountryParty const* new_ruling_party, Date new_last_election, std::map<Ideology const*, fixed_point_t>&& new_upper_house,
+	CountryParty const* new_ruling_party, Date new_last_election, decimal_map_t<Ideology const*>&& new_upper_house,
 	Province const* new_capital, GovernmentType const* new_government_type, fixed_point_t new_plurality,
 	NationalValue const* new_national_value, bool new_civilised, fixed_point_t new_prestige,
 	std::vector<Reform const*>&& new_reforms, Deployment const* new_inital_oob
@@ -21,7 +21,7 @@ Culture const* CountryHistory::get_primary_culture() const {
 	return primary_culture;
 }
 
-const std::vector<Culture const*>& CountryHistory::get_accepted_cultures() const {
+std::vector<Culture const*> const& CountryHistory::get_accepted_cultures() const {
 	return accepted_cultures;
 }
 
@@ -37,7 +37,7 @@ Date CountryHistory::get_last_election() const {
 	return last_election;
 }
 
-const std::map<Ideology const*, fixed_point_t>& CountryHistory::get_upper_house() const {
+decimal_map_t<Ideology const*> const& CountryHistory::get_upper_house() const {
 	return upper_house;
 }
 
@@ -49,7 +49,7 @@ GovernmentType const* CountryHistory::get_government_type() const {
 	return government_type;
 }
 
-const fixed_point_t CountryHistory::get_plurality() const {
+fixed_point_t CountryHistory::get_plurality() const {
 	return plurality;
 }
 
@@ -57,15 +57,15 @@ NationalValue const* CountryHistory::get_national_value() const {
 	return national_value;
 }
 
-const bool CountryHistory::is_civilised() const {
+bool CountryHistory::is_civilised() const {
 	return civilised;
 }
 
-const fixed_point_t CountryHistory::get_prestige() const {
+fixed_point_t CountryHistory::get_prestige() const {
 	return prestige;
 }
 
-const std::vector<Reform const*>& CountryHistory::get_reforms() const {
+std::vector<Reform const*> const& CountryHistory::get_reforms() const {
 	return reforms;
 }
 
@@ -76,9 +76,9 @@ Deployment const* CountryHistory::get_inital_oob() const {
 bool CountryHistoryManager::add_country_history_entry(
 	Country const* country, Date date, Culture const* primary_culture, std::vector<Culture const*>&& accepted_cultures,
 	Religion const* religion, CountryParty const* ruling_party, Date last_election,
-	std::map<Ideology const*, fixed_point_t>&& upper_house, Province const* capital, GovernmentType const* government_type,
+	decimal_map_t<Ideology const*>&& upper_house, Province const* capital, GovernmentType const* government_type,
 	fixed_point_t plurality, NationalValue const* national_value, bool civilised, fixed_point_t prestige,
-	std::vector<Reform const*>&& reforms, Deployment const* initial_oob, bool updated_accepted_cultures,
+	std::vector<Reform const*>&& reforms, std::optional<Deployment const*> initial_oob, bool updated_accepted_cultures,
 	bool updated_upper_house, bool updated_reforms
 ) {
 	if (locked) {
@@ -87,8 +87,8 @@ bool CountryHistoryManager::add_country_history_entry(
 	}
 
 	/* combine duplicate histories, priority to current (defined later) */
-	auto& country_registry = country_histories[country];
-	const auto existing_entry = country_registry.find(date);
+	country_history_map_t& country_registry = country_histories[country];
+	const country_history_map_t::iterator existing_entry = country_registry.find(date);
 
 	if (existing_entry != country_registry.end()) {
 		if (primary_culture != nullptr) {
@@ -130,15 +130,15 @@ bool CountryHistoryManager::add_country_history_entry(
 		if (updated_reforms) {
 			existing_entry->second.reforms = std::move(reforms);
 		}
-		if (initial_oob != nullptr) {
-			existing_entry->second.inital_oob = initial_oob;
+		if (initial_oob) {
+			existing_entry->second.inital_oob = *initial_oob;
 		}
 	} else {
 		country_registry.emplace( date,
 			CountryHistory {
 				primary_culture, std::move(accepted_cultures), religion, ruling_party, last_election,
 				std::move(upper_house), capital, government_type, plurality, national_value, civilised,
-				prestige, std::move(reforms), initial_oob
+				prestige, std::move(reforms), std::move(*initial_oob)
 			}
 		);
 	}
@@ -195,57 +195,68 @@ inline CountryHistory const* CountryHistoryManager::get_country_history(Country
 }
 
 inline bool CountryHistoryManager::_load_country_history_entry(
-	GameManager& game_manager, std::string_view name, Date date, ast::NodeCPtr root
+	GameManager& game_manager, Dataloader const& dataloader, Country const& country, Date date, ast::NodeCPtr root
 ) {
+	PoliticsManager const& politics_manager = game_manager.get_politics_manager();
+	IssueManager const& issue_manager = politics_manager.get_issue_manager();
+	CultureManager const& culture_manager = game_manager.get_pop_manager().get_culture_manager();
+
 	Province const* capital = nullptr;
 	Culture const* primary_culture = nullptr;
 	Religion const* religion = nullptr;
 	GovernmentType const* government_type = nullptr;
 	NationalValue const* national_value = nullptr;
 	CountryParty const* ruling_party = nullptr;
-	std::vector<Culture const*> accepted_cultures;
-	std::vector<Reform const*> reforms;
-	std::map<Ideology const*, fixed_point_t> upper_house;
+	std::vector<Culture const*> accepted_cultures {};
+	std::vector<Reform const*> reforms {};
+	decimal_map_t<Ideology const*> upper_house {};
 	fixed_point_t plurality = -1, prestige = -1;
 	bool civilised = false;
 	Date last_election {};
-	Deployment const* initial_oob = nullptr;
+	std::optional<Deployment const*> initial_oob;
 
 	bool updated_accepted_cultures = false, updated_upper_house = false, updated_reforms = false;
 
 	bool ret = expect_dictionary_keys_and_default(
-		[this, &game_manager, &reforms, &updated_reforms, &name](std::string_view key, ast::NodeCPtr value) -> bool {
-			if (game_manager.get_politics_manager().get_issue_manager().has_reform_group_identifier(key)) {
+		[this, &issue_manager, &reforms, &updated_reforms, &country](std::string_view key, ast::NodeCPtr value) -> bool {
+			ReformGroup const* reform_group = issue_manager.get_reform_group_by_identifier(key);
+			if (reform_group != nullptr) {
 				updated_reforms = true;
-
-				Reform const* reform;
-
-				bool ret = game_manager.get_politics_manager().get_issue_manager()
-					.expect_reform_identifier(assign_variable_callback_pointer(reform))(value);
-				if (std::find(reforms.begin(), reforms.end(), reform) != reforms.end()) {
-					Logger::error("Redefinition of reform ", reform->get_identifier(), " in history of ", name);
-					return false;
-				}
-
-				reforms.push_back(reform);
-				return ret;
+				return issue_manager.expect_reform_identifier(
+					[reform_group, &reforms, &country](Reform const& reform) -> bool {
+						if (&reform.get_reform_group() != reform_group) {
+							Logger::warning(
+								"Listing ", reform.get_identifier(), " as belonging to the reform group ",
+								reform_group->get_identifier(), " when it actually belongs to ",
+								reform.get_reform_group().get_identifier()
+							);
+						}
+						if (std::find(reforms.begin(), reforms.end(), &reform) != reforms.end()) {
+							Logger::error(
+								"Redefinition of reform ", reform.get_identifier(), " in history of ", country.get_identifier()
+							);
+							return false;
+						}
+						reforms.push_back(&reform);
+						return true;
+					}
+				)(value);
 			}
 			// TODO: technologies & inventions
 			return true;
 		},
 		/* we have to use a lambda, assign_variable_callback_pointer
 		 * apparently doesn't play nice with const & non-const accessors */
+		// TODO - fix this issue (cause by provinces having non-const accessors)
 		"capital", ZERO_OR_ONE,
 			game_manager.get_map().expect_province_identifier([&capital](Province const& province) -> bool {
 				capital = &province;
 				return true;
 			}),
 		"primary_culture", ZERO_OR_ONE,
-			game_manager.get_pop_manager().get_culture_manager().expect_culture_identifier(
-				assign_variable_callback_pointer(primary_culture)
-			),
+			culture_manager.expect_culture_identifier(assign_variable_callback_pointer(primary_culture)),
 		"culture", ZERO_OR_MORE,
-			game_manager.get_pop_manager().get_culture_manager().expect_culture_identifier(
+			culture_manager.expect_culture_identifier(
 				[&game_manager, &accepted_cultures, &updated_accepted_cultures](Culture const& culture) -> bool {
 					updated_accepted_cultures = true;
 					accepted_cultures.push_back(&culture);
@@ -257,102 +268,62 @@ inline bool CountryHistoryManager::_load_country_history_entry(
 				assign_variable_callback_pointer(religion)
 			),
 		"government", ZERO_OR_ONE,
-			game_manager.get_politics_manager().get_government_type_manager().expect_government_type_identifier(
+			politics_manager.get_government_type_manager().expect_government_type_identifier(
 				assign_variable_callback_pointer(government_type)
 			),
 		"plurality", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(plurality)),
 		"nationalvalue", ZERO_OR_ONE,
-			game_manager.get_politics_manager().get_national_value_manager().expect_national_value_identifier(
+			politics_manager.get_national_value_manager().expect_national_value_identifier(
 				assign_variable_callback_pointer(national_value)
 			),
 		"civilized", ZERO_OR_ONE, expect_bool(assign_variable_callback(civilised)),
 		"prestige", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(prestige)),
-		"ruling_party", ZERO_OR_ONE,
-			expect_identifier([this, &game_manager, &ruling_party, &name, &date](std::string_view identifier) -> bool {
-				const std::vector<CountryParty>* parties =
-					&game_manager.get_country_manager().get_country_by_identifier(name)->get_parties();
-				for (auto& party : *parties) {
-					if (party.get_identifier() == identifier) {
-						if (party.get_start_date() <= date && date <= party.get_end_date()) {
-							ruling_party = &party;
-							return true;
-						} else {
-							if (party.get_start_date() > date) {
-								Logger::warning(
-									"Ruling party ", identifier, " of country ", name, " has invalid start date ",
-									party.get_start_date(), " for bookmark: ", date.to_string()
-								);
-							}
-							if (party.get_end_date() < date) {
-								Logger::warning(
-									"Ruling party ", identifier, " of country ", name, " has invalid end date ",
-									party.get_end_date(), " for bookmark: ", date.to_string()
-								);
-							}
-							ruling_party = &party;
-							return true;
-						}
-					}
-				}
-				Logger::error("Ruling party ", identifier, " of country ", name, " is not defined!");
-				return false;
-			}),
+		"ruling_party", ZERO_OR_ONE, country.expect_party_identifier(assign_variable_callback_pointer(ruling_party)),
 		"last_election", ZERO_OR_ONE, expect_date(assign_variable_callback(last_election)),
 		"upper_house", ZERO_OR_ONE,
-			game_manager.get_politics_manager().get_ideology_manager().expect_ideology_dictionary(
+			politics_manager.get_ideology_manager().expect_ideology_dictionary(
 				[&upper_house, &updated_upper_house](Ideology const& ideology, ast::NodeCPtr value) -> bool {
-					fixed_point_t popularity;
-
-					updated_upper_house = true;
-					bool ret = expect_fixed_point(assign_variable_callback(popularity))(value);
-					upper_house.emplace(&ideology, popularity);
-					return ret;
-				}
-			),
-		"oob", ZERO_OR_ONE,
-			[&game_manager, &initial_oob](ast::NodeCPtr node) -> bool {
-				std::string_view string;
-				expect_string(assign_variable_callback(string))(node);
-
-				if (string.starts_with('/')) {
-					if (game_manager.get_military_manager().get_deployment_manager()
-						.has_deployment_identifier(string.substr(1))) {
-						initial_oob = game_manager.get_military_manager().get_deployment_manager()
-							.get_deployment_by_identifier(string.substr(1));
+					return expect_fixed_point([&upper_house, &updated_upper_house, &ideology](fixed_point_t val) -> bool {
+						if (val != 0) {
+							upper_house[&ideology] += val;
+							updated_upper_house = true;
+						}
 						return true;
-					}
-				} else {
-					if (game_manager.get_military_manager().get_deployment_manager().has_deployment_identifier(string)) {
-						initial_oob =
-							game_manager.get_military_manager().get_deployment_manager().get_deployment_by_identifier(string);
-					}
+					})(value);
 				}
-
-				initial_oob =
-					game_manager.get_military_manager().get_deployment_manager().get_deployment_by_identifier("NULL");
-				return true;
-			},
+			),
+		"oob", ZERO_OR_ONE, expect_identifier_or_string([&game_manager, &dataloader, &initial_oob](std::string_view path) -> bool {
+			if(!initial_oob.has_value())
+				initial_oob = decltype(initial_oob)::value_type {};
+			return game_manager.get_military_manager().get_deployment_manager().load_oob_file(
+				game_manager, dataloader, path, *initial_oob, false
+			);
+		}),
 		"schools", ZERO_OR_ONE, success_callback, // TODO: technology school
 		"foreign_investment", ZERO_OR_ONE, success_callback // TODO: foreign investment
 	)(root);
 
 	ret &= add_country_history_entry(
-		game_manager.get_country_manager().get_country_by_identifier(name), date, primary_culture,
+		&country, date, primary_culture,
 		std::move(accepted_cultures), religion, ruling_party, last_election, std::move(upper_house), capital, government_type,
-		plurality, national_value, civilised, prestige, std::move(reforms), initial_oob, updated_accepted_cultures,
+		plurality, national_value, civilised, prestige, std::move(reforms), std::move(initial_oob), updated_accepted_cultures,
 		updated_upper_house, updated_reforms
 	);
 	return ret;
 }
 
-bool CountryHistoryManager::load_country_history_file(GameManager& game_manager, std::string_view name, ast::NodeCPtr root) {
-	if (game_manager.get_country_manager().get_country_by_identifier(name)->is_dynamic_tag()) {
+bool CountryHistoryManager::load_country_history_file(
+	GameManager& game_manager, Dataloader const& dataloader, Country const& country, ast::NodeCPtr root
+) {
+	if (country.is_dynamic_tag()) {
 		return true; /* as far as I can tell dynamic countries are hardcoded, broken, and unused */
 	}
 
-	bool ret = _load_country_history_entry(game_manager, name, game_manager.get_define_manager().get_start_date(), root);
+	bool ret = _load_country_history_entry(
+		game_manager, dataloader, country, game_manager.get_define_manager().get_start_date(), root
+	);
 
-	ret &= expect_dictionary([this, &game_manager, &name](std::string_view key, ast::NodeCPtr value) -> bool {
+	ret &= expect_dictionary([this, &game_manager, &dataloader, &country](std::string_view key, ast::NodeCPtr value) -> bool {
 		bool is_date = false;
 		Date entry = Date::from_string(key, &is_date, true);
 		if (!is_date) {
@@ -362,13 +333,13 @@ bool CountryHistoryManager::load_country_history_file(GameManager& game_manager,
 		Date end_date = game_manager.get_define_manager().get_end_date();
 		if (entry > end_date) {
 			Logger::error(
-				"History entry ", entry.to_string(), " of country ", name, " defined after defined end date ",
-				end_date.to_string()
+				"History entry ", entry.to_string(), " of country ", country.get_identifier(),
+				" defined after defined end date ", end_date.to_string()
 			);
 			return false;
 		}
 
-		return _load_country_history_entry(game_manager, name, entry, value);
+		return _load_country_history_entry(game_manager, dataloader, country, entry, value);
 	})(root);
 
 	return ret;