Refactor RuleSet

Author: wvpm

src/openvic-simulation/politics/RuleSet.hpp

@@ -0,0 +1,214 @@
+#pragma once
+
+#include <cstdint>
+#include <string_view>
+
+#include "openvic-simulation/core/string/StringLiteral.hpp"
+#include "openvic-simulation/core/Typedefs.hpp"
+#include "openvic-simulation/dataloader/NodeTools.hpp"
+#include "openvic-simulation/types/OptionalBool.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
+
+namespace OpenVic {
+	//TODO replace with strategy pattern?
+	enum struct ApportionmentMethod : std::uint8_t {
+		largest_share,
+		dhont,
+		sainte_laque
+	};
+	enum struct UpperHouseComposition : std::uint8_t {
+		same_as_ruling_party,
+		rich_only,
+		state_vote,
+		population_vote
+	};
+	enum struct CulturalVotingRight : std::uint8_t {
+		primary_culture_voting,
+		culture_voting,
+		all_voting
+	};
+
+	struct RuleSet {
+	private:
+		struct RuleDefinition {
+			const std::string_view name;
+			OptionalBool const& value;
+
+			template<string_literal Name>
+			static constexpr RuleDefinition Define(OptionalBool const& value) {
+				return RuleDefinition { { Name }, value };
+			}
+		};
+
+		#define DO_FOR_ALL_RULES(F) \
+			F(build_railway) \
+			F(build_factory) \
+			F(expand_factory) \
+			F(open_factory) \
+			F(destroy_factory) \
+			F(pop_build_factory) \
+			F(pop_expand_factory) \
+			F(pop_open_factory) \
+			F(can_subsidise) \
+			F(factory_priority) \
+			F(delete_factory_if_no_input) \
+			F(build_factory_invest) \
+			F(expand_factory_invest) \
+			F(open_factory_invest) \
+			F(build_railway_invest) \
+			F(pop_build_factory_invest) \
+			F(pop_expand_factory_invest) \
+			F(pop_open_factory_invest) \
+			F(can_invest_in_pop_projects) \
+			F(allow_foreign_investment) \
+			F(primary_culture_voting) \
+			F(culture_voting) \
+			F(all_voting) \
+			F(slavery_allowed) \
+			F(same_as_ruling_party) \
+			F(rich_only) \
+			F(state_vote) \
+			F(population_vote) \
+			F(largest_share) \
+			F(dhont) \
+			F(sainte_laque)
+
+		#define RULE_FIELDS(rule) \
+			OptionalBool rule : 2 = OptionalBool::UNSPECIFIED;
+		
+		DO_FOR_ALL_RULES(RULE_FIELDS)
+		#undef RULE_FIELDS
+
+		static NodeTools::node_callback_t expect_rule_set(NodeTools::callback_t<RuleSet&&> ruleset_callback) {
+			return [ruleset_callback](ast::NodeCPtr root) mutable -> bool {
+				RuleSet ruleset;
+				using enum NodeTools::dictionary_entry_t::expected_count_t;
+				bool ret = NodeTools::expect_dictionary_keys(
+					"sainte_laque", ZERO_OR_ONE, NodeTools::expect_bool(
+						[&ruleset](const bool value) mutable -> bool {
+							const bool ret = ruleset.sainte_laque == OptionalBool::UNSPECIFIED;
+							ruleset.sainte_laque = value ? OptionalBool::TRUE : OptionalBool::FALSE;
+							return ret;
+						}
+					)
+					//TODO add the rest using the DO_FOR_ALL_RULES macro and avoid duplicating inline lambda callbacks
+				)(root);
+				ret &= ruleset_callback(std::move(ruleset));
+				return ret;
+			};
+		}
+
+		#undef DO_FOR_ALL_RULES
+
+		template <typename EnumType, size_t N>
+		constexpr EnumType select_with_priority(const RuleDefinition (&rules)[N]) const {
+			const std::string_view context_name = type_name<EnumType>();
+
+			// 1. Check for explicit TRUE flags (Highest Priority)
+			for (size_t i = 0; i < N; ++i) {
+				if (rules[i].value == OptionalBool::TRUE) {
+					if (!std::is_constant_evaluated()) {
+						// Log conflicts with lower-priority methods
+						for (size_t j = i + 1; j < N; ++j) {
+							if (OV_unlikely(rules[j].value == OptionalBool::TRUE)) {
+								spdlog::warn_s(
+									"Both {} and {} are enabled for {}. {} is picked.", 
+									rules[i].name,
+									rules[j].name,
+									context_name,
+									rules[i].name
+								);
+							}
+						}
+					}
+					return EnumType(i);
+				}
+			}
+
+			// 2. Check for UNSPECIFIED (Defaulting logic)
+			for (size_t i = 0; i < N; ++i) {
+				if (rules[i].value == OptionalBool::UNSPECIFIED) {
+					if (!std::is_constant_evaluated()) {
+						spdlog::warn_s("No {} enabled. Picking {} (unspecified).", context_name, rules[i].name);
+					}
+					return EnumType(i);
+				}
+			}
+
+			// 3. Absolute Fallback
+			if (!std::is_constant_evaluated()) {
+				spdlog::error_s("All {} options are disabled. Falling back to {}.", context_name, rules[0].name);
+			}
+			return EnumType(0);
+		}
+
+	#define DEF(Value) RuleDefinition::Define<#Value>(Value)
+
+	#define RESOLVE_DEFAULT_FALSE(method_name, field) \
+	constexpr bool method_name() const { \
+		const bool is_true = field == OptionalBool::TRUE; \
+		if (!std::is_constant_evaluated() && field == OptionalBool::UNSPECIFIED) { \
+			spdlog::warn_s("{} is not specified, returning {}.", #field, is_true); \
+		} \
+		return is_true; \
+	}
+
+	public:
+	//political
+		constexpr ApportionmentMethod get_apportionment_method() const {
+			const RuleDefinition rules[] {
+				DEF(largest_share),
+				DEF(dhont),
+				DEF(sainte_laque)
+			};
+			return select_with_priority<ApportionmentMethod>(rules);
+		}
+		constexpr UpperHouseComposition get_upper_house_composition() const {
+			const RuleDefinition rules[] {
+				DEF(same_as_ruling_party),
+				DEF(rich_only),
+				DEF(state_vote),
+				DEF(population_vote)
+			};
+			return select_with_priority<UpperHouseComposition>(rules);
+		}
+		constexpr CulturalVotingRight get_cultural_voting_rights() const {
+			const RuleDefinition rules[] {
+				DEF(primary_culture_voting),
+				DEF(culture_voting),
+				DEF(all_voting)
+			};
+			return select_with_priority<CulturalVotingRight>(rules);
+		}
+  	#undef DEF
+		RESOLVE_DEFAULT_FALSE(is_slavery_legal, slavery_allowed)
+	//economic
+		RESOLVE_DEFAULT_FALSE(may_build_infrastructure_domestically, build_railway)
+		RESOLVE_DEFAULT_FALSE(may_build_factory_domestically, build_factory)
+		RESOLVE_DEFAULT_FALSE(may_expand_factory_domestically, expand_factory)
+		RESOLVE_DEFAULT_FALSE(may_open_factory_domestically, open_factory)
+		constexpr bool may_close_factory_domestically() const {
+			return may_open_factory_domestically();
+		}
+		RESOLVE_DEFAULT_FALSE(may_destroy_factory_domestically, destroy_factory)
+		RESOLVE_DEFAULT_FALSE(may_subsidise_factory_domestically, can_subsidise)
+		RESOLVE_DEFAULT_FALSE(may_set_factory_priority_domestically, factory_priority)
+
+		RESOLVE_DEFAULT_FALSE(pop_may_build_factory_domestically, pop_build_factory)
+		RESOLVE_DEFAULT_FALSE(pop_may_expand_factory_domestically, pop_expand_factory)
+		RESOLVE_DEFAULT_FALSE(pop_may_open_factory_domestically, pop_open_factory)
+		RESOLVE_DEFAULT_FALSE(may_automatically_delete_factory_if_no_input_domestically, delete_factory_if_no_input)
+		RESOLVE_DEFAULT_FALSE(may_invest_in_pop_projects_domestically, can_invest_in_pop_projects)
+
+		RESOLVE_DEFAULT_FALSE(may_invest_in_building_factory_abroad, build_factory_invest)
+		RESOLVE_DEFAULT_FALSE(may_invest_in_expanding_factory_abroad, expand_factory_invest)
+		RESOLVE_DEFAULT_FALSE(may_invest_in_opening_factory_abroad, open_factory_invest)
+		RESOLVE_DEFAULT_FALSE(pop_may_invest_in_building_factory_abroad, pop_build_factory_invest)
+		RESOLVE_DEFAULT_FALSE(pop_may_invest_in_expanding_factory_abroad, pop_expand_factory_invest)
+		RESOLVE_DEFAULT_FALSE(pop_may_invest_in_opening_factory_abroad, pop_open_factory_invest)
+		RESOLVE_DEFAULT_FALSE(may_invest_in_expanding_infrastructure_abroad, build_railway_invest)
+
+		RESOLVE_DEFAULT_FALSE(foreigners_may_invest, allow_foreign_investment)
+	#undef RESOLVE_DEFAULT_FALSE
+	};
+}

src/openvic-simulation/types/OptionalBool.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstdint>
+
+namespace OpenVic {
+    enum struct OptionalBool : std::uint8_t {
+        UNSPECIFIED = 0,
+        TRUE = 1,
+        FALSE = 2
+    };
+}

src/openvic-simulation/types/TypedIndices.hpp

@@ -46,7 +46,6 @@ TYPED_INDEX(rebel_type_index_t)
 TYPED_INDEX(reform_index_t)
 TYPED_INDEX(reform_group_index_t)
 TYPED_INDEX(regiment_type_index_t)
-TYPED_INDEX(rule_index_t)
 TYPED_INDEX(ship_type_index_t)
 TYPED_INDEX(strata_index_t)
 TYPED_INDEX(technology_index_t)