Merge pull request #696 from OpenVicProject/refactor_province_buildings

Refactor province buildings

Author: wvpm

src/openvic-simulation/DefinitionManager.cpp

@@ -1,7 +1,8 @@
 #include "openvic-simulation/DefinitionManager.hpp"
 
+#include "openvic-simulation/history/HistoryManager.hpp"
 #include "openvic-simulation/interface/UI.hpp"
 
 using namespace OpenVic;
 
-DefinitionManager::DefinitionManager() : ui_manager(*this) {}
+DefinitionManager::DefinitionManager() : ui_manager(*this), history_manager(*this) {}

src/openvic-simulation/dataloader/Dataloader.cpp

@@ -965,10 +965,6 @@ bool Dataloader::load_defines(
 
 	bool ret = true;
 
-	if (!definition_manager.get_mapmode_manager().setup_mapmodes(definition_manager.get_map_definition())) {
-		spdlog::critical_s("Failed to set up mapmodes!");
-		ret = false;
-	}
 	if (!_load_sound_effect_defines(definition_manager)) {
 		spdlog::critical_s("Failed to load sound effect defines");
 		ret = false;
@@ -1033,6 +1029,13 @@ bool Dataloader::load_defines(
 		spdlog::critical_s("Failed to load buildings!");
 		ret = false;
 	}
+	if (!definition_manager.get_mapmode_manager().setup_mapmodes(
+		definition_manager.get_map_definition(),
+		definition_manager.get_economy_manager().get_building_type_manager()
+	)) {
+		spdlog::critical_s("Failed to set up mapmodes!");
+		ret = false;
+	}
 	if (!_load_map_dir(definition_manager)) {
 		spdlog::critical_s("Failed to load map!");
 		ret = false;

src/openvic-simulation/economy/BuildingType.cpp

@@ -1,19 +1,24 @@
 #include "BuildingType.hpp"
 
+#include <optional>
+
 #include "openvic-simulation/economy/GoodDefinition.hpp"
 #include "openvic-simulation/economy/production/ProductionType.hpp"
 #include "openvic-simulation/modifier/ModifierEffectCache.hpp"
 #include "openvic-simulation/modifier/ModifierManager.hpp"
+#include "openvic-simulation/types/TypedIndices.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
 
 BuildingType::BuildingType(
 	index_t new_index,
-	std::string_view identifier,
+	std::optional<province_building_index_t> new_province_building_index,
+	std::string_view new_identifier,
 	building_type_args_t& building_type_args
 ) : HasIndex { new_index },
-	Modifier { identifier, std::move(building_type_args.modifier), modifier_type_t::BUILDING },
+	Modifier { new_identifier, std::move(building_type_args.modifier), modifier_type_t::BUILDING },
+	province_building_index { new_province_building_index },
 	type { building_type_args.type },
 	on_completion { building_type_args.on_completion },
 	completion_size { building_type_args.completion_size },
@@ -40,7 +45,7 @@ BuildingType::BuildingType(
 	capital { building_type_args.capital },
 	port { building_type_args.port } {}
 
-BuildingTypeManager::BuildingTypeManager() : port_building_type { nullptr } {}
+BuildingTypeManager::BuildingTypeManager() : infrastructure_building_type { nullptr }, port_building_type { nullptr } {}
 
 bool BuildingTypeManager::add_building_type(
 	std::string_view identifier, BuildingType::building_type_args_t& building_type_args
@@ -49,14 +54,21 @@ bool BuildingTypeManager::add_building_type(
 		spdlog::error_s("Invalid building identifier - empty!");
 		return false;
 	}
+	
+	std::optional<province_building_index_t> province_building_index = building_type_args.in_province
+		? std::make_optional<province_building_index_t>(province_building_types.size())
+		: std::nullopt;
 
 	const bool ret = building_types.emplace_item(
 		identifier,
-		BuildingType::index_t { get_building_type_count() }, identifier, building_type_args
+		BuildingType::index_t { get_building_type_count() }, province_building_index, identifier, building_type_args
 	);
 
 	if (ret) {
 		building_type_types.emplace(building_type_args.type);
+		if (province_building_index.has_value()) {
+			province_building_types.emplace_back(&building_types.back());
+		}
 	}
 
 	return ret;
@@ -146,13 +158,8 @@ bool BuildingTypeManager::load_buildings_file(
 			this_building_type_effects.min_level, append_string_views(min_prefix, building_type.get_identifier()),
 			FORMAT_x1_0DP_NEG
 		);
-
 		if (building_type.is_in_province()) {
-			province_building_types.emplace_back(&building_type);
-		}
-
-		if (building_type.is_port()) {
-			if (building_type.is_in_province()) {
+			if (building_type.is_port()) {
 				if (port_building_type == nullptr) {
 					port_building_type = &building_type;
 				} else {
@@ -162,7 +169,19 @@ bool BuildingTypeManager::load_buildings_file(
 					);
 					ret = false;
 				}
-			} else {
+			} else if (building_type.get_type() == "infrastructure") {
+				if (infrastructure_building_type == nullptr) {
+					infrastructure_building_type = &building_type;
+				} else {
+					spdlog::error_s(
+						"Building type {} is marked as a infrastructure, but we are already using {} as the infrastructure building type!",
+						building_type, *infrastructure_building_type
+					);
+					ret = false;
+				}
+			}
+		} else {
+			if (building_type.is_port()) {
 				spdlog::error_s(
 					"Building type {} is marked as a port, but is not a province building!", building_type
 				);
@@ -171,6 +190,11 @@ bool BuildingTypeManager::load_buildings_file(
 		}
 	}
 
+	if (infrastructure_building_type == nullptr) {
+		spdlog::error_s("No infrastructure building type found!");
+		ret = false;
+	}
+
 	if (port_building_type == nullptr) {
 		spdlog::error_s("No port building type found!");
 		ret = false;

src/openvic-simulation/economy/BuildingType.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <optional>
+
 #include "openvic-simulation/modifier/Modifier.hpp"
 #include "openvic-simulation/economy/BuildingLevel.hpp"
 #include "openvic-simulation/types/Date.hpp"
@@ -72,9 +74,15 @@ namespace OpenVic {
 		bool PROPERTY(steam); // only in steamer shipyard
 		bool PROPERTY(capital); // only in naval base
 		bool PROPERTY_CUSTOM_PREFIX(port, is); // only in naval base
+		std::optional<province_building_index_t> PROPERTY(province_building_index);
 
 	public:
-		BuildingType(index_t new_index, std::string_view identifier, building_type_args_t& building_type_args);
+		BuildingType(
+			index_t new_index,
+			std::optional<province_building_index_t> new_province_building_index,
+			std::string_view new_identifier,
+			building_type_args_t& building_type_args
+		);
 		BuildingType(BuildingType&&) = default;
 	};
 
@@ -83,6 +91,7 @@ namespace OpenVic {
 		IdentifierRegistry<BuildingType> IDENTIFIER_REGISTRY(building_type);
 		string_set_t PROPERTY(building_type_types);
 		memory::vector<BuildingType const*> SPAN_PROPERTY(province_building_types);
+		BuildingType const* PROPERTY(infrastructure_building_type);
 		BuildingType const* PROPERTY(port_building_type);
 
 	public:

src/openvic-simulation/history/HistoryManager.hpp

@@ -6,11 +6,15 @@
 #include "openvic-simulation/history/ProvinceHistory.hpp"
 
 namespace OpenVic {
+	struct DefinitionManager;
+
 	struct HistoryManager {
 	private:
 		BookmarkManager PROPERTY_REF(bookmark_manager);
 		CountryHistoryManager PROPERTY_REF(country_manager);
 		ProvinceHistoryManager PROPERTY_REF(province_manager);
 		DiplomaticHistoryManager PROPERTY_REF(diplomacy_manager);
+	public:
+		HistoryManager(DefinitionManager const& definition_manager) : province_manager { definition_manager } {}
 	};
 }

src/openvic-simulation/history/ProvinceHistory.cpp

@@ -4,6 +4,7 @@
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/DefinitionManager.hpp"
+#include "openvic-simulation/economy/BuildingLevel.hpp"
 #include "openvic-simulation/economy/GoodDefinition.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
@@ -12,13 +13,26 @@
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
 
-ProvinceHistoryEntry::ProvinceHistoryEntry(ProvinceDefinition const& new_province, Date new_date)
-	: HistoryEntry { new_date }, province { new_province } {}
+ProvinceHistoryEntry::ProvinceHistoryEntry(
+	BuildingTypeManager const& building_type_manager,
+	ProvinceDefinition const& new_province,
+	Date new_date
+) : HistoryEntry { new_date },
+	province { new_province },
+	_province_building_levels(
+		building_type_manager.get_province_building_types().size(),
+		building_level_t(0)
+	),
+	province_building_levels(_province_building_levels)
+{}
 
-ProvinceHistoryMap::ProvinceHistoryMap(ProvinceDefinition const& new_province) : province { new_province } {}
+ProvinceHistoryMap::ProvinceHistoryMap(ProvinceDefinition const& new_province, BuildingTypeManager const& new_building_type_manager)
+  : province { new_province },
+	building_type_manager { new_building_type_manager }
+ {}
 
 memory::unique_ptr<ProvinceHistoryEntry> ProvinceHistoryMap::_make_entry(Date date) const {
-	return memory::make_unique<ProvinceHistoryEntry>(province, date);
+	return memory::make_unique<ProvinceHistoryEntry>(building_type_manager, province, date);
 }
 
 bool ProvinceHistoryMap::_load_history_entry(
@@ -85,7 +99,17 @@ bool ProvinceHistoryMap::_load_history_entry(
 					return expect_strong_typedef<building_level_t>(
 						/* This is set to warn to prevent vanilla from always having errors because
 						 * of a duplicate railroad entry in the 1861.1.1 history of Manchester (278). */
-						map_callback(entry.province_buildings, building_type, true)
+						[
+							&entry,
+							optional_index = building_type->get_province_building_index()
+						](const building_level_t level) -> bool {
+							if (!optional_index.has_value()) {
+								return false;
+							}
+
+							entry.province_building_levels[optional_index.value()] = level;
+							return true;
+						}
 					)(value);
 				} else {
 					spdlog::error_s(
@@ -167,7 +191,7 @@ bool ProvinceHistoryMap::_load_history_entry(
 			)(node);
 			if (building_type != nullptr) {
 				if (!building_type->is_in_province()) {
-					ret &= map_callback(entry.state_buildings, building_type, true)(level);
+					ret &= map_callback(entry.state_buildings, building_type->index, true)(level);
 				} else {
 					spdlog::error_s(
 						"Attempted to add province building \"{}\" to state building list of province history for {}",
@@ -241,7 +265,13 @@ ProvinceHistoryMap* ProvinceHistoryManager::_get_or_make_province_history(Provin
 	decltype(province_histories)::iterator it = province_histories.find(&province);
 	if (it == province_histories.end()) {
 		const std::pair<decltype(province_histories)::iterator, bool> result =
-			province_histories.emplace(&province, ProvinceHistoryMap { province });
+			province_histories.emplace(
+				&province,
+				ProvinceHistoryMap {
+					province,
+					definition_manager.get_economy_manager().get_building_type_manager()
+				}
+			);
 		if (result.second) {
 			it = result.first;
 		} else {

src/openvic-simulation/history/ProvinceHistory.hpp

@@ -8,8 +8,11 @@
 #include "openvic-simulation/economy/BuildingLevel.hpp"
 #include "openvic-simulation/types/ColonyStatus.hpp"
 #include "openvic-simulation/types/Date.hpp"
-#include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
+#include "openvic-simulation/types/FixedVector.hpp"
+#include "openvic-simulation/types/OrderedContainers.hpp"
+#include "openvic-simulation/types/TypedSpan.hpp"
+#include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/map/LifeRating.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
@@ -26,7 +29,11 @@ namespace OpenVic {
 	struct ProvinceHistoryEntry : HistoryEntry {
 		friend struct ProvinceHistoryMap;
 
-		ProvinceHistoryEntry(ProvinceDefinition const& new_province, Date new_date);
+		ProvinceHistoryEntry(
+			BuildingTypeManager const& building_type_manager,
+			ProvinceDefinition const& new_province,
+			Date new_date
+		);
 	private:
 		std::optional<CountryDefinition const*> PROPERTY(owner);
 		std::optional<CountryDefinition const*> PROPERTY(controller);
@@ -36,8 +43,14 @@ namespace OpenVic {
 		std::optional<ProductionType const*> PROPERTY(rgo_production_type_nullable);
 		std::optional<life_rating_t> PROPERTY(life_rating);
 		std::optional<TerrainType const*> PROPERTY(terrain_type);
-		ordered_map<BuildingType const*, building_level_t> PROPERTY(province_buildings);
-		ordered_map<BuildingType const*, building_level_t> PROPERTY(state_buildings);
+		memory::FixedVector<building_level_t> _province_building_levels;
+		TypedSpan<province_building_index_t, building_level_t> province_building_levels;
+	public:
+		constexpr TypedSpan<province_building_index_t, const building_level_t> get_province_building_levels() const {
+			return province_building_levels;
+		}
+	private:
+		ordered_map<building_type_index_t, building_level_t> PROPERTY(state_buildings);
 		fixed_point_map_t<Ideology const*> PROPERTY(party_loyalties);
 		memory::vector<PopBase> SPAN_PROPERTY(pops);
 
@@ -55,9 +68,10 @@ namespace OpenVic {
 
 	private:
 		ProvinceDefinition const& province;
+		BuildingTypeManager const& building_type_manager;
 
 	protected:
-		ProvinceHistoryMap(ProvinceDefinition const& new_province);
+		ProvinceHistoryMap(ProvinceDefinition const& new_province, BuildingTypeManager const& new_building_type_manager);
 
 		memory::unique_ptr<ProvinceHistoryEntry> _make_entry(Date date) const override;
 		bool _load_history_entry(DefinitionManager const& definition_manager, ProvinceHistoryEntry& entry, ast::NodeCPtr root)
@@ -73,13 +87,14 @@ namespace OpenVic {
 
 	struct ProvinceHistoryManager {
 	private:
+		DefinitionManager const& definition_manager;
 		ordered_map<ProvinceDefinition const*, ProvinceHistoryMap> province_histories;
 		bool locked = false;
 
 		ProvinceHistoryMap* _get_or_make_province_history(ProvinceDefinition const& province);
 
 	public:
-		ProvinceHistoryManager() {};
+		ProvinceHistoryManager(DefinitionManager const& new_definition_manager) : definition_manager { new_definition_manager } {};
 
 		void reserve_more_province_histories(size_t size);
 		void lock_province_histories(MapDefinition const& map_definition, bool detailed_errors);