Refactor province buildings

Author: wvpm

src/openvic-simulation/economy/BuildingType.cpp

@@ -1,19 +1,23 @@
 #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 },
@@ -49,10 +53,14 @@ 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) {
@@ -147,10 +155,6 @@ bool BuildingTypeManager::load_buildings_file(
 			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 (port_building_type == nullptr) {

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;
 	};
 

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,8 +13,18 @@
 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 } {}
 
@@ -85,7 +96,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 +188,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 {}",

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,9 @@ 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> SPAN_PROPERTY(province_building_levels);
+		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);
 

src/openvic-simulation/map/ProvinceInstance.cpp

@@ -5,13 +5,15 @@
 #include "openvic-simulation/country/CountryInstance.hpp"
 #include "openvic-simulation/defines/Define.hpp"
 #include "openvic-simulation/DefinitionManager.hpp"
+#include "openvic-simulation/economy/BuildingInstance.hpp"
 #include "openvic-simulation/economy/BuildingType.hpp"
 #include "openvic-simulation/economy/production/Employee.hpp"
 #include "openvic-simulation/economy/production/ProductionType.hpp"
 #include "openvic-simulation/InstanceManager.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/modifier/StaticModifierCache.hpp"
+#include "openvic-simulation/types/TypedIndices.hpp"
 
 using namespace OpenVic;
 
