Make fixed_point_t & pop_sum_t compatible

Author: wvpm

src/openvic-simulation/core/template/Concepts.hpp

@@ -108,9 +108,12 @@ namespace OpenVic {
 		{ t.get_name() } -> std::same_as<std::string_view>;
 	};
 
+	template<typename T>
+	concept is_strongly_typed = derived_from_specialization_of<T, type_safe::strong_typedef>;
+
 	template<typename T>
 	concept has_index = requires { typename T::index_t; } &&
-		derived_from_specialization_of<typename T::index_t, type_safe::strong_typedef> && requires {
+		is_strongly_typed<typename T::index_t> && requires {
 			static_cast<std::size_t>(
 				static_cast<type_safe::underlying_type<decltype(std::declval<T>().index)>>(std::declval<T>().index)
 			);
@@ -222,11 +225,6 @@ namespace OpenVic {
 		{ lhs /= rhs } -> std::same_as<Lhs&>;
 	};
 
-	template<typename Lhs, typename A, typename B>
-	concept mul_add_assignable = requires(Lhs& lhs, const A a, const B b) {
-		{ lhs += a * b } -> std::same_as<Lhs&>;
-	};
-
 	template<typename Lhs, typename Rhs = Lhs>
 	concept equalable = requires(Lhs const& lhs, Rhs const& rhs) {
 		{ lhs == rhs } -> std::convertible_to<bool>;

src/openvic-simulation/country/CountryInstance.cpp

@@ -1368,18 +1368,24 @@ void CountryInstance::_update_budget() {
 		administrative_efficiency_from_administrators.set(fixed_point_t::_1);
 		administrator_percentage.set(fixed_point_t::_0);
 	} else {		
-		administrator_percentage.set(fixed_point_t(administrators) / total_non_colonial_population);
-
-		const fixed_point_t desired_administrators = desired_administrator_percentage.get_untracked() * type_safe::get(total_non_colonial_population);
-		const fixed_point_t administrative_efficiency_from_administrators_unclamped = std::min(
-			fixed_point_t::mul_div(
-				type_safe::get(administrators),
-				fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency()),
-				desired_administrators
-			)
-			* (fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency_modifier())),
-			fixed_point_t::_1
+		administrator_percentage.set(fixed_point_t::from_fraction(administrators, total_non_colonial_population));
+
+		const pop_sum_t desired_administrators = fixed_point_t::multiply_truncate(
+			total_non_colonial_population,
+			desired_administrator_percentage.get_untracked()
 		);
+		const pop_sum_t effective_administrators = fixed_point_t::multiply_truncate(
+			administrators,
+			fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency())
+		);
+		const fixed_point_t administrative_efficiency_from_administrators_unclamped = 
+			desired_administrators == 0
+			? fixed_point_t::_1
+			: std::min(
+				fixed_point_t::from_fraction(effective_administrators, desired_administrators)
+					* (fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency_modifier())),
+				fixed_point_t::_1
+			);
 
 		administrative_efficiency_from_administrators.set(
 			game_rules_manager.get_prevent_negative_administration_efficiency()
@@ -1388,36 +1394,42 @@ void CountryInstance::_update_budget() {
 		);
 	}
 
-	fixed_point_t projected_administration_spending_unscaled_by_slider_running_total = 0;
-	fixed_point_t projected_education_spending_unscaled_by_slider_running_total = 0;
-	fixed_point_t projected_military_spending_unscaled_by_slider_running_total = 0;
-	fixed_point_t projected_pensions_spending_unscaled_by_slider_running_total = 0;
-	fixed_point_t projected_unemployment_subsidies_spending_unscaled_by_slider_running_total = 0;
+	int64_t projected_administration_spending_unscaled_by_slider_running_total = 0;
+	int64_t projected_education_spending_unscaled_by_slider_running_total = 0;
+	int64_t projected_military_spending_unscaled_by_slider_running_total = 0;
+	int64_t projected_pensions_spending_unscaled_by_slider_running_total = 0;
+	int64_t projected_unemployment_subsidies_spending_unscaled_by_slider_running_total = 0;
 
-	for (auto const& [pop_type, size] : get_population_by_type()) {
-		projected_administration_spending_unscaled_by_slider_running_total += size * administration_salary_base_by_pop_type.at(pop_type).get_untracked();
-		projected_education_spending_unscaled_by_slider_running_total += size * education_salary_base_by_pop_type.at(pop_type).get_untracked();
-		projected_military_spending_unscaled_by_slider_running_total += size * military_salary_base_by_pop_type.at(pop_type).get_untracked();
-		projected_pensions_spending_unscaled_by_slider_running_total += size * calculate_pensions_base(pop_type);
+	for (auto const& [pop_type, pop_size] : get_population_by_type()) {
+		const int64_t size = type_safe::get(pop_size);
+		projected_administration_spending_unscaled_by_slider_running_total += size * administration_salary_base_by_pop_type.at(pop_type).get_untracked().get_raw_value();
+		projected_education_spending_unscaled_by_slider_running_total += size * education_salary_base_by_pop_type.at(pop_type).get_untracked().get_raw_value();
+		projected_military_spending_unscaled_by_slider_running_total += size * military_salary_base_by_pop_type.at(pop_type).get_untracked().get_raw_value();
+		projected_pensions_spending_unscaled_by_slider_running_total += size * calculate_pensions_base(pop_type).get_raw_value();
 		projected_unemployment_subsidies_spending_unscaled_by_slider_running_total += type_safe::get(get_unemployed_pops_by_type(pop_type))
-			* calculate_unemployment_subsidies_base(pop_type);
+			* calculate_unemployment_subsidies_base(pop_type).get_raw_value();
 	}
 
-	projected_administration_spending_unscaled_by_slider.set(
-		projected_administration_spending_unscaled_by_slider_running_total / Pop::size_denominator
-	);
-	projected_education_spending_unscaled_by_slider.set(
-		projected_education_spending_unscaled_by_slider_running_total / Pop::size_denominator
-	);
-	projected_military_spending_unscaled_by_slider.set(
-		projected_military_spending_unscaled_by_slider_running_total / Pop::size_denominator
-	);
-	projected_pensions_spending_unscaled_by_slider.set(
-		projected_pensions_spending_unscaled_by_slider_running_total / Pop::size_denominator
-	);
-	projected_unemployment_subsidies_spending_unscaled_by_slider.set(
-		projected_unemployment_subsidies_spending_unscaled_by_slider_running_total / Pop::size_denominator
-	);
+	projected_administration_spending_unscaled_by_slider.set(fixed_point_t::from_fraction(
+		projected_administration_spending_unscaled_by_slider_running_total,
+		type_safe::get(Pop::size_denominator)
+	));
+	projected_education_spending_unscaled_by_slider.set(fixed_point_t::from_fraction(
+		projected_education_spending_unscaled_by_slider_running_total,
+		type_safe::get(Pop::size_denominator)
+	));
+	projected_military_spending_unscaled_by_slider.set(fixed_point_t::from_fraction(
+		projected_military_spending_unscaled_by_slider_running_total,
+		type_safe::get(Pop::size_denominator)
+	));
+	projected_pensions_spending_unscaled_by_slider.set(fixed_point_t::from_fraction(
+		projected_pensions_spending_unscaled_by_slider_running_total,
+		type_safe::get(Pop::size_denominator)
+	));
+	projected_unemployment_subsidies_spending_unscaled_by_slider.set(fixed_point_t::from_fraction(
+		projected_unemployment_subsidies_spending_unscaled_by_slider_running_total,
+		type_safe::get(Pop::size_denominator)
+	));
 }
 
 fixed_point_t CountryInstance::calculate_pensions_base(PopType const& pop_type) {
@@ -1499,9 +1511,18 @@ void CountryInstance::_update_population() {
 
 	for (auto const& [pop_type, pop_size] : get_population_by_type()) {
 		if (pop_type.research_leadership_optimum > 0 && pop_size > 0) {
-			const fixed_point_t factor = std::min(
-				pop_size / (get_total_population() * pop_type.research_leadership_optimum), fixed_point_t::_1
+			const pop_sum_t optimum_size = fixed_point_t::multiply_truncate(
+				get_total_population(),
+				pop_type.research_leadership_optimum
 			);
+			const fixed_point_t factor = optimum_size == 0
+				? fixed_point_t::_1
+				: std::min(
+					fixed_point_t::from_fraction(
+						pop_size,
+						optimum_size
+					), fixed_point_t::_1
+				);
 
 			if (pop_type.research_points != 0) {
 				const fixed_point_t research_points = pop_type.research_points * factor;
@@ -1635,11 +1656,9 @@ void CountryInstance::_update_military() {
 	naval_unit_start_experience += get_modifier_effect_value(*modifier_effect_cache.get_naval_unit_start_experience());
 
 	recruit_time = fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_unit_recruitment_time());
-	combat_width = combat_width_t(
-		(
-			type_safe::get(military_defines.get_base_combat_width())
-			+ get_modifier_effect_value(*modifier_effect_cache.get_combat_width_additive())
-		).floor<type_safe::underlying_type<combat_width_t>>()
+	combat_width = fixed_point_t::multiply_truncate(
+		military_defines.get_base_combat_width(),
+		get_modifier_effect_value(*modifier_effect_cache.get_combat_width_additive())
 	);
 	dig_in_cap = get_modifier_effect_value(*modifier_effect_cache.get_dig_in_cap()).floor<int32_t>();
 	military_tactics = military_defines.get_base_military_tactics() +

src/openvic-simulation/economy/production/ArtisanalProducer.cpp

@@ -479,7 +479,7 @@ std::optional<fixed_point_t> ArtisanalProducer::estimate_production_type_score(
 fixed_point_t ArtisanalProducer::calculate_production_type_score(
 	const fixed_point_t revenue,
 	const fixed_point_t costs,
-	const pop_sum_t workforce
+	const pop_size_t workforce
 ) {
 	if (costs >= revenue) {
 		return 0;
@@ -494,7 +494,7 @@ fixed_point_t ArtisanalProducer::calculate_production_type_score(
 		k * fixed_point_t::mul_div(costs, costs, revenue)
 		-(1+k)*costs
 		+ revenue
-	) * Pop::size_denominator / workforce; //factor out pop size without making values too small
+	).mul_div(Pop::size_denominator, workforce); //factor out pop size without making values too small
 }
 
 ProductionType const* ArtisanalProducer::pick_production_type(

src/openvic-simulation/economy/production/ArtisanalProducer.hpp

@@ -23,7 +23,6 @@ namespace OpenVic {
 	struct ProvinceInstance;
 	struct RandomU32;
 	struct pop_size_t;
-	struct pop_sum_t;
 
 	struct ArtisanalProducer {
 	private:
@@ -49,7 +48,7 @@ namespace OpenVic {
 		static fixed_point_t calculate_production_type_score(
 			const fixed_point_t revenue,
 			const fixed_point_t costs,
-			const pop_sum_t workforce
+			const pop_size_t workforce
 		);
 
 	public:

src/openvic-simulation/economy/production/ProductionType.cpp

@@ -29,7 +29,7 @@ ProductionType::ProductionType(
 	const std::optional<Job> new_owner,
 	memory::vector<Job>&& new_jobs,
 	const template_type_t new_template_type,
-	const pop_sum_t new_base_workforce_size,
+	const pop_size_t new_base_workforce_size,
 	fixed_point_map_t<GoodDefinition const*>&& new_input_goods,
 	GoodDefinition const& new_output_good,
 	const fixed_point_t new_base_output_quantity,
@@ -140,7 +140,7 @@ bool ProductionTypeManager::add_production_type(
 	std::optional<Job> owner,
 	memory::vector<Job>&& jobs,
 	const ProductionType::template_type_t template_type,
-	const pop_sum_t base_workforce_size,
+	const pop_size_t base_workforce_size,
 	fixed_point_map_t<GoodDefinition const*>&& input_goods,
 	GoodDefinition const* const output_good,
 	const fixed_point_t base_output_quantity,
@@ -328,7 +328,7 @@ bool ProductionTypeManager::load_production_types_file(
 			memory::vector<Job> jobs;
 			ProductionType::template_type_t template_type { FACTORY };
 			GoodDefinition const* output_good = nullptr;
-			pop_sum_t base_workforce_size = 0;
+			pop_size_t base_workforce_size = 0;
 			fixed_point_map_t<GoodDefinition const*> input_goods, maintenance_requirements;
 			fixed_point_t base_output_quantity = 0;
 			memory::vector<ProductionType::bonus_t> bonuses;

src/openvic-simulation/economy/production/ProductionType.hpp

@@ -6,7 +6,7 @@
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/population/PopSum.hpp"
+#include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/types/PopSprite.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 
@@ -65,7 +65,7 @@ namespace OpenVic {
 	public:
 		GoodDefinition const& output_good;
 		const template_type_t template_type;
-		const pop_sum_t base_workforce_size;
+		const pop_size_t base_workforce_size;
 		const fixed_point_t base_output_quantity;
 
 		ProductionType(
@@ -74,7 +74,7 @@ namespace OpenVic {
 			const std::optional<Job> new_owner,
 			memory::vector<Job>&& new_jobs,
 			const template_type_t new_template_type,
-			const pop_sum_t new_base_workforce_size,
+			const pop_size_t new_base_workforce_size,
 			fixed_point_map_t<GoodDefinition const*>&& new_input_goods,
 			GoodDefinition const& new_output_good,
 			const fixed_point_t new_base_output_quantity,
@@ -123,7 +123,7 @@ namespace OpenVic {
 			std::optional<Job> owner,
 			memory::vector<Job>&& jobs,
 			const ProductionType::template_type_t template_type,
-			const pop_sum_t base_workforce_size,
+			const pop_size_t base_workforce_size,
 			fixed_point_map_t<GoodDefinition const*>&& input_goods,
 			GoodDefinition const* const output_good,
 			const fixed_point_t base_output_quantity,

src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp

@@ -44,7 +44,7 @@ ResourceGatheringOperation::ResourceGatheringOperation(
 	0, {}
 } {}
 
-pop_sum_t ResourceGatheringOperation::get_employee_count_per_type_cache(PopType const& key) const {
+pop_size_t ResourceGatheringOperation::get_employee_count_per_type_cache(PopType const& key) const {
 	return employee_count_per_type_cache.at(key);
 }
 
@@ -73,11 +73,19 @@ void ResourceGatheringOperation::initialise_rgo_size_multiplier() {
 	}
 
 	const fixed_point_t size_modifier = calculate_size_modifier();
-	const fixed_point_t base_workforce_size = type_safe::get(production_type.base_workforce_size);
+	const pop_size_t base_workforce_size = production_type.base_workforce_size;
 	if (size_modifier == 0) {
 		size_multiplier = 0;
 	} else {
-		size_multiplier = ((total_worker_count_in_province / (size_modifier * base_workforce_size)).ceil() * fixed_point_t::_1_50).floor();
+		size_multiplier = (
+			(
+				fixed_point_t::from_fraction<pop_sum_t>(
+					total_worker_count_in_province,
+					base_workforce_size
+				) / size_modifier
+			).ceil()
+			* fixed_point_t::_1_50
+		).floor();
 	}
 
 	max_employee_count_cache = (size_modifier * size_multiplier * base_workforce_size).floor<type_safe::underlying_type<pop_size_t>>();
@@ -189,8 +197,7 @@ void ResourceGatheringOperation::hire() {
 		proportion_to_hire = 1;
 	} else {
 		//hire all pops proportionally
-		const fixed_point_t max_worker_count_real = type_safe::get(max_employee_count_cache), available_worker_count_real = type_safe::get(available_worker_count);
-		proportion_to_hire = max_worker_count_real / available_worker_count_real;
+		proportion_to_hire = fixed_point_t::from_fraction<pop_sum_t>(max_employee_count_cache, available_worker_count);
 	}
 
 	std::span<const Job> jobs = production_type.get_jobs();
@@ -248,10 +255,16 @@ fixed_point_t ResourceGatheringOperation::produce() {
 		if (total_owner_count_in_state_cache > 0) {
 			switch (owner_job.get_effect_type()) {
 				case Job::effect_t::OUTPUT:
-					output_multiplier += owner_job.get_effect_multiplier() * total_owner_count_in_state_cache / state_population;
+					output_multiplier += owner_job.get_effect_multiplier().mul_div(
+						total_owner_count_in_state_cache,
+						state_population
+					);
 					break;
 				case Job::effect_t::THROUGHPUT:
-					throughput_multiplier += owner_job.get_effect_multiplier() * total_owner_count_in_state_cache / state_population;
+					throughput_multiplier += owner_job.get_effect_multiplier().mul_div(
+						total_owner_count_in_state_cache,
+						state_population
+					);
 					break;
 				default:
 					spdlog::error_s("Invalid job effect in RGO {}", production_type);
@@ -307,18 +320,18 @@ fixed_point_t ResourceGatheringOperation::produce() {
 			}
 
 			const fixed_point_t effect_multiplier = job.get_effect_multiplier();
-			fixed_point_t relative_to_workforce =
-				fixed_point_t(employees_of_type) / fixed_point_t(max_employee_count_cache);
 			const fixed_point_t amount = job.get_amount();
-			if (effect_multiplier != fixed_point_t::_1 && relative_to_workforce > amount) {
-				relative_to_workforce = amount;
-			}
+			const fixed_point_t effect = effect_multiplier != fixed_point_t::_1
+				&& fixed_point_t::from_fraction(employees_of_type, max_employee_count_cache) > amount
+				? effect_multiplier * amount //special Vic2 logic
+				: effect_multiplier.mul_div(employees_of_type, max_employee_count_cache);
+
 			switch (job.get_effect_type()) {
 				case Job::effect_t::OUTPUT:
-					output_from_workers += effect_multiplier * relative_to_workforce;
+					output_from_workers += effect;
 					break;
 				case Job::effect_t::THROUGHPUT:
-					throughput_from_workers += effect_multiplier * relative_to_workforce;
+					throughput_from_workers += effect;
 					break;
 				default:
 					spdlog::error_s("Invalid job effect in RGO {}", production_type);
@@ -382,14 +395,14 @@ void ResourceGatheringOperation::pay_employees(memory::vector<fixed_point_t>& re
 				fixed_point_t::_1 - total_minimum_wage / revenue_left
 			);
 			const fixed_point_t owner_share = std::min(
-				fixed_point_t::_2 * total_owner_count_in_state_cache / total_worker_count_in_province_cache,
+				fixed_point_t::from_fraction(2 * total_owner_count_in_state_cache, total_worker_count_in_province_cache),
 				upper_limit
 			);
 
 			for (Pop* owner_pop_ptr : *owner_pops_cache_nullable) {
 				Pop& owner_pop = *owner_pop_ptr;
 				const fixed_point_t income_for_this_pop = std::max(
-					revenue_left * (owner_share * owner_pop.get_size()) / total_owner_count_in_state_cache,
+					revenue_left * owner_share.mul_div<pop_sum_t>(owner_pop.get_size(), total_owner_count_in_state_cache),
 					fixed_point_t::epsilon //revenue > 0 is already checked, so rounding up
 				);
 				owner_pop.add_rgo_owner_income(income_for_this_pop);
@@ -405,7 +418,7 @@ void ResourceGatheringOperation::pay_employees(memory::vector<fixed_point_t>& re
 			memory::vector<fixed_point_t>& incomes = reusable_vector;
 			incomes.resize(employees.size());
 
-			pop_sum_t count_workers_to_be_paid = total_paid_employees_count_cache;
+			pop_size_t count_workers_to_be_paid = total_paid_employees_count_cache;
 			for (size_t i = 0; i < employees.size(); i++) {
 				Employee& employee = employees[i];
 				Pop& employee_pop = employee.get_pop();
@@ -427,7 +440,7 @@ void ResourceGatheringOperation::pay_employees(memory::vector<fixed_point_t>& re
 
 				const pop_size_t employee_size = employee.get_size();
 				const fixed_point_t income_for_this_pop = std::max(
-					revenue_left * employee_size / count_workers_to_be_paid,
+					revenue_left.mul_div(employee_size, count_workers_to_be_paid),
 					fixed_point_t::epsilon //revenue > 0 is already checked, so rounding up
 				);