Rename `scope_t` enum to `scope_type_t`

20 files changed, 153 insertions, 108 deletions

diff --git a/src/openvic-simulation/economy/production/ProductionType.cpp b/src/openvic-simulation/economy/production/ProductionType.cpp
index 7c4dfef..874ec61 100644
--- a/src/openvic-simulation/economy/production/ProductionType.cpp
+++ b/src/openvic-simulation/economy/production/ProductionType.cpp
@@ -254,13 +254,18 @@ bool ProductionTypeManager::load_production_types_file(
 			auto parse_node = expect_dictionary_keys(
 				"template", ZERO_OR_ONE, success_callback, /* Already parsed using expect_key in Pass #1 above. */
 				"bonus", ZERO_OR_MORE, [&bonuses](ast::NodeCPtr bonus_node) -> bool {
-					ConditionScript trigger { scope_t::STATE, scope_t::NO_SCOPE, scope_t::NO_SCOPE };
+					using enum scope_type_t;
+
+					ConditionScript trigger { STATE, NO_SCOPE, NO_SCOPE };
 					fixed_point_t bonus_value {};
+
 					const bool ret = expect_dictionary_keys(
 						"trigger", ONE_EXACTLY, trigger.expect_script(),
 						"value", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(bonus_value))
 					)(bonus_node);
+
 					bonuses.emplace_back(std::move(trigger), bonus_value);
+
 					return ret;
 				},
 				"owner", ZERO_OR_ONE, _expect_job(good_definition_manager, pop_manager, move_variable_callback(owner)),
diff --git a/src/openvic-simulation/map/Crime.cpp b/src/openvic-simulation/map/Crime.cpp
index f52352c..ce0c623 100644
--- a/src/openvic-simulation/map/Crime.cpp
+++ b/src/openvic-simulation/map/Crime.cpp
@@ -30,9 +30,11 @@ bool CrimeManager::load_crime_modifiers(ModifierManager const& modifier_manager,
 	const bool ret = expect_dictionary_reserve_length(
 		crime_modifiers,
 		[this, &modifier_manager](std::string_view key, ast::NodeCPtr value) -> bool {
+			using enum scope_type_t;
+
 			ModifierValue modifier_value;
 			IconModifier::icon_t icon = 0;
-			ConditionScript trigger { scope_t::PROVINCE, scope_t::NO_SCOPE, scope_t::NO_SCOPE };
+			ConditionScript trigger { PROVINCE, NO_SCOPE, NO_SCOPE };
 			bool default_active = false;
 
 			bool ret = NodeTools::expect_dictionary_keys_and_default(
diff --git a/src/openvic-simulation/military/Wargoal.cpp b/src/openvic-simulation/military/Wargoal.cpp
index 773e791..ce6b153 100644
--- a/src/openvic-simulation/military/Wargoal.cpp
+++ b/src/openvic-simulation/military/Wargoal.cpp
@@ -86,6 +86,7 @@ bool WargoalTypeManager::load_wargoal_file(ovdl::v2script::Parser const& parser)
 			}
 
 			using enum WargoalType::peace_options_t;
+			using enum scope_type_t;
 
 			std::string_view war_name;
 			Timespan available {}, truce {};
@@ -94,12 +95,12 @@ bool WargoalTypeManager::load_wargoal_file(ovdl::v2script::Parser const& parser)
 				mutual = false, all_allowed_states = false, always = false;
 			WargoalType::peace_options_t peace_options = NO_PEACE_OPTIONS;
 			WargoalType::peace_modifiers_t modifiers;
-			ConditionScript can_use { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::COUNTRY };
-			ConditionScript is_valid { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::COUNTRY };
-			ConditionScript allowed_states { scope_t::STATE, scope_t::COUNTRY, scope_t::COUNTRY };
-			ConditionScript allowed_substate_regions { scope_t::STATE, scope_t::COUNTRY, scope_t::COUNTRY };
-			ConditionScript allowed_states_in_crisis { scope_t::STATE, scope_t::COUNTRY, scope_t::COUNTRY };
-			ConditionScript allowed_countries { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::COUNTRY };
+			ConditionScript can_use { COUNTRY, COUNTRY, COUNTRY };
+			ConditionScript is_valid { COUNTRY, COUNTRY, COUNTRY };
+			ConditionScript allowed_states { STATE, COUNTRY, COUNTRY };
+			ConditionScript allowed_substate_regions { STATE, COUNTRY, COUNTRY };
+			ConditionScript allowed_states_in_crisis { STATE, COUNTRY, COUNTRY };
+			ConditionScript allowed_countries { COUNTRY, COUNTRY, COUNTRY };
 			EffectScript on_add, on_po_accepted; //country as default scope for both
 
 			const auto expect_peace_option = [&peace_options](WargoalType::peace_options_t peace_option) -> node_callback_t {
diff --git a/src/openvic-simulation/misc/Decision.cpp b/src/openvic-simulation/misc/Decision.cpp
index 41d4f81..7812fc1 100644
--- a/src/openvic-simulation/misc/Decision.cpp
+++ b/src/openvic-simulation/misc/Decision.cpp
@@ -55,12 +55,15 @@ bool DecisionManager::load_decision_file(ast::NodeCPtr root) {
 		"political_decisions", ZERO_OR_ONE, expect_dictionary_reserve_length(
 			decisions,
 			[this](std::string_view identifier, ast::NodeCPtr node) -> bool {
+				using enum scope_type_t;
+
 				bool alert = true, news = false;
 				std::string_view news_title, news_desc_long, news_desc_medium, news_desc_short, picture;
-				ConditionScript potential { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-				ConditionScript allow { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-				ConditionalWeight ai_will_do { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+				ConditionScript potential { COUNTRY, COUNTRY, NO_SCOPE };
+				ConditionScript allow { COUNTRY, COUNTRY, NO_SCOPE };
+				ConditionalWeight ai_will_do { COUNTRY, COUNTRY, NO_SCOPE };
 				EffectScript effect;
+
 				bool ret = expect_dictionary_keys(
 					"alert", ZERO_OR_ONE, expect_bool(assign_variable_callback(alert)),
 					"news", ZERO_OR_ONE, expect_bool(assign_variable_callback(news)),
@@ -74,10 +77,12 @@ bool DecisionManager::load_decision_file(ast::NodeCPtr root) {
 					"effect", ONE_EXACTLY, effect.expect_script(),
 					"ai_will_do", ZERO_OR_ONE, ai_will_do.expect_conditional_weight(ConditionalWeight::FACTOR)
 				)(node);
+
 				ret &= add_decision(
 					identifier, alert, news, news_title, news_desc_long, news_desc_medium, news_desc_short, picture,
 					std::move(potential), std::move(allow), std::move(ai_will_do), std::move(effect)
 				);
+
 				return ret;
 			}
 		)
diff --git a/src/openvic-simulation/misc/Event.cpp b/src/openvic-simulation/misc/Event.cpp
index 5bfc929..3c85afb 100644
--- a/src/openvic-simulation/misc/Event.cpp
+++ b/src/openvic-simulation/misc/Event.cpp
@@ -119,15 +119,17 @@ bool EventManager::load_event_file(IssueManager const& issue_manager, ast::NodeC
 	return expect_dictionary_reserve_length(
 		events,
 		[this, &issue_manager](std::string_view key, ast::NodeCPtr value) -> bool {
+			using enum scope_type_t;
+
 			Event::event_type_t type;
-			scope_t initial_scope;
+			scope_type_t initial_scope;
 
 			if (key == "country_event") {
 				type = Event::event_type_t::COUNTRY;
-				initial_scope = scope_t::COUNTRY;
+				initial_scope = COUNTRY;
 			} else if (key == "province_event") {
 				type = Event::event_type_t::PROVINCE;
-				initial_scope = scope_t::PROVINCE;
+				initial_scope = PROVINCE;
 			} else {
 				Logger::error("Invalid event type: ", key);
 				return false;
@@ -138,8 +140,8 @@ bool EventManager::load_event_file(IssueManager const& issue_manager, ast::NodeC
 			bool triggered_only = false, major = false, fire_only_once = false, allows_multiple_instances = false,
 				news = false, election = false;
 			IssueGroup const* election_issue_group = nullptr;
-			ConditionScript trigger { initial_scope, initial_scope, scope_t::NO_SCOPE };
-			ConditionalWeight mean_time_to_happen { initial_scope, initial_scope, scope_t::NO_SCOPE };
+			ConditionScript trigger { initial_scope, initial_scope, NO_SCOPE };
+			ConditionalWeight mean_time_to_happen { initial_scope, initial_scope, NO_SCOPE };
 			EffectScript immediate;
 			std::vector<Event::EventOption> options;
 
@@ -166,7 +168,7 @@ bool EventManager::load_event_file(IssueManager const& issue_manager, ast::NodeC
 					ConditionalWeight ai_chance {
 						initial_scope,
 						initial_scope,
-						scope_t::COUNTRY | scope_t::PROVINCE
+						COUNTRY | PROVINCE // TODO - decide which to use?
 					};
 
 					bool ret = expect_dictionary_keys_and_default(
diff --git a/src/openvic-simulation/misc/SongChance.cpp b/src/openvic-simulation/misc/SongChance.cpp
index 94fb571..d05afdf 100644
--- a/src/openvic-simulation/misc/SongChance.cpp
+++ b/src/openvic-simulation/misc/SongChance.cpp
@@ -17,12 +17,14 @@ bool SongChanceManager::load_songs_file(ast::NodeCPtr root) {
 	ret &= expect_dictionary_reserve_length(
 		song_chances,
 		[this](std::string_view key, ast::NodeCPtr value) -> bool {
+			using enum scope_type_t;
+
 			if (key != "song") {
 				Logger::error("Invalid song declaration ", key);
 				return false;
 			}
 			std::string_view name {};
-			ConditionalWeight chance { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+			ConditionalWeight chance { COUNTRY, COUNTRY, NO_SCOPE };
 
 			bool ret = expect_dictionary_keys(
 				"name", ONE_EXACTLY, expect_string(assign_variable_callback(name)),
diff --git a/src/openvic-simulation/modifier/ModifierManager.cpp b/src/openvic-simulation/modifier/ModifierManager.cpp
index a5ef8a8..9d6d3f8 100644
--- a/src/openvic-simulation/modifier/ModifierManager.cpp
+++ b/src/openvic-simulation/modifier/ModifierManager.cpp
@@ -630,9 +630,11 @@ bool ModifierManager::load_triggered_modifiers(const ast::NodeCPtr root) {
 	const bool ret = expect_dictionary_reserve_length(
 		triggered_modifiers,
 		[this](const std::string_view key, const ast::NodeCPtr value) -> bool {
+			using enum scope_type_t;
+
 			ModifierValue modifier_value {};
 			IconModifier::icon_t icon = 0;
-			ConditionScript trigger { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+			ConditionScript trigger { COUNTRY, COUNTRY, NO_SCOPE };
 
 			bool ret = expect_dictionary_keys_and_default(
 				expect_base_country_modifier(modifier_value),
diff --git a/src/openvic-simulation/politics/Ideology.cpp b/src/openvic-simulation/politics/Ideology.cpp
index 546d16e..ca21997 100644
--- a/src/openvic-simulation/politics/Ideology.cpp
+++ b/src/openvic-simulation/politics/Ideology.cpp
@@ -83,15 +83,17 @@ bool IdeologyManager::load_ideology_file(ast::NodeCPtr root) {
 		IdeologyGroup const* ideology_group = get_ideology_group_by_identifier(ideology_group_key);
 
 		return expect_dictionary([this, ideology_group](std::string_view key, ast::NodeCPtr value) -> bool {
+			using enum scope_type_t;
+
 			colour_t colour = colour_t::null();
 			bool uncivilised = true, can_reduce_militancy = false;
 			Date spawn_date;
-			ConditionalWeight add_political_reform { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight remove_political_reform { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight add_social_reform { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight remove_social_reform { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight add_military_reform { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight add_economic_reform { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+			ConditionalWeight add_political_reform { COUNTRY, COUNTRY, NO_SCOPE };
+			ConditionalWeight remove_political_reform { COUNTRY, COUNTRY, NO_SCOPE };
+			ConditionalWeight add_social_reform { COUNTRY, COUNTRY, NO_SCOPE };
+			ConditionalWeight remove_social_reform { COUNTRY, COUNTRY, NO_SCOPE };
+			ConditionalWeight add_military_reform { COUNTRY, COUNTRY, NO_SCOPE };
+			ConditionalWeight add_economic_reform { COUNTRY, COUNTRY, NO_SCOPE };
 
 			bool ret = expect_dictionary_keys(
 				"uncivilized", ZERO_OR_ONE, expect_bool(assign_variable_callback(uncivilised)),
@@ -99,20 +101,24 @@ bool IdeologyManager::load_ideology_file(ast::NodeCPtr root) {
 				"date", ZERO_OR_ONE, expect_date(assign_variable_callback(spawn_date)),
 				"can_reduce_militancy", ZERO_OR_ONE, expect_bool(assign_variable_callback(can_reduce_militancy)),
 				"add_political_reform", ONE_EXACTLY, add_political_reform.expect_conditional_weight(ConditionalWeight::BASE),
-				"remove_political_reform", ONE_EXACTLY, remove_political_reform.expect_conditional_weight(ConditionalWeight::BASE),
+				"remove_political_reform", ONE_EXACTLY,
+					remove_political_reform.expect_conditional_weight(ConditionalWeight::BASE),
 				"add_social_reform", ONE_EXACTLY, add_social_reform.expect_conditional_weight(ConditionalWeight::BASE),
 				"remove_social_reform", ONE_EXACTLY, remove_social_reform.expect_conditional_weight(ConditionalWeight::BASE),
 				"add_military_reform", ZERO_OR_ONE, add_military_reform.expect_conditional_weight(ConditionalWeight::BASE),
 				"add_economic_reform", ZERO_OR_ONE, add_economic_reform.expect_conditional_weight(ConditionalWeight::BASE)
 			)(value);
+
 			ret &= add_ideology(
 				key, colour, ideology_group, uncivilised, can_reduce_militancy, spawn_date, std::move(add_political_reform),
 				std::move(remove_political_reform), std::move(add_social_reform), std::move(remove_social_reform),
 				std::move(add_military_reform), std::move(add_economic_reform)
 			);
+
 			return ret;
 		})(ideology_group_value);
 	})(root);
+
 	lock_ideologies();
 
 	return ret;
diff --git a/src/openvic-simulation/politics/Issue.cpp b/src/openvic-simulation/politics/Issue.cpp
index 8da09fc..71356b6 100644
--- a/src/openvic-simulation/politics/Issue.cpp
+++ b/src/openvic-simulation/politics/Issue.cpp
@@ -221,12 +221,14 @@ bool IssueManager::_load_reform(
 	ModifierManager const& modifier_manager, RuleManager const& rule_manager, size_t ordinal, std::string_view identifier,
 	ReformGroup const* group, ast::NodeCPtr node
 ) {
+	using enum scope_type_t;
+
 	ModifierValue values;
 	RuleSet rules;
 	fixed_point_t administrative_multiplier = 0;
 	Reform::tech_cost_t technology_cost = 0;
-	ConditionScript allow { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-	ConditionScript on_execute_trigger { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+	ConditionScript allow { COUNTRY, COUNTRY, NO_SCOPE };
+	ConditionScript on_execute_trigger { COUNTRY, COUNTRY, NO_SCOPE };
 	EffectScript on_execute_effect;
 
 	bool ret = NodeTools::expect_dictionary_keys_and_default(
diff --git a/src/openvic-simulation/politics/NationalFocus.cpp b/src/openvic-simulation/politics/NationalFocus.cpp
index 2427d7c..b60b3f5 100644
--- a/src/openvic-simulation/politics/NationalFocus.cpp
+++ b/src/openvic-simulation/politics/NationalFocus.cpp
@@ -117,6 +117,8 @@ bool NationalFocusManager::load_national_foci_file(
 				[this, &group, &pop_manager, &ideology_manager, &good_definition_manager, &modifier_manager](
 					std::string_view identifier, ast::NodeCPtr node
 				) -> bool {
+					using enum scope_type_t;
+
 					uint8_t icon = 0;
 					bool has_flashpoint = false, own_provinces = true, outliner_show_as_percent = false;
 					fixed_point_t flashpoint_tension = 0;
@@ -127,7 +129,7 @@ bool NationalFocusManager::load_national_foci_file(
 					fixed_point_map_t<GoodDefinition const*> encourage_goods;
 					fixed_point_map_t<PopType const*> encourage_pop_types;
 					ConditionScript limit {
-						scope_t::PROVINCE | scope_t::COUNTRY, scope_t::PROVINCE | scope_t::COUNTRY, scope_t::NO_SCOPE
+						PROVINCE | COUNTRY, PROVINCE | COUNTRY, NO_SCOPE
 					};
 
 					const auto expect_base_province_modifier_cb = modifier_manager.expect_base_province_modifier(modifiers);
diff --git a/src/openvic-simulation/politics/Rebel.cpp b/src/openvic-simulation/politics/Rebel.cpp
index 9b2927c..ccaee5e 100644
--- a/src/openvic-simulation/politics/Rebel.cpp
+++ b/src/openvic-simulation/politics/Rebel.cpp
@@ -98,6 +98,8 @@ bool RebelManager::load_rebels_file(
 	bool ret = expect_dictionary_reserve_length(
 		rebel_types,
 		[this, &ideology_manager, &government_type_manager](std::string_view identifier, ast::NodeCPtr node) -> bool {
+			using enum scope_type_t;
+
 			RebelType::icon_t icon = 0;
 			RebelType::area_t area = RebelType::area_t::ALL;
 			RebelType::government_map_t desired_governments;
@@ -109,11 +111,11 @@ bool RebelManager::load_rebels_file(
 				allow_all_religions = true, allow_all_ideologies = true, resilient = true, reinforcing = true, general = true,
 				smart = true, unit_transfer = false;
 			fixed_point_t occupation_mult = 0;
-			ConditionalWeight will_rise { scope_t::POP, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight spawn_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
-			ConditionalWeight movement_evaluation { scope_t::PROVINCE, scope_t::PROVINCE, scope_t::NO_SCOPE };
-			ConditionScript siege_won_trigger { scope_t::PROVINCE, scope_t::PROVINCE, scope_t::NO_SCOPE };
-			ConditionScript demands_enforced_trigger { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+			ConditionalWeight will_rise { POP, COUNTRY, NO_SCOPE };
+			ConditionalWeight spawn_chance { POP, POP, NO_SCOPE };
+			ConditionalWeight movement_evaluation { PROVINCE, PROVINCE, NO_SCOPE };
+			ConditionScript siege_won_trigger { PROVINCE, PROVINCE, NO_SCOPE };
+			ConditionScript demands_enforced_trigger { COUNTRY, COUNTRY, NO_SCOPE };
 			EffectScript siege_won_effect, demands_enforced_effect;
 
 			bool ret = expect_dictionary_keys(
diff --git a/src/openvic-simulation/pop/Pop.cpp b/src/openvic-simulation/pop/Pop.cpp
index 4b81e5d..10337a9 100644
--- a/src/openvic-simulation/pop/Pop.cpp
+++ b/src/openvic-simulation/pop/Pop.cpp
@@ -236,13 +236,13 @@ bool PopType::parse_scripts(DefinitionManager const& definition_manager) {
 
 PopManager::PopManager()
   : slave_sprite { 0 }, administrative_sprite { 0 },
-	promotion_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE },
-	demotion_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE },
-	migration_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE },
-	colonialmigration_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE },
-	emigration_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE },
-	assimilation_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE },
-	conversion_chance { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE } {}
+	promotion_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE },
+	demotion_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE },
+	migration_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE },
+	colonialmigration_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE },
+	emigration_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE },
+	assimilation_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE },
+	conversion_chance { scope_type_t::POP, scope_type_t::POP, scope_type_t::NO_SCOPE } {}
 
 bool PopManager::add_strata(std::string_view identifier) {
 	if (identifier.empty()) {
@@ -423,6 +423,8 @@ bool PopManager::load_pop_type_file(
 	std::string_view filestem, GoodDefinitionManager const& good_definition_manager, IdeologyManager const& ideology_manager,
 	ast::NodeCPtr root
 ) {
+	using enum scope_type_t;
+
 	colour_t colour = colour_t::null();
 	Strata const* strata = nullptr;
 	PopType::sprite_t sprite = 0;
@@ -437,8 +439,8 @@ bool PopManager::load_pop_type_file(
 	fixed_point_t research_points = 0, leadership_points = 0, research_leadership_optimum = 0,
 		state_administration_multiplier = 0;
 	ast::NodeCPtr equivalent = nullptr;
-	ConditionalWeight country_migration_target { scope_t::COUNTRY, scope_t::POP, scope_t::NO_SCOPE };
-	ConditionalWeight migration_target { scope_t::PROVINCE, scope_t::POP, scope_t::NO_SCOPE };
+	ConditionalWeight country_migration_target { COUNTRY, POP, NO_SCOPE };
+	ConditionalWeight migration_target { PROVINCE, POP, NO_SCOPE };
 	ast::NodeCPtr promote_to_node = nullptr;
 	PopType::ideology_weight_map_t ideologies;
 	ast::NodeCPtr issues_node = nullptr;
@@ -487,9 +489,12 @@ bool PopManager::load_pop_type_file(
 		"ideologies", ZERO_OR_ONE, ideology_manager.expect_ideology_dictionary_reserve_length(
 			ideologies,
 			[&filestem, &ideologies](Ideology const& ideology, ast::NodeCPtr node) -> bool {
-				ConditionalWeight weight { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
+				ConditionalWeight weight { POP, POP, NO_SCOPE };
+
 				bool ret = weight.expect_conditional_weight(ConditionalWeight::FACTOR)(node);
+
 				ret &= map_callback(ideologies, &ideology)(std::move(weight));
+
 				return ret;
 			}
 		),
@@ -546,7 +551,11 @@ bool PopManager::load_pop_type_file(
 	return ret;
 }
 
-bool PopManager::load_delayed_parse_pop_type_data(UnitTypeManager const& unit_type_manager, IssueManager const& issue_manager) {
+bool PopManager::load_delayed_parse_pop_type_data(
+	UnitTypeManager const& unit_type_manager, IssueManager const& issue_manager
+) {
+	using enum scope_type_t;
+
 	bool ret = true;
 	for (size_t index = 0; index < delayed_parse_nodes.size(); ++index) {
 		const auto [rebel_units, equivalent, promote_to_node, issues_node] = delayed_parse_nodes[index];
@@ -573,7 +582,7 @@ bool PopManager::load_delayed_parse_pop_type_data(UnitTypeManager const& unit_ty
 					Logger::error("Pop type ", type, " cannot have promotion weight to itself!");
 					return false;
 				}
-				ConditionalWeight weight { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
+				ConditionalWeight weight { POP, POP, NO_SCOPE };
 				bool ret = weight.expect_conditional_weight(ConditionalWeight::FACTOR)(node);
 				ret &= map_callback(pop_type->promote_to, &type)(std::move(weight));
 				return ret;
@@ -594,7 +603,7 @@ bool PopManager::load_delayed_parse_pop_type_data(UnitTypeManager const& unit_ty
 					Logger::error("Invalid issue in pop type ", pop_type, " issue weights: ", key);
 					return false;
 				}
-				ConditionalWeight weight { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
+				ConditionalWeight weight { POP, POP, NO_SCOPE };
 				bool ret = weight.expect_conditional_weight(ConditionalWeight::FACTOR)(node);
 				ret &= map_callback(pop_type->issues, issue)(std::move(weight));
 				return ret;
diff --git a/src/openvic-simulation/research/Invention.cpp b/src/openvic-simulation/research/Invention.cpp
index 1076a62..4351337 100644
--- a/src/openvic-simulation/research/Invention.cpp
+++ b/src/openvic-simulation/research/Invention.cpp
@@ -62,6 +62,8 @@ bool InventionManager::load_inventions_file(
 		inventions, [this, &modifier_manager, &unit_type_manager, &building_type_manager, &crime_manager](
 			std::string_view identifier, ast::NodeCPtr value
 		) -> bool {
+			using enum scope_type_t;
+
 			// TODO - use the same variable for all modifiers rather than combining them at the end?
 			ModifierValue loose_modifiers;
 			ModifierValue modifiers;
@@ -74,8 +76,8 @@ bool InventionManager::load_inventions_file(
 			bool unlock_gas_defence = false;
 			bool news = true; //defaults to true!
 
-			ConditionScript limit { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
-			ConditionalWeight chance { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+			ConditionScript limit { COUNTRY, COUNTRY, NO_SCOPE };
+			ConditionalWeight chance { COUNTRY, COUNTRY, NO_SCOPE };
 
 			bool ret = NodeTools::expect_dictionary_keys_and_default(
 				modifier_manager.expect_base_country_modifier(loose_modifiers),
diff --git a/src/openvic-simulation/research/Technology.cpp b/src/openvic-simulation/research/Technology.cpp
index 9a1cf27..f2df94b 100644
--- a/src/openvic-simulation/research/Technology.cpp
+++ b/src/openvic-simulation/research/Technology.cpp
@@ -168,6 +168,8 @@ bool TechnologyManager::load_technologies_file(
 	return expect_dictionary_reserve_length(technologies, [this, &modifier_manager, &unit_type_manager, &building_type_manager](
 		std::string_view tech_key, ast::NodeCPtr tech_value
 	) -> bool {
+		using enum scope_type_t;
+
 		ModifierValue modifiers;
 		TechnologyArea const* area = nullptr;
 		Date::year_t year = 0;
@@ -176,7 +178,7 @@ bool TechnologyManager::load_technologies_file(
 		std::optional<CountryInstance::unit_variant_t> unit_variant;
 		Technology::unit_set_t activated_units;
 		Technology::building_set_t activated_buildings;
-		ConditionalWeight ai_chance { scope_t::COUNTRY, scope_t::COUNTRY, scope_t::NO_SCOPE };
+		ConditionalWeight ai_chance { COUNTRY, COUNTRY, NO_SCOPE };
 
 		bool ret = NodeTools::expect_dictionary_keys_and_default(
 			modifier_manager.expect_technology_modifier(modifiers),
diff --git a/src/openvic-simulation/scripts/Condition.cpp b/src/openvic-simulation/scripts/Condition.cpp
index fd1f4fa..bb8b662 100644
--- a/src/openvic-simulation/scripts/Condition.cpp
+++ b/src/openvic-simulation/scripts/Condition.cpp
@@ -7,12 +7,12 @@ using namespace OpenVic;
 using namespace OpenVic::NodeTools;
 
 using enum value_type_t;
-using enum scope_t;
+using enum scope_type_t;
 using enum identifier_type_t;
 
 Condition::Condition(
-	std::string_view new_identifier, value_type_t new_value_type, scope_t new_scope,
-	scope_t new_scope_change, identifier_type_t new_key_identifier_type,
+	std::string_view new_identifier, value_type_t new_value_type, scope_type_t new_scope,
+	scope_type_t new_scope_change, identifier_type_t new_key_identifier_type,
 	identifier_type_t new_value_identifier_type
 ) : HasIdentifier { new_identifier }, value_type { new_value_type }, scope { new_scope },
 	scope_change { new_scope_change }, key_identifier_type { new_key_identifier_type },
@@ -26,7 +26,7 @@ ConditionNode::ConditionNode(
 	condition_key_item { new_condition_key_item }, condition_value_item { new_condition_key_item } {}
 
 bool ConditionManager::add_condition(
-	std::string_view identifier, value_type_t value_type, scope_t scope, scope_t scope_change,
+	std::string_view identifier, value_type_t value_type, scope_type_t scope, scope_type_t scope_change,
 	identifier_type_t key_identifier_type, identifier_type_t value_identifier_type
 ) {
 	if (identifier.empty()) {
@@ -337,8 +337,8 @@ bool ConditionManager::setup_conditions(DefinitionManager const& definition_mana
 	const auto import_identifiers = [this, &ret](
 		std::vector<std::string_view> const& identifiers,
 		value_type_t value_type,
-		scope_t scope,
-		scope_t scope_change = NO_SCOPE,
+		scope_type_t scope,
+		scope_type_t scope_change = NO_SCOPE,
 		identifier_type_t key_identifier_type = NO_IDENTIFIER,
 		identifier_type_t value_identifier_type = NO_IDENTIFIER
 	) -> void {
@@ -523,10 +523,10 @@ callback_t<std::string_view> ConditionManager::expect_parse_identifier(
 }
 
 node_callback_t ConditionManager::expect_condition_node(
-	DefinitionManager const& definition_manager, Condition const& condition, scope_t this_scope,
-	scope_t from_scope, scope_t cur_scope, callback_t<ConditionNode&&> callback
+	DefinitionManager const& definition_manager, Condition const& condition, scope_type_t current_scope,
+	scope_type_t this_scope, scope_type_t from_scope, callback_t<ConditionNode&&> callback
 ) const {
-	return [this, &definition_manager, &condition, callback, this_scope, from_scope, cur_scope](
+	return [this, &definition_manager, &condition, callback, current_scope, this_scope, from_scope](
 		ast::NodeCPtr node
 	) -> bool {
 		bool ret = false;
@@ -534,8 +534,8 @@ node_callback_t ConditionManager::expect_condition_node(
 
 		const std::string_view identifier = condition.get_identifier();
 		const value_type_t value_type = condition.get_value_type();
-		const scope_t scope = condition.get_scope();
-		const scope_t scope_change = condition.get_scope_change();
+		const scope_type_t scope = condition.get_scope();
+		const scope_type_t scope_change = condition.get_scope_change();
 		const identifier_type_t key_identifier_type = condition.get_key_identifier_type();
 		const identifier_type_t value_identifier_type = condition.get_value_identifier_type();
 
@@ -647,23 +647,24 @@ node_callback_t ConditionManager::expect_condition_node(
 		if (!ret && share_value_type(value_type, GROUP)) {
 			ConditionNode::condition_list_t node_list;
 			ret |= expect_condition_node_list(
-				definition_manager, this_scope, from_scope,
-				scope_change == NO_SCOPE ? cur_scope : scope_change,
-				false,
+				definition_manager,
+				scope_change == NO_SCOPE ? current_scope : scope_change,
+				this_scope,
+				from_scope,
 				vector_callback(node_list)
 			)(node);
 			value = std::move(node_list);
 		}
 
 		// scope validation
-		scope_t effective_current_scope = cur_scope;
-		if (share_scope(effective_current_scope, THIS)) {
+		scope_type_t effective_current_scope = current_scope;
+		if (share_scope_type(effective_current_scope, THIS)) {
 			effective_current_scope = this_scope;
-		} else if (share_scope(effective_current_scope, FROM)) {
+		} else if (share_scope_type(effective_current_scope, FROM)) {
 			effective_current_scope = from_scope;
 		}
 
-		if (!share_scope(scope, effective_current_scope) && effective_current_scope > scope) {
+		if (!share_scope_type(scope, effective_current_scope) && effective_current_scope > scope) {
 			Logger::warning(
 				"Condition or scope ", identifier, " was found in wrong scope ", effective_current_scope, ", expected ",
 				scope, "!"
@@ -706,15 +707,15 @@ static bool top_scope_fallback(std::string_view id, ast::NodeCPtr node) {
 };
 
 node_callback_t ConditionManager::expect_condition_node_list(
-	DefinitionManager const& definition_manager, scope_t this_scope, scope_t from_scope,
-	scope_t cur_scope, bool top_scope, callback_t<ConditionNode&&> callback
+	DefinitionManager const& definition_manager, scope_type_t current_scope, scope_type_t this_scope, scope_type_t from_scope,
+	callback_t<ConditionNode&&> callback, bool top_scope
 ) const {
-	return [this, &definition_manager, callback, this_scope, from_scope, cur_scope, top_scope](ast::NodeCPtr node) -> bool {
+	return [this, &definition_manager, callback, current_scope, this_scope, from_scope, top_scope](ast::NodeCPtr node) -> bool {
 		const auto expect_node = [
-			this, &definition_manager, callback, this_scope, from_scope, cur_scope
+			this, &definition_manager, callback, current_scope, this_scope, from_scope
 		](Condition const& condition, ast::NodeCPtr node) -> bool {
 			return expect_condition_node(
-				definition_manager, condition, this_scope, from_scope, cur_scope, callback
+				definition_manager, condition, current_scope, this_scope, from_scope, callback
 			)(node);
 		};
 
@@ -729,19 +730,19 @@ node_callback_t ConditionManager::expect_condition_node_list(
 }
 
 node_callback_t ConditionManager::expect_condition_script(
-	DefinitionManager const& definition_manager, scope_t initial_scope, scope_t this_scope,
-	scope_t from_scope, callback_t<ConditionNode&&> callback
+	DefinitionManager const& definition_manager, scope_type_t initial_scope, scope_type_t this_scope,
+	scope_type_t from_scope, callback_t<ConditionNode&&> callback
 ) const {
 	return [this, &definition_manager, initial_scope, this_scope, from_scope, callback](ast::NodeCPtr node) -> bool {
 
 		ConditionNode::condition_list_t conds;
 		bool ret = expect_condition_node_list(
 			definition_manager,
+			initial_scope,
 			this_scope,
 			from_scope,
-			initial_scope,
-			true,
-			NodeTools::vector_callback(conds)
+			NodeTools::vector_callback(conds),
+			true
 		)(node);
 
 		ret &= callback({ root_condition, std::move(conds), true });
diff --git a/src/openvic-simulation/scripts/Condition.hpp b/src/openvic-simulation/scripts/Condition.hpp
index 8d4d246..1f4929a 100644
--- a/src/openvic-simulation/scripts/Condition.hpp
+++ b/src/openvic-simulation/scripts/Condition.hpp
@@ -27,7 +27,7 @@ namespace OpenVic {
 
 	// Order matters in this enum, for the fallback system to work
 	// smaller entities must have smaller integers associated!
-	enum class scope_t : uint8_t { //TODO: maybe distinguish TRANSPARENT from NO_SCOPE
+	enum class scope_type_t : uint8_t { //TODO: maybe distinguish TRANSPARENT from NO_SCOPE
 		NO_SCOPE    = 0,
 		POP         = 1 << 0,
 		PROVINCE    = 1 << 1,
@@ -74,15 +74,15 @@ namespace OpenVic {
 
 	/* Allows enum types to be used with bitwise operators. */
 	template<> struct enable_bitfield<value_type_t> : std::true_type {};
-	template<> struct enable_bitfield<scope_t> : std::true_type {};
+	template<> struct enable_bitfield<scope_type_t> : std::true_type {};
 	template<> struct enable_bitfield<identifier_type_t> : std::true_type {};
 
 	/* Returns true if the values have any bit in common. */
 	inline constexpr bool share_value_type(value_type_t lhs, value_type_t rhs) {
 		return (lhs & rhs) != value_type_t::NO_TYPE;
 	}
-	inline constexpr bool share_scope(scope_t lhs, scope_t rhs) {
-		return (lhs & rhs) != scope_t::NO_SCOPE;
+	inline constexpr bool share_scope_type(scope_type_t lhs, scope_type_t rhs) {
+		return (lhs & rhs) != scope_type_t::NO_SCOPE;
 	}
 	inline constexpr bool share_identifier_type(identifier_type_t lhs, identifier_type_t rhs) {
 		return (lhs & rhs) != identifier_type_t::NO_IDENTIFIER;
@@ -122,10 +122,10 @@ namespace OpenVic {
 	}
 
 #undef BUILD_STRING
-#define BUILD_STRING(entry) _BUILD_STRING(entry, share_scope)
+#define BUILD_STRING(entry) _BUILD_STRING(entry, share_scope_type)
 
-	inline std::ostream& operator<<(std::ostream& stream, scope_t value) {
-		using enum scope_t;
+	inline std::ostream& operator<<(std::ostream& stream, scope_type_t value) {
+		using enum scope_type_t;
 		if (value == NO_SCOPE) {
 			return stream << "[NO_SCOPE]";
 		}
@@ -198,14 +198,14 @@ namespace OpenVic {
 
 	private:
 		const value_type_t PROPERTY(value_type);
-		const scope_t PROPERTY(scope);
-		const scope_t PROPERTY(scope_change);
+		const scope_type_t PROPERTY(scope);
+		const scope_type_t PROPERTY(scope_change);
 		const identifier_type_t PROPERTY(key_identifier_type);
 		const identifier_type_t PROPERTY(value_identifier_type);
 
 		Condition(
-			std::string_view new_identifier, value_type_t new_value_type, scope_t new_scope,
-			scope_t new_scope_change, identifier_type_t new_key_identifier_type,
+			std::string_view new_identifier, value_type_t new_value_type, scope_type_t new_scope,
+			scope_type_t new_scope_change, identifier_type_t new_key_identifier_type,
 			identifier_type_t new_value_identifier_type
 		);
 
@@ -249,8 +249,8 @@ namespace OpenVic {
 		Condition const* root_condition = nullptr;
 
 		bool add_condition(
-			std::string_view identifier, value_type_t value_type, scope_t scope,
-			scope_t scope_change = scope_t::NO_SCOPE,
+			std::string_view identifier, value_type_t value_type, scope_type_t scope,
+			scope_type_t scope_change = scope_type_t::NO_SCOPE,
 			identifier_type_t key_identifier_type = identifier_type_t::NO_IDENTIFIER,
 			identifier_type_t value_identifier_type = identifier_type_t::NO_IDENTIFIER
 		);
@@ -261,21 +261,21 @@ namespace OpenVic {
 		) const;
 
 		NodeTools::node_callback_t expect_condition_node(
-			DefinitionManager const& definition_manager, Condition const& condition, scope_t this_scope,
-			scope_t from_scope, scope_t cur_scope, NodeTools::callback_t<ConditionNode&&> callback
+			DefinitionManager const& definition_manager, Condition const& condition, scope_type_t current_scope,
+			scope_type_t this_scope, scope_type_t from_scope, NodeTools::callback_t<ConditionNode&&> callback
 		) const;
 
 		NodeTools::node_callback_t expect_condition_node_list(
-			DefinitionManager const& definition_manager, scope_t this_scope, scope_t from_scope,
-			scope_t cur_scope, bool top_scope, NodeTools::callback_t<ConditionNode&&> callback
+			DefinitionManager const& definition_manager, scope_type_t current_scope, scope_type_t this_scope,
+			scope_type_t from_scope, NodeTools::callback_t<ConditionNode&&> callback, bool top_scope = false
 		) const;
 
 	public:
 		bool setup_conditions(DefinitionManager const& definition_manager);
 
 		NodeTools::node_callback_t expect_condition_script(
-			DefinitionManager const& definition_manager, scope_t initial_scope, scope_t this_scope, scope_t from_scope,
-			NodeTools::callback_t<ConditionNode&&> callback
+			DefinitionManager const& definition_manager, scope_type_t initial_scope, scope_type_t this_scope,
+			scope_type_t from_scope, NodeTools::callback_t<ConditionNode&&> callback
 		) const;
 	};
 }
diff --git a/src/openvic-simulation/scripts/ConditionScript.cpp b/src/openvic-simulation/scripts/ConditionScript.cpp
index bee4d07..c556bd2 100644
--- a/src/openvic-simulation/scripts/ConditionScript.cpp
+++ b/src/openvic-simulation/scripts/ConditionScript.cpp
@@ -6,7 +6,7 @@ using namespace OpenVic;
 using namespace OpenVic::NodeTools;
 
 ConditionScript::ConditionScript(
-	scope_t new_initial_scope, scope_t new_this_scope, scope_t new_from_scope
+	scope_type_t new_initial_scope, scope_type_t new_this_scope, scope_type_t new_from_scope
 ) : initial_scope { new_initial_scope }, this_scope { new_this_scope }, from_scope { new_from_scope } {}
 
 bool ConditionScript::_parse_script(ast::NodeCPtr root, DefinitionManager const& definition_manager) {
diff --git a/src/openvic-simulation/scripts/ConditionScript.hpp b/src/openvic-simulation/scripts/ConditionScript.hpp
index e6ed255..aa386e8 100644
--- a/src/openvic-simulation/scripts/ConditionScript.hpp
+++ b/src/openvic-simulation/scripts/ConditionScript.hpp
@@ -10,14 +10,14 @@ namespace OpenVic {
 
 	private:
 		ConditionNode PROPERTY_REF(condition_root);
-		scope_t PROPERTY(initial_scope);
-		scope_t PROPERTY(this_scope);
-		scope_t PROPERTY(from_scope);
+		scope_type_t PROPERTY(initial_scope);
+		scope_type_t PROPERTY(this_scope);
+		scope_type_t PROPERTY(from_scope);
 
 	protected:
 		bool _parse_script(ast::NodeCPtr root, DefinitionManager const& definition_manager) override;
 
 	public:
-		ConditionScript(scope_t new_initial_scope, scope_t new_this_scope, scope_t new_from_scope);
+		ConditionScript(scope_type_t new_initial_scope, scope_type_t new_this_scope, scope_type_t new_from_scope);
 	};
 }
diff --git a/src/openvic-simulation/scripts/ConditionalWeight.cpp b/src/openvic-simulation/scripts/ConditionalWeight.cpp
index 7c3e0a0..ca42f1b 100644
--- a/src/openvic-simulation/scripts/ConditionalWeight.cpp
+++ b/src/openvic-simulation/scripts/ConditionalWeight.cpp
@@ -3,12 +3,12 @@
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
 
-ConditionalWeight::ConditionalWeight(scope_t new_initial_scope, scope_t new_this_scope, scope_t new_from_scope)
+ConditionalWeight::ConditionalWeight(scope_type_t new_initial_scope, scope_type_t new_this_scope, scope_type_t new_from_scope)
   : initial_scope { new_initial_scope }, this_scope { new_this_scope }, from_scope { new_from_scope } {}
 
 template<typename T>
 static NodeCallback auto expect_modifier(
-	std::vector<T>& items, scope_t initial_scope, scope_t this_scope, scope_t from_scope
+	std::vector<T>& items, scope_type_t initial_scope, scope_type_t this_scope, scope_type_t from_scope
 ) {
 	return [&items, initial_scope, this_scope, from_scope](ast::NodeCPtr node) -> bool {
 		fixed_point_t weight = 0;
diff --git a/src/openvic-simulation/scripts/ConditionalWeight.hpp b/src/openvic-simulation/scripts/ConditionalWeight.hpp
index c99d6b0..f667cd7 100644
--- a/src/openvic-simulation/scripts/ConditionalWeight.hpp
+++ b/src/openvic-simulation/scripts/ConditionalWeight.hpp
@@ -21,14 +21,14 @@ namespace OpenVic {
 	private:
 		fixed_point_t PROPERTY(base);
 		std::vector<condition_weight_item_t> PROPERTY(condition_weight_items);
-		scope_t PROPERTY(initial_scope);
-		scope_t PROPERTY(this_scope);
-		scope_t PROPERTY(from_scope);
+		scope_type_t PROPERTY(initial_scope);
+		scope_type_t PROPERTY(this_scope);
+		scope_type_t PROPERTY(from_scope);
 
 		struct parse_scripts_visitor_t;
 
 	public:
-		ConditionalWeight(scope_t new_initial_scope, scope_t new_this_scope, scope_t new_from_scope);
+		ConditionalWeight(scope_type_t new_initial_scope, scope_type_t new_this_scope, scope_type_t new_from_scope);
 		ConditionalWeight(ConditionalWeight&&) = default;
 
 		static constexpr std::string_view base_key_to_string(base_key_t base_key) {