@@ -30,22 +32,19 @@ ProvinceInstance::ProvinceInstance(
 	game_rules_manager { province_instance_deps->game_rules_manager },
 	terrain_type { new_province_definition->get_default_terrain_type() },
 	rgo { province_instance_deps->rgo_deps },
-	pops_cache_by_type { province_instance_deps->pop_types }
+	pops_cache_by_type { province_instance_deps->pop_types },
+	_buildings(
+		new_province_definition->is_water()
+			? 0
+			: province_instance_deps->building_type_manager.get_province_building_types().size(),
+			[&province_instance_deps](const size_t i)->BuildingInstance {
+				return *province_instance_deps->building_type_manager.get_province_building_types()[i];
+			}
+	),
+	buildings(_buildings)
 {
 	modifier_sum.set_this_source(this);
 	rgo.setup_location_ptr(*this);
-	if (!province_definition.is_water()) {
-		BuildingTypeManager const& building_type_manager = province_instance_deps->building_type_manager;
-		assert(building_type_manager.building_types_are_locked());
-		buildings.reserve(building_type_manager.get_province_building_types().size());
-
-		for (BuildingType const* building_type_ptr : building_type_manager.get_province_building_types()) {
-			BuildingType const& building_type = *building_type_ptr;
-			buildings.emplace_item(building_type.get_identifier(), building_type);
-		}
-	}
-
-	lock_buildings();
 }
 
 ModifierSum const& ProvinceInstance::get_owner_modifier_sum() const {
@@ -172,17 +171,8 @@ bool ProvinceInstance::remove_core(CountryInstance& core_to_remove, bool warn) {
 	return true;
 }
 
-bool ProvinceInstance::expand_building(const building_instance_index_t index) {
-	BuildingInstance* building = buildings.get_item_by_index(type_safe::get(index));
-	if (building == nullptr) {
-		spdlog::error_s(
-			"Trying to expand non-existent building index {} in province {}",
-			index, *this
-		);
-		return false;
-	}
-	
-	return building->expand();
+bool ProvinceInstance::expand_building(const province_building_index_t index) {
+	return buildings[index].expand();
 }
 
 void ProvinceInstance::_add_pop(Pop&& pop) {
@@ -299,7 +289,7 @@ void ProvinceInstance::update_modifier_sum(Date today, StaticModifierCache const
 		}
 	});
 
-	for (BuildingInstance const& building : buildings.get_items()) {
+	for (BuildingInstance const& building : buildings) {
 		modifier_sum.add_modifier(building.building_type);
 	}
 
@@ -380,7 +370,7 @@ void ProvinceInstance::update_gamestate(InstanceManager const& instance_manager)
 
 	const Date today = instance_manager.get_today();
 
-	for (BuildingInstance& building : buildings.get_items()) {
+	for (BuildingInstance& building : buildings) {
 		building.update_gamestate(today);
 	}
 	_update_pops(instance_manager.definition_manager.get_define_manager());
@@ -397,7 +387,7 @@ void ProvinceInstance::province_tick(
 	> reusable_vectors
 ) {
 	if (is_occupied()) {
-		occupation_duration++;
+		++occupation_duration;
 	}
 
 	if (!pops.empty()) {
@@ -412,7 +402,7 @@ void ProvinceInstance::province_tick(
 		}
 	}
 
-	for (BuildingInstance& building : buildings.get_items()) {
+	for (BuildingInstance& building : buildings) {
 		building.tick(today);
 	}
 	rgo.rgo_tick(reusable_vectors[0]);
@@ -499,17 +489,8 @@ bool ProvinceInstance::apply_history_to_province(ProvinceHistoryEntry const& ent
 
 	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()) {
-		BuildingInstance* existing_entry = buildings.get_item_by_identifier(building->get_identifier());
-		if (existing_entry != nullptr) {
-			existing_entry->set_level(level);
-		} else {
-			spdlog::error_s(
-				"Trying to set level of non-existent province building {} to {} in province {}",
-				*building, level, *this
-			);
-			ret = false;
-		}
+	for (auto const& [province_building_index, level] : entry.get_province_buildings()) {
+		buildings[province_building_index].set_level(level);
 	}
 	// TODO: load state buildings - entry.get_state_buildings()
 	// TODO: party loyalties for each POP when implemented on POP side - entry.get_party_loyalties()

src/openvic-simulation/map/ProvinceInstance.hpp

@@ -2,6 +2,7 @@
 
 #include <plf_colony.h>
 
+#include "openvic-simulation/core/portable/ForwardableSpan.hpp"
 #include "openvic-simulation/economy/BuildingInstance.hpp"
 #include "openvic-simulation/economy/production/ResourceGatheringOperation.hpp"
 #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp"
@@ -14,10 +15,11 @@
 #include "openvic-simulation/types/HasIndex.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/map/LifeRating.hpp"
+#include "openvic-simulation/types/FixedVector.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
-#include "openvic-simulation/core/portable/ForwardableSpan.hpp"
+#include "types/TypedSpan.hpp"
 
 namespace OpenVic {
 	struct BaseIssue;
@@ -95,7 +97,8 @@ namespace OpenVic {
 		memory::vector<ProvinceInstance const*> SPAN_PROPERTY(adjacent_nonempty_land_provinces);
 		Crime const* PROPERTY_RW(crime, nullptr);
 		ResourceGatheringOperation PROPERTY(rgo);
-		IdentifierRegistry<BuildingInstance> IDENTIFIER_REGISTRY(building, false);
+		memory::FixedVector<BuildingInstance> _buildings;
+		TypedSpan<province_building_index_t, BuildingInstance> SPAN_PROPERTY(buildings);
 		memory::vector<ArmyInstance*> SPAN_PROPERTY(armies);
 		memory::vector<NavyInstance*> SPAN_PROPERTY(navies);
 		// The number of land regiments currently in the province, including those being transported by navies
@@ -158,7 +161,7 @@ namespace OpenVic {
 			return owner == nullptr;
 		}
 
-		bool expand_building(const building_instance_index_t index);
+		bool expand_building(const province_building_index_t index);
 
 		bool add_pop(Pop&& pop);
 		bool add_pop_vec(

src/openvic-simulation/misc/GameAction.cpp

@@ -44,15 +44,15 @@ bool GameActionManager::VariantVisitor::operator() (set_ai_argument_t const& arg
 
 // Production
 bool GameActionManager::VariantVisitor::operator() (expand_province_building_argument_t const& argument) const {
-	const auto [province_index, building_instance_index] = argument;
+	const auto [province_index, province_building_index] = argument;
 	ProvinceInstance* province = instance_manager.get_map_instance().get_province_instance_by_index(province_index);
 
 	if (OV_unlikely(province == nullptr)) {
 		spdlog::error_s("GAME_ACTION_EXPAND_PROVINCE_BUILDING called with invalid province index: {}", province_index);
 		return false;
 	}
 
-	return province->expand_building(building_instance_index);
+	return province->expand_building(province_building_index);
 }
 
 // Budget

src/openvic-simulation/misc/GameAction.hpp

@@ -68,7 +68,7 @@ X(tick, std::monostate) \
 X(set_pause, bool) \
 X(set_speed, int64_t) \
 X(set_ai, country_index_t, bool) \
-X(expand_province_building, province_index_t, building_instance_index_t) \
+X(expand_province_building, province_index_t, province_building_index_t) \
 X(set_strata_tax, country_index_t, strata_index_t, fixed_point_t) \
 X(set_army_spending, country_index_t, fixed_point_t) \
 X(set_navy_spending, country_index_t, fixed_point_t) \

src/openvic-simulation/types/TypedIndices.hpp

@@ -26,8 +26,8 @@
 #define TYPED_INDEX(name) TYPED_INDEX_CUSTOM(name, std::size_t)
 
 TYPED_INDEX(bookmark_index_t)
-TYPED_INDEX(building_instance_index_t)
 TYPED_INDEX(building_type_index_t)
+TYPED_INDEX(province_building_index_t)
 TYPED_INDEX(country_index_t)
 TYPED_INDEX(crime_index_t)
 TYPED_INDEX(good_index_t)