Implement rgo for new gameprepare_for_rgo

Map province history rgo to production type for province instance

output_goods back to ZERO_OR_ONE

Link trade_goods in history to RGO instance for province.

Other producer types as structs instead of classes

Convert pops to equivalents & calculate rgo size

Also convert pops when changing rgo

Clean up

Refactored RGO into part of ProvinceInstance

ProductionType const& output_good

Remove unused imports

Clean up unused imports

Restore constructor for ResourceGatheringOperation to initialise from savegame

Move rgo size calculation to rgo

Use terrain modifiers to calculate rgo size (placeholder code)

Clean up

Basic production & sales for rgo when initialising new game

Use mutable pops

Paychecks for owners, workers and slaves

Clean up

Simplify rgo instantiation

Co-authored-by: Hop311 <Hop3114@gmail.com>

Simplify good_to_rgo_production_type assignment

Co-authored-by: Hop311 <Hop3114@gmail.com>

Fix import

Co-authored-by: Hop311 <Hop3114@gmail.com>

min(3, great_powers.size())

Co-authored-by: Hop311 <Hop3114@gmail.com>

Fix import

Co-authored-by: Hop311 <Hop3114@gmail.com>

Apply comments

Log errors and return result when applying history

Cleanup

28 files changed, 712 insertions, 143 deletions

diff --git a/src/headless/main.cpp b/src/headless/main.cpp
index 21e9f7c..a50b4ba 100644
--- a/src/headless/main.cpp
+++ b/src/headless/main.cpp
@@ -1,7 +1,10 @@
-#include <cstring>
-
+#include <openvic-simulation/country/CountryInstance.hpp>
 #include <openvic-simulation/dataloader/Dataloader.hpp>
+#include <openvic-simulation/economy/GoodDefinition.hpp>
+#include <openvic-simulation/economy/production/ProductionType.hpp>
+#include <openvic-simulation/economy/production/ResourceGatheringOperation.hpp>
 #include <openvic-simulation/GameManager.hpp>
+#include <openvic-simulation/pop/Pop.hpp>
 #include <openvic-simulation/testing/Testing.hpp>
 #include <openvic-simulation/utility/Logger.hpp>
 
@@ -18,6 +21,40 @@ static void print_help(std::ostream& stream, char const* program_name) {
 		<< "(Paths with spaces need to be enclosed in \"quotes\").\n";
 }
 
+static void print_rgo(ProvinceInstance const& province) {
+	ResourceGatheringOperation const& rgo = province.get_rgo();
+	ProductionType const* const production_type_nullable = rgo.get_production_type_nullable();
+	if (production_type_nullable == nullptr) {
+		Logger::error(
+			"\n    ", province.get_identifier(),
+			" - production_type: nullptr"
+		);
+	} else {
+		ProductionType const& production_type = *production_type_nullable;
+		GoodDefinition const& output_good = production_type.get_output_good();
+		std::string text = StringUtils::append_string_views(
+			"\n\t", province.get_identifier(),
+			" - good: ", output_good.get_identifier(),
+			", production_type: ", production_type.get_identifier(),
+			", size_multiplier: ", rgo.get_size_multiplier().to_string(3),
+			", output_quantity_yesterday: ", rgo.get_output_quantity_yesterday().to_string(3),
+			", revenue_yesterday: ", rgo.get_revenue_yesterday().to_string(3),
+			", total owner income: ", rgo.get_total_owner_income_cache().to_string(3),
+			", total employee income: ", rgo.get_total_employee_income_cache().to_string(3),
+			"\n\temployees:"
+		);
+
+		auto const& employee_count_per_type_cache=rgo.get_employee_count_per_type_cache();
+		for (PopType const& pop_type : *employee_count_per_type_cache.get_keys()) {
+			const Pop::pop_size_t employees_of_type = employee_count_per_type_cache[pop_type];
+			if (employees_of_type > 0) {
+				text += StringUtils::append_string_views("\n\t\t", std::to_string(employees_of_type), " ", pop_type.get_identifier());
+			}
+		}
+		Logger::info("", text);
+	}
+}
+
 static bool run_headless(Dataloader::path_vector_t const& roots, bool run_tests) {
 	bool ret = true;
 
@@ -72,9 +109,21 @@ static bool run_headless(Dataloader::path_vector_t const& roots, bool run_tests)
 		CountryInstanceManager const& country_instance_manager =
 			game_manager.get_instance_manager()->get_country_instance_manager();
 
-		print_ranking_list("Great Powers", country_instance_manager.get_great_powers());
+		std::vector<CountryInstance*> const& great_powers = country_instance_manager.get_great_powers();
+		print_ranking_list("Great Powers", great_powers);
 		print_ranking_list("Secondary Powers", country_instance_manager.get_secondary_powers());
 		print_ranking_list("All countries", country_instance_manager.get_total_ranking());
+
+		Logger::info("===== RGO test... =====");
+		for (size_t i = 0; i < std::min<size_t>(3, great_powers.size()); ++i) {
+			CountryInstance const& great_power = *great_powers[i];
+			ProvinceInstance const* const capital_province = great_power.get_capital();
+			if (capital_province == nullptr) {
+				Logger::warning(great_power.get_identifier(), " has no capital ProvinceInstance set.");
+			} else {
+				print_rgo(*capital_province);
+			}
+		}
 	} else {
 		Logger::error("Instance manager not available!");
 		ret = false;
diff --git a/src/openvic-simulation/InstanceManager.cpp b/src/openvic-simulation/InstanceManager.cpp
index eaa0692..670cbfc 100644
--- a/src/openvic-simulation/InstanceManager.cpp
+++ b/src/openvic-simulation/InstanceManager.cpp
@@ -38,32 +38,7 @@ void InstanceManager::update_gamestate() {
 	currently_updating_gamestate = true;
 
 	Logger::info("Update: ", today);
-
-	if constexpr (ProvinceInstance::ADD_OWNER_CONTRIBUTION) {
-		// Calculate local province modifier sums first, then national country modifier sums, then loop over owned provinces
-		// adding their contributions to the owner country's modifier sum and loop over them again to add the country's total
-		// (including province contributions) to the provinces' modifier sum. This results in every country and province
-		// having a full copy of all the modifiers affecting them in their modifier sum.
-		map_instance.update_modifier_sums(
-			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
-		);
-		country_instance_manager.update_modifier_sums(
-			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
-		);
-	} else {
-		// Calculate national country modifier sums first, then local province modifier sums, adding province contributions
-		// to owner countries' modifier sums if each province has an owner. This results in every country having a full copy
-		// of all the modifiers affecting them in their modifier sum, but provinces only having their directly/locally applied
-		// modifiers in their modifier sum, hence requiring both province and owner country modifier effect values to be looked
-		// up and added together to get the full effect on the province.
-		country_instance_manager.update_modifier_sums(
-			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
-		);
-		map_instance.update_modifier_sums(
-			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
-		);
-	}
-
+	update_modifier_sums();
 	// Update gamestate...
 	map_instance.update_gamestate(today, definition_manager.get_define_manager());
 	country_instance_manager.update_gamestate(
@@ -163,6 +138,11 @@ bool InstanceManager::load_bookmark(Bookmark const* new_bookmark) {
 		map_instance, definition_manager.get_pop_manager().get_pop_types()
 	);
 
+	if (ret) {
+		update_modifier_sums();
+		map_instance.initialise_for_new_game(definition_manager.get_modifier_manager().get_modifier_effect_cache());
+	}
+
 	return ret;
 }
 
@@ -204,3 +184,30 @@ bool InstanceManager::expand_selected_province_building(size_t building_index) {
 	}
 	return province->expand_building(building_index);
 }
+
+void InstanceManager::update_modifier_sums() {
+	if constexpr (ProvinceInstance::ADD_OWNER_CONTRIBUTION) {
+		// Calculate local province modifier sums first, then national country modifier sums, then loop over owned provinces
+		// adding their contributions to the owner country's modifier sum and loop over them again to add the country's total
+		// (including province contributions) to the provinces' modifier sum. This results in every country and province
+		// having a full copy of all the modifiers affecting them in their modifier sum.
+		map_instance.update_modifier_sums(
+			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
+		);
+		country_instance_manager.update_modifier_sums(
+			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
+		);
+	} else {
+		// Calculate national country modifier sums first, then local province modifier sums, adding province contributions
+		// to owner countries' modifier sums if each province has an owner. This results in every country having a full copy
+		// of all the modifiers affecting them in their modifier sum, but provinces only having their directly/locally applied
+		// modifiers in their modifier sum, hence requiring both province and owner country modifier effect values to be looked
+		// up and added together to get the full effect on the province.
+		country_instance_manager.update_modifier_sums(
+			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
+		);
+		map_instance.update_modifier_sums(
+			today, definition_manager.get_modifier_manager().get_static_modifier_cache()
+		);
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/InstanceManager.hpp b/src/openvic-simulation/InstanceManager.hpp
index cfb5447..05ae412 100644
--- a/src/openvic-simulation/InstanceManager.hpp
+++ b/src/openvic-simulation/InstanceManager.hpp
@@ -33,6 +33,7 @@ namespace OpenVic {
 		bool PROPERTY_CUSTOM_PREFIX(game_instance_setup, is);
 		bool PROPERTY_CUSTOM_PREFIX(game_session_started, is);
 
+		void update_modifier_sums();
 	public:
 		inline constexpr bool is_bookmark_loaded() const {
 			return bookmark != nullptr;
diff --git a/src/openvic-simulation/country/CountryInstance.hpp b/src/openvic-simulation/country/CountryInstance.hpp
index ea30c0d..6e01649 100644
--- a/src/openvic-simulation/country/CountryInstance.hpp
+++ b/src/openvic-simulation/country/CountryInstance.hpp
@@ -139,7 +139,7 @@ namespace OpenVic {
 		// TODO - population change over last 30 days
 		fixed_point_t PROPERTY(national_consciousness);
 		fixed_point_t PROPERTY(national_militancy);
-		IndexedMap<PopType, fixed_point_t> PROPERTY(pop_type_distribution);
+		IndexedMap<PopType, Pop::pop_size_t> PROPERTY(pop_type_distribution);
 		size_t PROPERTY(national_focus_capacity)
 		// TODO - national foci
 
diff --git a/src/openvic-simulation/dataloader/Vic2PathSearch.cpp b/src/openvic-simulation/dataloader/Vic2PathSearch.cpp
index a23d0ce..a1a125d 100644
--- a/src/openvic-simulation/dataloader/Vic2PathSearch.cpp
+++ b/src/openvic-simulation/dataloader/Vic2PathSearch.cpp
@@ -206,7 +206,7 @@ static fs::path _search_for_game_path(fs::path hint_path = {}) {
 			}
 			return empty_fail_result_callback("Could not parse VDF at '", current_path, "'.");
 		}
-		std::optional current_node = *(parser.get_key_values());
+		std::optional current_node = *parser.get_key_values();
 
 		// check "libraryfolders" list
 		auto it = current_node.value().find("libraryfolders");
diff --git a/src/openvic-simulation/economy/GoodDefinition.cpp b/src/openvic-simulation/economy/GoodDefinition.cpp
index 7ad5a87..ba5aff8 100644
--- a/src/openvic-simulation/economy/GoodDefinition.cpp
+++ b/src/openvic-simulation/economy/GoodDefinition.cpp
@@ -13,18 +13,18 @@ GoodDefinition::GoodDefinition(
 	index_t new_index,
 	GoodCategory const& new_category,
 	fixed_point_t new_base_price,
-	bool new_available_from_start,
-	bool new_tradeable,
-	bool new_money,
-	bool new_overseas_penalty
+	bool new_is_available_from_start,
+	bool new_is_tradeable,
+	bool new_is_money,
+	bool new_counters_overseas_penalty
 ) : HasIdentifierAndColour { new_identifier, new_colour, false },
 	HasIndex { new_index },
 	category { new_category },
 	base_price { new_base_price },
-	available_from_start { new_available_from_start },
-	tradeable { new_tradeable },
-	money { new_money },
-	overseas_penalty { new_overseas_penalty } {}
+	is_available_from_start { new_is_available_from_start },
+	is_tradeable { new_is_tradeable },
+	is_money { new_is_money },
+	counters_overseas_penalty { new_counters_overseas_penalty } {}
 
 bool GoodDefinitionManager::add_good_category(std::string_view identifier) {
 	if (identifier.empty()) {
@@ -36,7 +36,7 @@ bool GoodDefinitionManager::add_good_category(std::string_view identifier) {
 
 bool GoodDefinitionManager::add_good_definition(
 	std::string_view identifier, colour_t colour, GoodCategory const& category, fixed_point_t base_price,
-	bool available_from_start, bool tradeable, bool money, bool overseas_penalty
+	bool is_available_from_start, bool is_tradeable, bool is_money, bool has_overseas_penalty
 ) {
 	if (identifier.empty()) {
 		Logger::error("Invalid good identifier - empty!");
@@ -47,8 +47,8 @@ bool GoodDefinitionManager::add_good_definition(
 		return false;
 	}
 	return good_definitions.add_item({
-		identifier, colour, get_good_definition_count(), category, base_price, available_from_start,
-		tradeable, money, overseas_penalty
+		identifier, colour, get_good_definition_count(), category, base_price, is_available_from_start,
+		is_tradeable, is_money, has_overseas_penalty
 	});
 }
 
@@ -68,19 +68,19 @@ bool GoodDefinitionManager::load_goods_file(ast::NodeCPtr root) {
 		return expect_dictionary([this, &good_category](std::string_view key, ast::NodeCPtr value) -> bool {
 			colour_t colour = colour_t::null();
 			fixed_point_t base_price;
-			bool available_from_start = true, tradeable = true;
-			bool money = false, overseas_penalty = false;
+			bool is_available_from_start = true, is_tradeable = true;
+			bool is_money = false, has_overseas_penalty = false;
 
 			bool ret = expect_dictionary_keys(
 				"color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)),
 				"cost", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(base_price)),
-				"available_from_start", ZERO_OR_ONE, expect_bool(assign_variable_callback(available_from_start)),
-				"tradeable", ZERO_OR_ONE, expect_bool(assign_variable_callback(tradeable)),
-				"money", ZERO_OR_ONE, expect_bool(assign_variable_callback(money)),
-				"overseas_penalty", ZERO_OR_ONE, expect_bool(assign_variable_callback(overseas_penalty))
+				"available_from_start", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_available_from_start)),
+				"tradeable", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_tradeable)),
+				"money", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_money)),
+				"overseas_penalty", ZERO_OR_ONE, expect_bool(assign_variable_callback(has_overseas_penalty))
 			)(value);
 			ret &= add_good_definition(
-				key, colour, good_category, base_price, available_from_start, tradeable, money, overseas_penalty
+				key, colour, good_category, base_price, is_available_from_start, is_tradeable, is_money, has_overseas_penalty
 			);
 			return ret;
 		})(good_category_value);
diff --git a/src/openvic-simulation/economy/GoodDefinition.hpp b/src/openvic-simulation/economy/GoodDefinition.hpp
index 823c1a3..7cb87cc 100644
--- a/src/openvic-simulation/economy/GoodDefinition.hpp
+++ b/src/openvic-simulation/economy/GoodDefinition.hpp
@@ -35,15 +35,15 @@ namespace OpenVic {
 	private:
 		GoodCategory const& PROPERTY(category);
 		const fixed_point_t PROPERTY(base_price);
-		const bool PROPERTY_CUSTOM_PREFIX(available_from_start, is);
-		const bool PROPERTY_CUSTOM_PREFIX(tradeable, is);
-		const bool PROPERTY(money);
-		const bool PROPERTY(overseas_penalty);
+		const bool PROPERTY(is_available_from_start);
+		const bool PROPERTY(is_tradeable);
+		const bool PROPERTY(is_money);
+		const bool PROPERTY(counters_overseas_penalty);
 
 		GoodDefinition(
 			std::string_view new_identifier, colour_t new_colour, index_t new_index, GoodCategory const& new_category,
-			fixed_point_t new_base_price, bool new_available_from_start, bool new_tradeable, bool new_money,
-			bool new_overseas_penalty
+			fixed_point_t new_base_price, bool new_is_available_from_start, bool new_is_tradeable, bool new_is_money,
+			bool new_counters_overseas_penalty
 		);
 
 	public:
@@ -62,7 +62,7 @@ namespace OpenVic {
 
 		bool add_good_definition(
 			std::string_view identifier, colour_t colour, GoodCategory const& category, fixed_point_t base_price,
-			bool available_from_start, bool tradeable, bool money, bool overseas_penalty
+			bool is_available_from_start, bool is_tradeable, bool is_money, bool has_overseas_penalty
 		);
 
 		bool load_goods_file(ast::NodeCPtr root);
diff --git a/src/openvic-simulation/economy/GoodInstance.cpp b/src/openvic-simulation/economy/GoodInstance.cpp
index 6fe3a2f..ac081c9 100644
--- a/src/openvic-simulation/economy/GoodInstance.cpp
+++ b/src/openvic-simulation/economy/GoodInstance.cpp
@@ -4,7 +4,7 @@ using namespace OpenVic;
 
 GoodInstance::GoodInstance(GoodDefinition const& new_good_definition)
   : HasIdentifierAndColour { new_good_definition }, good_definition { new_good_definition },
-	price { new_good_definition.get_base_price() }, available { new_good_definition.is_available_from_start() } {}
+	price { new_good_definition.get_base_price() }, is_available { new_good_definition.get_is_available_from_start() } {}
 
 bool GoodInstanceManager::setup(GoodDefinitionManager const& good_definition_manager) {
 	if (good_instances_are_locked()) {
diff --git a/src/openvic-simulation/economy/GoodInstance.hpp b/src/openvic-simulation/economy/GoodInstance.hpp
index 20370ef..74ec939 100644
--- a/src/openvic-simulation/economy/GoodInstance.hpp
+++ b/src/openvic-simulation/economy/GoodInstance.hpp
@@ -14,7 +14,7 @@ namespace OpenVic {
 	private:
 		GoodDefinition const& PROPERTY(good_definition);
 		fixed_point_t PROPERTY(price);
-		bool PROPERTY(available);
+		bool PROPERTY(is_available);
 		// TODO - supply, demand, actual bought
 
 		GoodInstance(GoodDefinition const& new_good_definition);
diff --git a/src/openvic-simulation/economy/production/ArtisanalProducer.hpp b/src/openvic-simulation/economy/production/ArtisanalProducer.hpp
index e5c0b80..65aa3fa 100644
--- a/src/openvic-simulation/economy/production/ArtisanalProducer.hpp
+++ b/src/openvic-simulation/economy/production/ArtisanalProducer.hpp
@@ -6,7 +6,7 @@
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
-	class ArtisanalProducer final {
+	struct ArtisanalProducer {
 	private:
 		ProductionType const& PROPERTY(production_type);
 		GoodDefinition::good_definition_map_t PROPERTY(stockpile);
diff --git a/src/openvic-simulation/economy/production/Employee.cpp b/src/openvic-simulation/economy/production/Employee.cpp
new file mode 100644
index 0000000..569299a
--- /dev/null
+++ b/src/openvic-simulation/economy/production/Employee.cpp
@@ -0,0 +1,8 @@
+#include "Employee.hpp"
+
+using namespace OpenVic;
+
+Employee::Employee(Pop& new_pop, const Pop::pop_size_t new_size)
+	: pop { new_pop },
+	size { new_size }
+	{}
\ No newline at end of file
diff --git a/src/openvic-simulation/economy/production/Employee.hpp b/src/openvic-simulation/economy/production/Employee.hpp
new file mode 100644
index 0000000..8a09c31
--- /dev/null
+++ b/src/openvic-simulation/economy/production/Employee.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "openvic-simulation/pop/Pop.hpp"
+
+namespace OpenVic {
+	struct Employee {
+	private:
+		Pop::pop_size_t PROPERTY_RW(size);
+	public:
+		Pop& pop;
+		Employee(Pop& new_pop, const Pop::pop_size_t new_size);
+	};
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/economy/production/FactoryProducer.hpp b/src/openvic-simulation/economy/production/FactoryProducer.hpp
index 54ddfb8..9e660ba 100644
--- a/src/openvic-simulation/economy/production/FactoryProducer.hpp
+++ b/src/openvic-simulation/economy/production/FactoryProducer.hpp
@@ -8,7 +8,7 @@
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
-	class FactoryProducer final {
+	struct FactoryProducer {
 	private:
 		static constexpr uint8_t DAYS_OF_HISTORY = 7;
 		using daily_profit_history_t = std::array<fixed_point_t, DAYS_OF_HISTORY>;
diff --git a/src/openvic-simulation/economy/production/ProductionType.cpp b/src/openvic-simulation/economy/production/ProductionType.cpp
index 7c4dfef..c5db641 100644
--- a/src/openvic-simulation/economy/production/ProductionType.cpp
+++ b/src/openvic-simulation/economy/production/ProductionType.cpp
@@ -9,33 +9,33 @@ Job::Job(
 	PopType const* new_pop_type,
 	effect_t new_effect_type,
 	fixed_point_t new_effect_multiplier,
-	fixed_point_t new_desired_workforce_share
+	fixed_point_t new_amount
 ) : pop_type { new_pop_type },
 	effect_type { new_effect_type },
 	effect_multiplier { new_effect_multiplier },
-	desired_workforce_share { new_desired_workforce_share } {}
+	amount { new_amount } {}
 
 ProductionType::ProductionType(
-	std::string_view new_identifier,
-	std::optional<Job> new_owner,
+	const std::string_view new_identifier,
+	const std::optional<Job> new_owner,
 	std::vector<Job>&& new_jobs,
-	template_type_t new_template_type,
-	Pop::pop_size_t new_base_workforce_size,
+	const template_type_t new_template_type,
+	const Pop::pop_size_t new_base_workforce_size,
 	GoodDefinition::good_definition_map_t&& new_input_goods,
-	GoodDefinition const* new_output_goods,
-	fixed_point_t new_base_output_quantity,
+	GoodDefinition const& new_output_good,
+	const fixed_point_t new_base_output_quantity,
 	std::vector<bonus_t>&& new_bonuses,
 	GoodDefinition::good_definition_map_t&& new_maintenance_requirements,
-	bool new_is_coastal,
-	bool new_is_farm,
-	bool new_is_mine
+	const bool new_is_coastal,
+	const bool new_is_farm,
+	const bool new_is_mine
 ) : HasIdentifier { new_identifier },
 	owner { new_owner },
 	jobs { std::move(new_jobs) },
 	template_type { new_template_type },
 	base_workforce_size { new_base_workforce_size },
 	input_goods { std::move(new_input_goods) },
-	output_goods { new_output_goods },
+	output_good { new_output_good },
 	base_output_quantity { new_base_output_quantity },
 	bonuses { std::move(new_bonuses) },
 	maintenance_requirements { std::move(new_maintenance_requirements) },
@@ -51,7 +51,9 @@ bool ProductionType::parse_scripts(DefinitionManager const& definition_manager)
 	return ret;
 }
 
-ProductionTypeManager::ProductionTypeManager() : rgo_owner_sprite { 0 } {}
+ProductionTypeManager::ProductionTypeManager() :
+	good_to_rgo_production_type { nullptr },
+	rgo_owner_sprite { 0 } {}
 
 node_callback_t ProductionTypeManager::_expect_job(
 	GoodDefinitionManager const& good_definition_manager, PopManager const& pop_manager, callback_t<Job&&> callback
@@ -92,19 +94,19 @@ node_callback_t ProductionTypeManager::_expect_job_list(
 }
 
 bool ProductionTypeManager::add_production_type(
-	std::string_view identifier,
+	const std::string_view identifier,
 	std::optional<Job> owner,
 	std::vector<Job>&& jobs,
-	ProductionType::template_type_t template_type,
-	Pop::pop_size_t base_workforce_size,
+	const ProductionType::template_type_t template_type,
+	const Pop::pop_size_t base_workforce_size,
 	GoodDefinition::good_definition_map_t&& input_goods,
-	GoodDefinition const* output_goods,
-	fixed_point_t base_output_quantity,
+	GoodDefinition const* const output_good,
+	const fixed_point_t base_output_quantity,
 	std::vector<ProductionType::bonus_t>&& bonuses,
 	GoodDefinition::good_definition_map_t&& maintenance_requirements,
-	bool is_coastal,
-	bool is_farm,
-	bool is_mine
+	const bool is_coastal,
+	const bool is_farm,
+	const bool is_mine
 ) {
 	if (identifier.empty()) {
 		Logger::error("Invalid production type identifier - empty!");
@@ -121,7 +123,7 @@ bool ProductionTypeManager::add_production_type(
 		return false;
 	}
 
-	if (output_goods == nullptr) {
+	if (output_good == nullptr) {
 		Logger::error("Output good for production type ", identifier, " was null!");
 		return false;
 	}
@@ -167,13 +169,25 @@ bool ProductionTypeManager::add_production_type(
 	}
 
 	const bool ret = production_types.add_item({
-		identifier, owner, std::move(jobs), template_type, base_workforce_size, std::move(input_goods), output_goods,
+		identifier, owner, std::move(jobs), template_type, base_workforce_size, std::move(input_goods), *output_good,
 		base_output_quantity, std::move(bonuses), std::move(maintenance_requirements), is_coastal, is_farm, is_mine
 	});
+
+	if (ret && (template_type == RGO)) {
+		ProductionType const& production_type = production_types.get_items().back();
+		ProductionType const*& current_rgo_pt = good_to_rgo_production_type[*output_good];
+		if (current_rgo_pt == nullptr || (is_farm && !current_rgo_pt->is_farm())) {
+			// first rgo pt or farms are preferred (over mines) in V2
+			current_rgo_pt = &production_type;
+		}
+		//else ignore, we already have an rgo pt
+	}
+
 	if (rgo_owner_sprite <= 0 && ret && template_type == RGO && owner.has_value() && owner->get_pop_type() != nullptr) {
 		/* Set rgo owner sprite to that of the first RGO owner we find. */
 		rgo_owner_sprite = owner->get_pop_type()->get_sprite();
 	}
+
 	return ret;
 }
 
@@ -224,7 +238,10 @@ bool ProductionTypeManager::load_production_types_file(
 		}
 	)(parser.get_file_node());
 
+
 	/* Pass #3: actually load production types */
+	good_to_rgo_production_type.set_keys(&good_definition_manager.get_good_definitions());
+
 	reserve_more_production_types(expected_types);
 	ret &= expect_dictionary(
 		[this, &good_definition_manager, &pop_manager, &template_target_map, &template_node_map](
@@ -238,7 +255,7 @@ bool ProductionTypeManager::load_production_types_file(
 			std::optional<Job> owner;
 			std::vector<Job> jobs;
 			ProductionType::template_type_t template_type { FACTORY };
-			GoodDefinition const* output_goods = nullptr;
+			GoodDefinition const* output_good = nullptr;
 			Pop::pop_size_t base_workforce_size = 0;
 			GoodDefinition::good_definition_map_t input_goods, maintenance_requirements;
 			fixed_point_t base_output_quantity = 0;
@@ -271,7 +288,7 @@ bool ProductionTypeManager::load_production_types_file(
 				"input_goods", ZERO_OR_ONE,
 					good_definition_manager.expect_good_definition_decimal_map(move_variable_callback(input_goods)),
 				"output_goods", ZERO_OR_ONE,
-					good_definition_manager.expect_good_definition_identifier(assign_variable_callback_pointer(output_goods)),
+					good_definition_manager.expect_good_definition_identifier(assign_variable_callback_pointer(output_good)),
 				"value", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(base_output_quantity)),
 				"efficiency", ZERO_OR_ONE, good_definition_manager.expect_good_definition_decimal_map(
 					move_variable_callback(maintenance_requirements)
@@ -300,9 +317,10 @@ bool ProductionTypeManager::load_production_types_file(
 			ret &= parse_node(node);
 
 			ret &= add_production_type(
-				key, owner, std::move(jobs), template_type, base_workforce_size, std::move(input_goods), output_goods,
+				key, owner, std::move(jobs), template_type, base_workforce_size, std::move(input_goods), output_good,
 				base_output_quantity, std::move(bonuses), std::move(maintenance_requirements), is_coastal, is_farm, is_mine
 			);
+
 			return ret;
 		}
 	)(parser.get_file_node());
diff --git a/src/openvic-simulation/economy/production/ProductionType.hpp b/src/openvic-simulation/economy/production/ProductionType.hpp
index 5394938..f9b1778 100644
--- a/src/openvic-simulation/economy/production/ProductionType.hpp
+++ b/src/openvic-simulation/economy/production/ProductionType.hpp
@@ -20,13 +20,13 @@ namespace OpenVic {
 		PopType const* PROPERTY(pop_type);
 		effect_t PROPERTY(effect_type);
 		fixed_point_t PROPERTY(effect_multiplier);
-		fixed_point_t PROPERTY(desired_workforce_share);
+		fixed_point_t PROPERTY(amount);
 
 		Job(
 			PopType const* new_pop_type,
 			effect_t new_effect_type,
 			fixed_point_t new_effect_multiplier,
-			fixed_point_t new_desired_workforce_share
+			fixed_point_t new_amount
 		);
 
 	public:
@@ -47,7 +47,7 @@ namespace OpenVic {
 		const Pop::pop_size_t PROPERTY(base_workforce_size);
 
 		GoodDefinition::good_definition_map_t PROPERTY(input_goods);
-		GoodDefinition const* PROPERTY(output_goods);
+		GoodDefinition const& PROPERTY(output_good);
 		const fixed_point_t PROPERTY(base_output_quantity);
 		std::vector<bonus_t> PROPERTY(bonuses);
 
@@ -58,19 +58,19 @@ namespace OpenVic {
 		const bool PROPERTY_CUSTOM_PREFIX(mine, is);
 
 		ProductionType(
-			std::string_view new_identifier,
-			std::optional<Job> new_owner,
+			const std::string_view new_identifier,
+			const std::optional<Job> new_owner,
 			std::vector<Job>&& new_jobs,
-			template_type_t new_template_type,
-			Pop::pop_size_t new_base_workforce_size,
+			const template_type_t new_template_type,
+			const Pop::pop_size_t new_base_workforce_size,
 			GoodDefinition::good_definition_map_t&& new_input_goods,
-			GoodDefinition const* new_output_goods,
-			fixed_point_t new_base_output_quantity,
+			GoodDefinition const& new_output_good,
+			const fixed_point_t new_base_output_quantity,
 			std::vector<bonus_t>&& new_bonuses,
 			GoodDefinition::good_definition_map_t&& new_maintenance_requirements,
-			bool new_is_coastal,
-			bool new_is_farm,
-			bool new_is_mine
+			const bool new_is_coastal,
+			const bool new_is_farm,
+			const bool new_is_mine
 		);
 
 		bool parse_scripts(DefinitionManager const& definition_manager);
@@ -83,6 +83,7 @@ namespace OpenVic {
 	private:
 		IdentifierRegistry<ProductionType> IDENTIFIER_REGISTRY(production_type);
 		PopType::sprite_t PROPERTY(rgo_owner_sprite);
+		IndexedMap<GoodDefinition, ProductionType const*> PROPERTY(good_to_rgo_production_type);
 
 		NodeTools::node_callback_t _expect_job(
 			GoodDefinitionManager const& good_definition_manager, PopManager const& pop_manager,
@@ -97,19 +98,19 @@ namespace OpenVic {
 		ProductionTypeManager();
 
 		bool add_production_type(
-			std::string_view identifier,
+			const std::string_view identifier,
 			std::optional<Job> owner,
-			std::vector<Job>&& employees,
-			ProductionType::template_type_t template_type,
-			Pop::pop_size_t workforce,
+			std::vector<Job>&& jobs,
+			const ProductionType::template_type_t template_type,
+			const Pop::pop_size_t base_workforce_size,
 			GoodDefinition::good_definition_map_t&& input_goods,
-			GoodDefinition const* output_goods,
-			fixed_point_t value,
+			GoodDefinition const* const output_good,
+			const fixed_point_t base_output_quantity,
 			std::vector<ProductionType::bonus_t>&& bonuses,
 			GoodDefinition::good_definition_map_t&& maintenance_requirements,
-			bool coastal,
-			bool farm,
-			bool mine
+			const bool is_coastal,
+			const bool is_farm,
+			const bool is_mine
 		);
 
 		bool load_production_types_file(
diff --git a/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp b/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp
index 9bf6f49..df91645 100644
--- a/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp
+++ b/src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp
@@ -1,21 +1,343 @@
 #include "ResourceGatheringOperation.hpp"
 
+#include <vector>
+
+#include "openvic-simulation/economy/production/Employee.hpp"
+#include "openvic-simulation/economy/production/ProductionType.hpp"
+#include "openvic-simulation/map/ProvinceInstance.hpp"
+#include "openvic-simulation/map/State.hpp"
+#include "openvic-simulation/modifier/ModifierEffectCache.hpp"
+#include "openvic-simulation/pop/Pop.hpp"
+#include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
+
 using namespace OpenVic;
 
 ResourceGatheringOperation::ResourceGatheringOperation(
-	ProductionType const& new_production_type,
+	ProductionType const* new_production_type_nullable,
 	fixed_point_t new_size_multiplier,
 	fixed_point_t new_revenue_yesterday,
 	fixed_point_t new_output_quantity_yesterday,
 	fixed_point_t new_unsold_quantity_yesterday,
-	ordered_map<Pop*, Pop::pop_size_t>&& new_employees
-) : production_type { new_production_type },
+	std::vector<Employee>&& new_employees,
+	decltype(employee_count_per_type_cache)::keys_t const& pop_type_keys
+) : production_type_nullable { new_production_type_nullable },
 	revenue_yesterday { new_revenue_yesterday },
 	output_quantity_yesterday { new_output_quantity_yesterday },
 	unsold_quantity_yesterday { new_unsold_quantity_yesterday },
 	size_multiplier { new_size_multiplier },
-	employees { std::move(new_employees) } {}
+	employees { std::move(new_employees) },
+	max_employee_count_cache { 0 },
+	total_employees_count_cache { 0 },
+	total_paid_employees_count_cache { 0 },
+	total_owner_income_cache { },
+	total_employee_income_cache { },
+	employee_count_per_type_cache { &pop_type_keys }
+{ }
 
-ResourceGatheringOperation::ResourceGatheringOperation(
-	ProductionType const& new_production_type, fixed_point_t new_size_multiplier
-) : ResourceGatheringOperation { new_production_type, new_size_multiplier, 0, 0, 0, {} } {}
+ResourceGatheringOperation::ResourceGatheringOperation(decltype(employee_count_per_type_cache)::keys_t const& pop_type_keys) : ResourceGatheringOperation {
+	nullptr, fixed_point_t::_0(),
+	fixed_point_t::_0(), fixed_point_t::_0(),
+	fixed_point_t::_0(), {}, pop_type_keys
+} {}
+
+void ResourceGatheringOperation::initialise_for_new_game(ProvinceInstance& location, ModifierEffectCache const& modifier_effect_cache) {
+	if (production_type_nullable == nullptr) {
+		output_quantity_yesterday = 0;
+		revenue_yesterday = 0;
+		return;
+	}
+
+	ProductionType const& production_type = *production_type_nullable;
+	const fixed_point_t size_modifier = calculate_size_modifier(location, modifier_effect_cache);
+	const Pop::pop_size_t total_worker_count_in_province = update_size_and_return_total_worker_count(location, modifier_effect_cache, size_modifier);
+	hire(location, total_worker_count_in_province);
+	Pop::pop_size_t total_owner_count_in_state_cache = 0;
+	std::vector<Pop*> owner_pops_cache {};
+	output_quantity_yesterday = produce(location, owner_pops_cache, total_owner_count_in_state_cache, modifier_effect_cache, size_modifier);
+	revenue_yesterday = output_quantity_yesterday * production_type.get_output_good().get_base_price(); //TODO sell on market
+	pay_employees(location, revenue_yesterday, total_worker_count_in_province, owner_pops_cache, total_owner_count_in_state_cache);	
+}
+
+Pop::pop_size_t ResourceGatheringOperation::update_size_and_return_total_worker_count(
+	ProvinceInstance& location,
+	ModifierEffectCache const& modifier_effect_cache,
+	const fixed_point_t size_modifier
+) {
+	if (production_type_nullable == nullptr) {
+		size_multiplier = fixed_point_t::_0();
+		max_employee_count_cache = fixed_point_t::_0();
+		return fixed_point_t::_0();
+	}
+	
+	Pop::pop_size_t total_worker_count_in_province = 0; //not counting equivalents
+	ProductionType const& production_type = *production_type_nullable;
+	std::vector<Job> const& jobs = production_type.get_jobs();
+	//can't use pop_type_distribution as it is not filled correctly yet (possibly due to equivalent pop type conversion)
+	for (Pop const& pop : location.get_pops()){
+		PopType const* pop_type = pop.get_type();
+		for(Job const& job : jobs) {
+			if (job.get_pop_type() == pop_type) {
+				total_worker_count_in_province += pop.get_size();
+				break;
+			}
+		}
+	}
+
+	const fixed_point_t base_workforce_size = production_type.get_base_workforce_size();
+	if (size_modifier == fixed_point_t::_0()) {
+		size_multiplier = 0;
+	} else {
+		size_multiplier = ((total_worker_count_in_province / (size_modifier * base_workforce_size)).ceil() * fixed_point_t::_1_50()).floor();
+	}
+	max_employee_count_cache = (size_modifier * size_multiplier * base_workforce_size).floor();
+	return total_worker_count_in_province;
+}
+
+fixed_point_t ResourceGatheringOperation::calculate_size_modifier(ProvinceInstance const& location, ModifierEffectCache const& modifier_effect_cache) const {
+	if (production_type_nullable == nullptr) {
+		return fixed_point_t::_1();
+	}
+	
+	ProductionType const& production_type = *production_type_nullable;
+
+	fixed_point_t size_modifier = fixed_point_t::_1();
+	if (production_type.is_farm()) {
+		size_modifier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_farm_rgo_size_global())
+			+ location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_farm_rgo_size_local());
+	}
+	if (production_type.is_mine()) {
+		size_modifier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_mine_rgo_size_global())
+			+ location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_mine_rgo_size_local());
+	}
+	auto const& good_effects = modifier_effect_cache.get_good_effects()[production_type.get_output_good()];
+	size_modifier += location.get_modifier_effect_value_nullcheck(good_effects.get_rgo_size());
+	return size_modifier > fixed_point_t::_0() ? size_modifier : fixed_point_t::_0();
+}
+
+void ResourceGatheringOperation::hire(ProvinceInstance& location, Pop::pop_size_t available_worker_count) {
+	total_employees_count_cache = 0;
+	total_paid_employees_count_cache=0;
+	if (production_type_nullable == nullptr) {
+		employees.clear();
+		employee_count_per_type_cache.fill(fixed_point_t::_0());
+		return;
+	}
+
+	ProductionType const& production_type = *production_type_nullable;
+	if (max_employee_count_cache <= 0) { return; }
+	if (available_worker_count <= 0) { return; }
+
+	fixed_point_t proportion_to_hire;
+	if (max_employee_count_cache >= available_worker_count) {
+		//hire everyone
+		proportion_to_hire = fixed_point_t::_1();
+	} else {
+		//hire all pops proportionally
+		const fixed_point_t max_worker_count_real = max_employee_count_cache, available_worker_count_real = available_worker_count;
+		proportion_to_hire = max_worker_count_real / available_worker_count_real;
+	}
+	
+	std::vector<Job> const& jobs = production_type.get_jobs();
+	for (Pop& pop : location.get_mutable_pops()){
+		PopType const& pop_type = *pop.get_type();
+		for(Job const& job : jobs) {
+			if (job.get_pop_type() == &pop_type) {
+				const Pop::pop_size_t pop_size_to_hire = static_cast<Pop::pop_size_t>((proportion_to_hire * pop.get_size()).floor());
+				employee_count_per_type_cache[pop_type] += pop_size_to_hire;
+				employees.emplace_back(pop, pop_size_to_hire);
+				total_employees_count_cache += pop_size_to_hire;
+				if (!pop_type.get_is_slave()) {
+					total_paid_employees_count_cache += pop_size_to_hire;
+				}
+				break;
+			}
+		}
+	}
+}
+
+fixed_point_t ResourceGatheringOperation::produce(
+	ProvinceInstance& location,
+	std::vector<Pop*>& owner_pops_cache,
+	Pop::pop_size_t& total_owner_count_in_state_cache,
+	ModifierEffectCache const& modifier_effect_cache,
+	const fixed_point_t size_modifier
+) {
+	if (size_modifier == fixed_point_t::_0()){
+		return fixed_point_t::_0();
+	}
+
+	total_owner_count_in_state_cache = 0;
+	owner_pops_cache = {};
+	if (production_type_nullable == nullptr || max_employee_count_cache <= 0) {
+		return fixed_point_t::_0();
+	}
+	
+	ProductionType const& production_type = *production_type_nullable;
+	fixed_point_t throughput_multiplier = fixed_point_t::_1();
+	fixed_point_t output_multilpier = fixed_point_t::_1();
+
+	std::optional<Job> const& owner = production_type.get_owner();
+	if (owner.has_value()) {
+		Job const& owner_job = owner.value();
+		PopType const* owner_job_pop_type_nullable = owner_job.get_pop_type();
+		if (owner_job_pop_type_nullable == nullptr) {
+			Logger::error("Owner job for ", production_type.get_identifier(), " has nullptr as pop_type.");
+			return fixed_point_t::_0();
+		}
+		PopType const& owner_pop_type = *owner_job_pop_type_nullable;
+		State const* state_nullable = location.get_state();
+		if (state_nullable == nullptr) {
+			Logger::error("Province ", location.get_identifier(), " has no state.");
+			return fixed_point_t::_0();
+		}
+		State const& state = *state_nullable;
+		Pop::pop_size_t state_population = 0; //state.get_total_population() is not filled yet
+		std::vector<ProvinceInstance*> const& provinces_in_state = state.get_provinces();
+		for (ProvinceInstance* const province_nullable : provinces_in_state) {
+			if (province_nullable == nullptr) {
+				Logger::error("State ", state.get_identifier(), " has nullptr in provinces.");
+				return fixed_point_t::_0();
+			}
+			ProvinceInstance& province = *province_nullable;
+			for (Pop& pop : province.get_mutable_pops()){
+				state_population += pop.get_size();
+				if (&owner_pop_type == pop.get_type()) {
+					owner_pops_cache.push_back(&pop);
+					total_owner_count_in_state_cache += pop.get_size();
+				}
+			}
+		}
+
+		if (total_owner_count_in_state_cache > 0) {
+			switch (owner_job.get_effect_type()) {
+				case Job::effect_t::OUTPUT:
+					output_multilpier += owner_job.get_effect_multiplier() * 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;
+					break;
+				default:
+					Logger::error("Invalid job effect in RGO ",production_type.get_identifier());
+					break;
+			}
+		}
+	}
+
+	throughput_multiplier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_rgo_throughput())
+		+location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_local_rgo_throughput());
+	output_multilpier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_rgo_output())
+		+location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_local_rgo_output());
+
+	if (production_type.is_farm()) {
+		throughput_multiplier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_farm_rgo_throughput_global());
+		output_multilpier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_farm_rgo_output_global())
+			+ location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_farm_rgo_output_local());
+	}
+	if (production_type.is_mine()) {
+		throughput_multiplier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_mine_rgo_throughput_global());
+		output_multilpier += location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_mine_rgo_output_global())
+			+ location.get_modifier_effect_value_nullcheck(modifier_effect_cache.get_mine_rgo_output_local());
+	}
+	auto const& good_effects = modifier_effect_cache.get_good_effects()[production_type.get_output_good()];
+	throughput_multiplier += location.get_modifier_effect_value_nullcheck(good_effects.get_rgo_goods_throughput());
+	output_multilpier += location.get_modifier_effect_value_nullcheck(good_effects.get_rgo_goods_output());
+
+	fixed_point_t throughput_from_workers = fixed_point_t::_0();
+	fixed_point_t output_from_workers = fixed_point_t::_1();
+	for (PopType const& pop_type : *employee_count_per_type_cache.get_keys()) {
+		const Pop::pop_size_t employees_of_type = employee_count_per_type_cache[pop_type];
+		
+		for(Job const& job : production_type.get_jobs()) {
+			if (job.get_pop_type() != &pop_type) {
+				continue;
+			}
+
+			fixed_point_t const effect_multiplier = job.get_effect_multiplier();
+			fixed_point_t relative_to_workforce = fixed_point_t::parse(employees_of_type) / fixed_point_t::parse(max_employee_count_cache);
+			fixed_point_t const amount = job.get_amount();
+			if (effect_multiplier != fixed_point_t::_1() && relative_to_workforce > amount) {
+				relative_to_workforce = amount;
+			}
+			switch (job.get_effect_type()) {
+				case Job::effect_t::OUTPUT:
+					output_from_workers += effect_multiplier * relative_to_workforce;
+					break;
+				case Job::effect_t::THROUGHPUT:
+					throughput_from_workers += effect_multiplier * relative_to_workforce;
+					break;
+				default:
+					Logger::error("Invalid job effect in RGO ",production_type.get_identifier());
+					break;
+			}
+		}
+	}
+	
+	//if province is overseas multiply by (1 + overseas penalty)
+
+	return production_type.get_base_output_quantity()
+		* size_modifier * size_multiplier
+		* throughput_multiplier * throughput_from_workers
+		* output_multilpier * output_from_workers;
+}
+
+void ResourceGatheringOperation::pay_employees(
+	ProvinceInstance& location,
+	const fixed_point_t revenue,
+	const Pop::pop_size_t total_worker_count_in_province,
+	std::vector<Pop*>& owner_pops_cache,
+	const Pop::pop_size_t total_owner_count_in_state_cache
+) {
+	total_owner_income_cache = 0;
+	total_employee_income_cache = 0;
+	if (production_type_nullable == nullptr || revenue <= 0 || total_worker_count_in_province <= 0) {
+		if (revenue < 0) { Logger::error("Negative revenue for province ", location.get_identifier()); }
+		if (total_worker_count_in_province < 0) { Logger::error("Negative total worker count for province ", location.get_identifier()); }
+		return;
+	}
+	
+	ProductionType const& production_type = *production_type_nullable;
+
+	fixed_point_t revenue_left = revenue;
+	if (total_owner_count_in_state_cache > 0) {
+		Job const& owner_job = production_type.get_owner().value();
+		PopType const* owner_job_pop_type_nullable = owner_job.get_pop_type();
+		
+		fixed_point_t owner_share = (fixed_point_t::_2() * total_owner_count_in_state_cache / total_worker_count_in_province);
+		constexpr fixed_point_t upper_limit = fixed_point_t::_0_50();
+		if (owner_share > upper_limit) {
+			owner_share = upper_limit;
+		}
+
+		for(Pop* owner_pop_nullable : owner_pops_cache) {
+			Pop& owner_pop = *owner_pop_nullable;
+			const fixed_point_t income_for_this_pop = revenue_left * owner_share * owner_pop.get_size() / total_owner_count_in_state_cache;
+			owner_pop.add_rgo_owner_income(income_for_this_pop);
+			total_owner_income_cache += income_for_this_pop;
+		}
+		revenue_left *= (fixed_point_t::_1() - owner_share);
+	}
+
+	if (total_paid_employees_count_cache > 0) {
+		for (Employee& employee : employees) {
+			Pop& employee_pop = employee.pop;
+			PopType const* employee_pop_type_nullable = employee_pop.get_type();
+			if (employee_pop_type_nullable == nullptr) {
+				Logger::error("employee has nullptr pop_type.");
+				return;
+			}
+			PopType const& employee_pop_type = *employee_pop_type_nullable;
+			if (employee_pop_type.get_is_slave()) {
+				continue;
+			}
+
+			const Pop::pop_size_t employee_size = employee.get_size();
+			const fixed_point_t income_for_this_pop = revenue_left * employee_size / total_paid_employees_count_cache;
+			employee_pop.add_rgo_worker_income(income_for_this_pop);
+			total_employee_income_cache += income_for_this_pop;
+		}
+	} else {
+		//scenario slaves only
+		//Money is removed from system in Victoria 2.
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp b/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp
index d71c569..a15e87d 100644
--- a/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp
+++ b/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp
@@ -1,25 +1,64 @@
 #pragma once
 
+#include "openvic-simulation/economy/production/Employee.hpp"
 #include "openvic-simulation/economy/production/ProductionType.hpp"
+#include "openvic-simulation/modifier/ModifierEffectCache.hpp"
+#include "openvic-simulation/pop/Pop.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
-	class ResourceGatheringOperation final {
+	struct ResourceGatheringOperation {
 	private:
-		ProductionType const& PROPERTY(production_type);
+		ProductionType const* PROPERTY_RW(production_type_nullable);
 		fixed_point_t PROPERTY(revenue_yesterday);
 		fixed_point_t PROPERTY(output_quantity_yesterday);
 		fixed_point_t PROPERTY(unsold_quantity_yesterday);
-		fixed_point_t PROPERTY(size_multiplier);
-		ordered_map<Pop*, Pop::pop_size_t> PROPERTY(employees);
+		fixed_point_t PROPERTY_RW(size_multiplier);
+		std::vector<Employee> PROPERTY(employees);
+		Pop::pop_size_t PROPERTY(max_employee_count_cache);
+		Pop::pop_size_t PROPERTY(total_employees_count_cache);
+		Pop::pop_size_t PROPERTY(total_paid_employees_count_cache);
+		fixed_point_t PROPERTY(total_owner_income_cache);
+		fixed_point_t PROPERTY(total_employee_income_cache);
+		IndexedMap<PopType, Pop::pop_size_t> PROPERTY(employee_count_per_type_cache);
+
+		Pop::pop_size_t update_size_and_return_total_worker_count(
+			ProvinceInstance& location,
+			ModifierEffectCache const& modifier_effect_cache,
+			const fixed_point_t size_modifier
+		);
+		fixed_point_t calculate_size_modifier(ProvinceInstance const& location, ModifierEffectCache const& modifier_effect_cache) const;
+		void hire(ProvinceInstance& location, const Pop::pop_size_t available_worker_count);
+		fixed_point_t produce(
+			ProvinceInstance& location,
+			std::vector<Pop*>& owner_pops_cache,
+			Pop::pop_size_t& total_owner_count_in_state_cache,
+			ModifierEffectCache const& modifier_effect_cache,
+			const fixed_point_t size_modifier
+		);
+		void pay_employees(
+			ProvinceInstance& location,
+			const fixed_point_t revenue,
+			const Pop::pop_size_t total_worker_count_in_province,
+			std::vector<Pop*>& owner_pops_cache,
+			const Pop::pop_size_t total_owner_count_in_state_cache
+		);
 
 	public:
 		ResourceGatheringOperation(
-			ProductionType const& new_production_type, fixed_point_t new_size_multiplier, fixed_point_t new_revenue_yesterday,
-			fixed_point_t new_output_quantity_yesterday, fixed_point_t new_unsold_quantity_yesterday,
-			ordered_map<Pop*, Pop::pop_size_t>&& new_employees
+			ProductionType const* new_production_type_nullable,
+			fixed_point_t new_size_multiplier,
+			fixed_point_t new_revenue_yesterday,
+			fixed_point_t new_output_quantity_yesterday,
+			fixed_point_t new_unsold_quantity_yesterday,
+			std::vector<Employee>&& new_employees,
+			decltype(employee_count_per_type_cache)::keys_t const& pop_type_keys
 		);
-		ResourceGatheringOperation(ProductionType const& new_production_type, fixed_point_t new_size_multiplier);
+		ResourceGatheringOperation(decltype(employee_count_per_type_cache)::keys_t const& pop_type_keys);
+		constexpr bool is_valid() const {
+			return production_type_nullable != nullptr;
+		}
+		void initialise_for_new_game(ProvinceInstance& location, ModifierEffectCache const& modifier_effect_cache);
 	};
 }
diff --git a/src/openvic-simulation/history/ProvinceHistory.cpp b/src/openvic-simulation/history/ProvinceHistory.cpp
index 60fcbe4..bc92f48 100644
--- a/src/openvic-simulation/history/ProvinceHistory.cpp
+++ b/src/openvic-simulation/history/ProvinceHistory.cpp
@@ -1,7 +1,9 @@
 #include "ProvinceHistory.hpp"
 
 #include "openvic-simulation/DefinitionManager.hpp"
+#include "openvic-simulation/economy/GoodDefinition.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
@@ -57,6 +59,9 @@ bool ProvinceHistoryMap::_load_history_entry(
 		};
 	};
 
+	constexpr bool allow_empty_true = true;
+	constexpr bool do_warn = true;
+
 	return expect_dictionary_keys_and_default(
 		[this, &definition_manager, &building_type_manager, &entry](
 			std::string_view key, ast::NodeCPtr value) -> bool {
@@ -98,7 +103,20 @@ bool ProvinceHistoryMap::_load_history_entry(
 			expect_identifier(expect_mapped_string(colony_status_map, assign_variable_callback(entry.colonial))),
 		"is_slave", ZERO_OR_ONE, expect_bool(assign_variable_callback(entry.slave)),
 		"trade_goods", ZERO_OR_ONE,
-			good_definition_manager.expect_good_definition_identifier(assign_variable_callback_pointer_opt(entry.rgo)),
+			good_definition_manager.expect_good_definition_identifier_or_string(
+				[&definition_manager, &entry](GoodDefinition const& rgo_good) ->bool {
+					entry.rgo_production_type_nullable = definition_manager.get_economy_manager().get_production_type_manager().get_good_to_rgo_production_type()[rgo_good];
+					if (entry.rgo_production_type_nullable == nullptr) {
+						Logger::error(entry.province.get_identifier(), " has trade_goods ", rgo_good.get_identifier(), " which has no rgo production type defined.");
+						//we expect the good to have an rgo production type
+						//Victoria 2 treats this as null, but clearly the modder wanted there to be a good
+						return false;
+					}
+					return true;
+				},
+				allow_empty_true, //could be explicitly setting trade_goods to null
+				do_warn //could be typo in good identifier
+			),
 		"life_rating", ZERO_OR_ONE, expect_uint<ProvinceInstance::life_rating_t>(assign_variable_callback(entry.life_rating)),
 		"terrain", ZERO_OR_ONE, terrain_type_manager.expect_terrain_type_identifier(
 			assign_variable_callback_pointer_opt(entry.terrain_type)
diff --git a/src/openvic-simulation/history/ProvinceHistory.hpp b/src/openvic-simulation/history/ProvinceHistory.hpp
index 99ea2af..f44fc81 100644
--- a/src/openvic-simulation/history/ProvinceHistory.hpp
+++ b/src/openvic-simulation/history/ProvinceHistory.hpp
@@ -32,7 +32,7 @@ namespace OpenVic {
 		std::optional<ProvinceInstance::colony_status_t> PROPERTY(colonial);
 		std::optional<bool> PROPERTY(slave);
 		ordered_map<CountryDefinition const*, bool> PROPERTY(cores);
-		std::optional<GoodDefinition const*> PROPERTY(rgo);
+		std::optional<ProductionType const*> PROPERTY(rgo_production_type_nullable);
 		std::optional<ProvinceInstance::life_rating_t> PROPERTY(life_rating);
 		std::optional<TerrainType const*> PROPERTY(terrain_type);
 		ordered_map<BuildingType const*, BuildingType::level_t> PROPERTY(province_buildings);
diff --git a/src/openvic-simulation/map/MapInstance.cpp b/src/openvic-simulation/map/MapInstance.cpp
index 47ae40e..4a4a1e5 100644
--- a/src/openvic-simulation/map/MapInstance.cpp
+++ b/src/openvic-simulation/map/MapInstance.cpp
@@ -93,6 +93,7 @@ bool MapInstance::apply_history_to_provinces(
 
 			if (history_map != nullptr) {
 				ProvinceHistoryEntry const* pop_history_entry = nullptr;
+				ProductionType const* rgo_production_type_nullable = nullptr;
 
 				for (auto const& [entry_date, entry] : history_map->get_entries()) {
 					if(entry_date > date) {
@@ -101,6 +102,10 @@ bool MapInstance::apply_history_to_provinces(
 						}
 					} else {
 						province.apply_history_to_province(*entry, country_manager);
+						std::optional<ProductionType const*> const& rgo_production_type_nullable_optional = entry->get_rgo_production_type_nullable();
+						if (rgo_production_type_nullable_optional.has_value()) {
+							rgo_production_type_nullable = rgo_production_type_nullable_optional.value();
+						}
 					}
 
 					if (!entry->get_pops().empty()) {
@@ -114,6 +119,8 @@ bool MapInstance::apply_history_to_provinces(
 					province.add_pop_vec(pop_history_entry->get_pops());
 					province.setup_pop_test_values(issue_manager);
 				}
+
+				ret&=province.set_rgo_production_type_nullable(rgo_production_type_nullable);
 			}
 		}
 	}
@@ -153,3 +160,9 @@ void MapInstance::tick(Date today) {
 		province.tick(today);
 	}
 }
+
+void MapInstance::initialise_for_new_game(ModifierEffectCache const& modifier_effect_cache){
+	for (ProvinceInstance& province : province_instances.get_items()) {
+		province.initialise_for_new_game(modifier_effect_cache);
+	}
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/map/MapInstance.hpp b/src/openvic-simulation/map/MapInstance.hpp
index e7c623e..a580c55 100644
--- a/src/openvic-simulation/map/MapInstance.hpp
+++ b/src/openvic-simulation/map/MapInstance.hpp
@@ -55,5 +55,6 @@ namespace OpenVic {
 		void update_modifier_sums(Date today, StaticModifierCache const& static_modifier_cache);
 		void update_gamestate(Date today, DefineManager const& define_manager);
 		void tick(Date today);
+		void initialise_for_new_game(ModifierEffectCache const& modifier_effect_cache);
 	};
 }
diff --git a/src/openvic-simulation/map/Mapmode.cpp b/src/openvic-simulation/map/Mapmode.cpp
index f951a05..88eb2eb 100644
--- a/src/openvic-simulation/map/Mapmode.cpp
+++ b/src/openvic-simulation/map/Mapmode.cpp
@@ -179,7 +179,7 @@ bool MapmodeManager::setup_mapmodes() {
 			"mapmode_terrain_type", get_colour_mapmode(&ProvinceInstance::get_terrain_type)
 		},
 		{
-			"mapmode_rgo", get_colour_mapmode(&ProvinceInstance::get_rgo)
+			"mapmode_rgo", get_colour_mapmode(&ProvinceInstance::get_rgo_good)
 		},
 		{
 			"mapmode_infrastructure",
diff --git a/src/openvic-simulation/map/ProvinceInstance.cpp b/src/openvic-simulation/map/ProvinceInstance.cpp
index cbb23bd..64a104b 100644
--- a/src/openvic-simulation/map/ProvinceInstance.cpp
+++ b/src/openvic-simulation/map/ProvinceInstance.cpp
@@ -1,6 +1,8 @@
 #include "ProvinceInstance.hpp"
 
 #include "openvic-simulation/country/CountryInstance.hpp"
+#include "openvic-simulation/economy/production/ProductionType.hpp"
+#include "openvic-simulation/economy/production/ResourceGatheringOperation.hpp"
 #include "openvic-simulation/history/ProvinceHistory.hpp"
 #include "openvic-simulation/map/Crime.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
@@ -10,6 +12,8 @@
 #include "openvic-simulation/misc/Define.hpp"
 #include "openvic-simulation/modifier/StaticModifierCache.hpp"
 #include "openvic-simulation/politics/Ideology.hpp"
+#include "openvic-simulation/pop/Pop.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
 
@@ -29,7 +33,7 @@ ProvinceInstance::ProvinceInstance(
 	event_modifiers {},
 	slave { false },
 	crime { nullptr },
-	rgo { nullptr },
+	rgo { pop_type_keys },
 	buildings { "buildings", false },
 	armies {},
 	navies {},
@@ -41,6 +45,25 @@ ProvinceInstance::ProvinceInstance(
 	religion_distribution {},
 	max_supported_regiments { 0 } {}
 
+GoodDefinition const* ProvinceInstance::get_rgo_good() const {
+	if (!rgo.is_valid()) { return nullptr; }
+	return &(rgo.get_production_type_nullable()->get_output_good());
+}
+bool ProvinceInstance::set_rgo_production_type_nullable(ProductionType const* rgo_production_type_nullable) {
+	bool is_valid_operation = true;
+	if (rgo_production_type_nullable != nullptr) {
+		ProductionType const& rgo_production_type = *rgo_production_type_nullable;
+		if (rgo_production_type.get_template_type() != ProductionType::template_type_t::RGO) {
+			Logger::error("Tried setting province ", get_identifier(), " rgo to ", rgo_production_type.get_identifier(), " which is not of template_type RGO.");
+			is_valid_operation = false;
+		}
+		is_valid_operation&=convert_rgo_worker_pops_to_equivalent(rgo_production_type);
+	}
+	
+	rgo.set_production_type_nullable(rgo_production_type_nullable);
+	return is_valid_operation;
+}
+
 bool ProvinceInstance::set_owner(CountryInstance* new_owner) {
 	bool ret = true;
 
@@ -176,7 +199,7 @@ void ProvinceInstance::_update_pops(DefineManager const& define_manager) {
 		average_consciousness += pop.get_consciousness();
 		average_militancy += pop.get_militancy();
 
-		pop_type_distribution[pop.get_type()] += pop.get_size();
+		pop_type_distribution[*pop.get_type()] += pop.get_size();
 		ideology_distribution += pop.get_ideologies();
 		culture_distribution[&pop.get_culture()] += pop.get_size();
 		religion_distribution[&pop.get_religion()] += pop.get_size();
@@ -311,6 +334,24 @@ std::vector<ModifierSum::modifier_entry_t> ProvinceInstance::get_contributing_mo
 	}
 }
 
+bool ProvinceInstance::convert_rgo_worker_pops_to_equivalent(ProductionType const& production_type) {
+	bool is_valid_operation = true;
+	std::vector<Job> const& jobs = production_type.get_jobs();
+	for(Pop& pop : pops) {
+		for(Job const& job : jobs) {
+			PopType const* const job_pop_type = job.get_pop_type();
+			PopType const* old_pop_type = pop.get_type();
+			if (job_pop_type != old_pop_type) {
+				PopType const* const equivalent = old_pop_type->get_equivalent();
+				if (job_pop_type == equivalent) {
+					is_valid_operation&=pop.convert_to_equivalent();
+				}
+			}
+		}
+	}
+	return is_valid_operation;
+}
+
 void ProvinceInstance::update_gamestate(Date today, DefineManager const& define_manager) {
 	for (BuildingInstance& building : buildings.get_items()) {
 		building.update_gamestate(today);
@@ -405,7 +446,7 @@ bool ProvinceInstance::apply_history_to_province(ProvinceHistoryEntry const& ent
 			ret &= remove_core(country_manager.get_country_instance_from_definition(*country));
 		}
 	}
-	set_optional(rgo, entry.get_rgo());
+
 	set_optional(life_rating, entry.get_life_rating());
 	set_optional(terrain_type, entry.get_terrain_type());
 	for (auto const& [building, level] : entry.get_province_buildings()) {
@@ -425,8 +466,16 @@ bool ProvinceInstance::apply_history_to_province(ProvinceHistoryEntry const& ent
 	return ret;
 }
 
+void ProvinceInstance::initialise_for_new_game(ModifierEffectCache const& modifier_effect_cache) {
+	rgo.initialise_for_new_game(*this, modifier_effect_cache);
+}
+
 void ProvinceInstance::setup_pop_test_values(IssueManager const& issue_manager) {
 	for (Pop& pop : pops) {
 		pop.setup_pop_test_values(issue_manager);
 	}
 }
+
+plf::colony<Pop>& ProvinceInstance::get_mutable_pops() {
+	return pops;
+}
\ No newline at end of file
diff --git a/src/openvic-simulation/map/ProvinceInstance.hpp b/src/openvic-simulation/map/ProvinceInstance.hpp
index e7c0326..ba800a9 100644
--- a/src/openvic-simulation/map/ProvinceInstance.hpp
+++ b/src/openvic-simulation/map/ProvinceInstance.hpp
@@ -3,11 +3,12 @@
 #include <plf_colony.h>
 
 #include "openvic-simulation/economy/BuildingInstance.hpp"
+#include "openvic-simulation/economy/production/ProductionType.hpp"
+#include "openvic-simulation/economy/production/ResourceGatheringOperation.hpp"
 #include "openvic-simulation/military/UnitInstance.hpp"
 #include "openvic-simulation/military/UnitType.hpp"
 #include "openvic-simulation/modifier/ModifierSum.hpp"
 #include "openvic-simulation/pop/Pop.hpp"
-#include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 
@@ -81,8 +82,7 @@ namespace OpenVic {
 
 		bool PROPERTY(slave);
 		Crime const* PROPERTY_RW(crime);
-		// TODO - change this into a factory-like structure
-		GoodDefinition const* PROPERTY(rgo);
+		ResourceGatheringOperation PROPERTY(rgo);
 		IdentifierRegistry<BuildingInstance> IDENTIFIER_REGISTRY(building);
 		ordered_set<ArmyInstance*> PROPERTY(armies);
 		ordered_set<NavyInstance*> PROPERTY(navies);
@@ -95,7 +95,7 @@ namespace OpenVic {
 		fixed_point_t PROPERTY(average_literacy);
 		fixed_point_t PROPERTY(average_consciousness);
 		fixed_point_t PROPERTY(average_militancy);
-		IndexedMap<PopType, fixed_point_t> PROPERTY(pop_type_distribution);
+		IndexedMap<PopType, Pop::pop_size_t> PROPERTY(pop_type_distribution);
 		IndexedMap<Ideology, fixed_point_t> PROPERTY(ideology_distribution);
 		fixed_point_map_t<Culture const*> PROPERTY(culture_distribution);
 		fixed_point_map_t<Religion const*> PROPERTY(religion_distribution);
@@ -108,6 +108,7 @@ namespace OpenVic {
 
 		void _add_pop(Pop&& pop);
 		void _update_pops(DefineManager const& define_manager);
+		bool convert_rgo_worker_pops_to_equivalent(ProductionType const& production_type);
 
 	public:
 		ProvinceInstance(ProvinceInstance&&) = default;
@@ -123,6 +124,9 @@ namespace OpenVic {
 			return controller;
 		}
 
+		GoodDefinition const* get_rgo_good() const;
+		bool set_rgo_production_type_nullable(ProductionType const* rgo_production_type_nullable);
+
 		bool set_owner(CountryInstance* new_owner);
 		bool set_controller(CountryInstance* new_controller);
 		bool add_core(CountryInstance& new_core);
@@ -155,6 +159,9 @@ namespace OpenVic {
 		bool setup(BuildingTypeManager const& building_type_manager);
 		bool apply_history_to_province(ProvinceHistoryEntry const& entry, CountryInstanceManager& country_manager);
 
+		void initialise_for_new_game(ModifierEffectCache const& modifier_effect_cache);
+
 		void setup_pop_test_values(IssueManager const& issue_manager);
+		plf::colony<Pop>& get_mutable_pops();
 	};
 }
diff --git a/src/openvic-simulation/map/State.cpp b/src/openvic-simulation/map/State.cpp
index 619f97b..31ea05f 100644
--- a/src/openvic-simulation/map/State.cpp
+++ b/src/openvic-simulation/map/State.cpp
@@ -66,16 +66,19 @@ void State::update_gamestate() {
 	const int32_t potential_workforce_in_state = 0; // sum of worker pops, regardless of employment
 	const int32_t potential_employment_in_state = 0; // sum of (factory level * production method base_workforce_size)
 
-	fixed_point_t unclamped_score_per_factory = fixed_point_t::_0();
-
-	if (potential_employment_in_state > 0) {
-		unclamped_score_per_factory = (fixed_point_t { potential_workforce_in_state } / fixed_point_t::_100()).floor() * 400 / potential_employment_in_state;
+	fixed_point_t workforce_scalar;
+	constexpr fixed_point_t min_workforce_scalar = fixed_point_t::_0_20();
+	constexpr fixed_point_t max_workforce_scalar = fixed_point_t::_4();
+	if (potential_employment_in_state <= 0) {
+		workforce_scalar = min_workforce_scalar;
 	} else {
-		industrial_power = total_factory_levels_in_state * std::clamp(
-			unclamped_score_per_factory,
-			fixed_point_t::_0_20(), fixed_point_t::_4()
+		workforce_scalar = std::clamp(
+			(fixed_point_t { potential_workforce_in_state } / 100).floor() * 400 / potential_employment_in_state,
+			min_workforce_scalar, max_workforce_scalar
 		);
 	}
+
+	industrial_power = total_factory_levels_in_state * workforce_scalar;
 }
 
 /* Whether two provinces in the same region should be grouped into the same state or not.
diff --git a/src/openvic-simulation/map/State.hpp b/src/openvic-simulation/map/State.hpp
index 596206a..a39eea6 100644
--- a/src/openvic-simulation/map/State.hpp
+++ b/src/openvic-simulation/map/State.hpp
@@ -29,7 +29,7 @@ namespace OpenVic {
 		fixed_point_t PROPERTY(average_literacy);
 		fixed_point_t PROPERTY(average_consciousness);
 		fixed_point_t PROPERTY(average_militancy);
-		IndexedMap<PopType, fixed_point_t> PROPERTY(pop_type_distribution);
+		IndexedMap<PopType, Pop::pop_size_t> PROPERTY(pop_type_distribution);
 
 		fixed_point_t PROPERTY(industrial_power);
 
diff --git a/src/openvic-simulation/pop/Pop.cpp b/src/openvic-simulation/pop/Pop.cpp
index 4b81e5d..0f0de69 100644
--- a/src/openvic-simulation/pop/Pop.cpp
+++ b/src/openvic-simulation/pop/Pop.cpp
@@ -9,6 +9,7 @@
 #include "openvic-simulation/politics/Ideology.hpp"
 #include "openvic-simulation/politics/Issue.hpp"
 #include "openvic-simulation/politics/Rebel.hpp"
+#include "openvic-simulation/utility/Logger.hpp"
 #include "openvic-simulation/utility/TslHelper.hpp"
 
 using namespace OpenVic;
@@ -19,7 +20,7 @@ using enum PopType::income_type_t;
 PopBase::PopBase(
 	PopType const& new_type, Culture const& new_culture, Religion const& new_religion, pop_size_t new_size,
 	fixed_point_t new_militancy, fixed_point_t new_consciousness, RebelType const* new_rebel_type
-) : type { new_type }, culture { new_culture }, religion { new_religion }, size { new_size }, militancy { new_militancy },
+) : type { &new_type }, culture { new_culture }, religion { new_religion }, size { new_size }, militancy { new_militancy },
 	consciousness { new_consciousness }, rebel_type { new_rebel_type } {}
 
 Pop::Pop(PopBase const& pop_base, decltype(ideologies)::keys_t const& ideology_keys)
@@ -115,6 +116,17 @@ void Pop::setup_pop_test_values(IssueManager const& issue_manager) {
 	luxury_needs_fulfilled = test_range();
 }
 
+bool Pop::convert_to_equivalent() {
+	PopType const* const equivalent = get_type()->get_equivalent();
+	if (equivalent == nullptr) {
+		Logger::error("Tried to convert pop of type ", get_type()->get_identifier(), " to equivalent, but there is no equivalent.");
+		return false;
+	}
+	
+	type = equivalent;
+	return true;
+}
+
 void Pop::set_location(ProvinceInstance const& new_location) {
 	if (location != &new_location) {
 		location = &new_location;
@@ -131,7 +143,7 @@ void Pop::set_location(ProvinceInstance const& new_location) {
 void Pop::update_gamestate(
 	DefineManager const& define_manager, CountryInstance const* owner, fixed_point_t const& pop_size_per_regiment_multiplier
 ) {
-	if (type.get_can_be_recruited()) {
+	if (type->get_can_be_recruited()) {
 		if (
 			size < define_manager.get_min_pop_size_for_regiment() || owner == nullptr ||
 			!RegimentType::allowed_cultures_check_culture_in_country(owner->get_allowed_regiment_cultures(), culture, *owner)
@@ -145,6 +157,10 @@ void Pop::update_gamestate(
 	}
 }
 
+//TODO store income
+void Pop::add_rgo_owner_income(const fixed_point_t income) {}
+void Pop::add_rgo_worker_income(const fixed_point_t income) {}
+
 Strata::Strata(std::string_view new_identifier) : HasIdentifier { new_identifier } {}
 
 PopType::PopType(
diff --git a/src/openvic-simulation/pop/Pop.hpp b/src/openvic-simulation/pop/Pop.hpp
index 59a7794..88c397a 100644
--- a/src/openvic-simulation/pop/Pop.hpp
+++ b/src/openvic-simulation/pop/Pop.hpp
@@ -35,7 +35,7 @@ namespace OpenVic {
 		using pop_size_t = int32_t;
 
 	protected:
-		PopType const& PROPERTY_ACCESS(type, protected);
+		PopType const* PROPERTY_ACCESS(type, protected);
 		Culture const& PROPERTY_ACCESS(culture, protected);
 		Religion const& PROPERTY_ACCESS(religion, protected);
 		pop_size_t PROPERTY_ACCESS(size, protected);
@@ -95,6 +95,7 @@ namespace OpenVic {
 		Pop& operator=(Pop&&) = delete;
 
 		void setup_pop_test_values(IssueManager const& issue_manager);
+		bool convert_to_equivalent();
 
 		void set_location(ProvinceInstance const& new_location);
 
@@ -102,6 +103,9 @@ namespace OpenVic {
 			DefineManager const& define_manager, CountryInstance const* owner,
 			fixed_point_t const& pop_size_per_regiment_multiplier
 		);
+
+		void add_rgo_owner_income(const fixed_point_t income);
+		void add_rgo_worker_income(const fixed_point_t income);
 	};
 
 	struct Strata : HasIdentifier {