Merge pull request #544 from OpenVicProject/update_states_and_allowed_regiment_cultures

Update states and allowed regiment cultures

Author: wvpm

src/openvic-simulation/InstanceManager.cpp

@@ -243,8 +243,8 @@ bool InstanceManager::load_bookmark(Bookmark const* new_bookmark) {
 	OV_ERR_FAIL_COND_V_MSG(!all_has_state, false, "At least one land province has no state");
 
 	update_modifier_sums();
-	country_instance_manager.update_gamestate(*this);
 	map_instance.initialise_for_new_game(*this);
+	country_instance_manager.update_gamestate(*this);
 	market_instance.execute_orders();
 
 	return ret;

src/openvic-simulation/country/CountryInstance.cpp

@@ -16,6 +16,7 @@
 #include "openvic-simulation/map/Crime.hpp"
 #include "openvic-simulation/map/MapInstance.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
+#include "openvic-simulation/military/UnitType.hpp"
 #include "openvic-simulation/modifier/ModifierEffectCache.hpp"
 #include "openvic-simulation/modifier/StaticModifierCache.hpp"
 #include "openvic-simulation/pop/Pop.hpp"
@@ -26,6 +27,7 @@
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/types/UnitBranchType.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Utility.hpp"
 
@@ -722,7 +724,35 @@ bool CountryInstance::modify_unit_type_unlock(UnitTypeBranched<Branch> const& un
 		return false;
 	}
 
-	unlock_level += unlock_level_change;
+	if constexpr (Branch != unit_branch_t::LAND) {
+		unlock_level += unlock_level_change;
+	} else {
+		bool was_unlocked = is_unit_type_unlocked(unit_type);
+		unlock_level += unlock_level_change;
+		bool is_unlocked = is_unit_type_unlocked(unit_type);
+
+		if (was_unlocked != is_unlocked) {
+			if (was_unlocked) {
+				//recalculate entirely
+				allowed_regiment_cultures = regiment_allowed_cultures_t::NO_CULTURES;
+				for (RegimentType const& regiment_type : unlocked_unit_types.get_keys()) {
+					if (!is_unit_type_unlocked(regiment_type)) {
+						continue;
+					}
+
+					allowed_regiment_cultures = RegimentType::allowed_cultures_get_most_permissive(
+						allowed_regiment_cultures,
+						regiment_type.get_allowed_cultures()
+					);
+				}
+			} else {
+				allowed_regiment_cultures = RegimentType::allowed_cultures_get_most_permissive(
+					allowed_regiment_cultures,
+					unit_type.get_allowed_cultures()
+				);
+			}
+		}
+	}
 
 	return true;
 }

src/openvic-simulation/map/State.cpp

@@ -16,7 +16,6 @@ using namespace OpenVic;
 
 State::State(
 	StateSet const& new_state_set,
-	CountryInstance* new_owner,
 	ProvinceInstance* new_capital,
 	memory::vector<ProvinceInstance*>&& new_provinces,
 	colony_status_t new_colony_status,
@@ -25,21 +24,33 @@ State::State(
 	utility::forwardable_span<const Ideology> ideology_keys
 ) : PopsAggregate { strata_keys, pop_type_keys, ideology_keys },
 	state_set { new_state_set },
-	owner { new_owner },
 	capital { new_capital },
 	provinces { std::move(new_provinces) },
 	colony_status { new_colony_status },
-	pops_cache_by_type { pop_type_keys } {
-		update_parties_for_votes(new_owner);
-	}
+	pops_cache_by_type { pop_type_keys }
+{
+	_update_country();
+}
 
 memory::string State::get_identifier() const {
+	CountryInstance const* const owner_ptr = get_owner();
 	return StringUtils::append_string_views(
-		state_set.get_region().get_identifier(), "_", owner->get_identifier(), "_",
+		state_set.get_region().get_identifier(),
+		"_",
+		owner_ptr == nullptr
+			? "NoCountry"
+			: owner_ptr->get_identifier(),
+		"_",
 		ProvinceInstance::get_colony_status_string(colony_status)
 	);
 }
 
+CountryInstance* State::get_owner() const {
+	return capital == nullptr
+		? static_cast<CountryInstance*>(nullptr)
+		: capital->get_owner();
+}
+
 memory::vector<Pop*> const& State::get_pops_cache_by_type(PopType const& pop_type) const {
 	return pops_cache_by_type.at(pop_type);
 }
@@ -84,6 +95,25 @@ void State::update_gamestate() {
 	}
 
 	industrial_power = total_factory_levels_in_state * workforce_scalar;
+	_update_country();
+}
+
+void State::_update_country() {
+	CountryInstance* const owner_ptr = get_owner();
+	if (owner_ptr == previous_country_ptr) { 
+		return;
+	}
+	
+	update_parties_for_votes(owner_ptr);
+	if (previous_country_ptr != nullptr) {
+		previous_country_ptr->remove_state(*this);
+	}
+
+	if (owner_ptr != nullptr) {
+		owner_ptr->add_state(*this);
+	}
+
+	previous_country_ptr = owner_ptr;
 }
 
 /* Whether two provinces in the same region should be grouped into the same state or not.
@@ -146,22 +176,16 @@ bool StateManager::add_state_set(
 	for (memory::vector<ProvinceInstance*>& provinces : temp_provinces) {
 		ProvinceInstance* capital = provinces.front();
 
-		CountryInstance* owner = capital->get_owner();
-
 		State& state = *state_set.states.emplace(
 			/* TODO: capital province logic */
-			state_set, owner, capital,
+			state_set, capital,
 			std::move(provinces), capital->get_colony_status(),
 			strata_keys, pop_type_keys, ideology_keys
 		);
 
 		for (ProvinceInstance* province : state.get_provinces()) {
 			province->set_state(&state);
 		}
-
-		if (owner != nullptr) {
-			owner->add_state(state);
-		}
 	}
 
 	return true;

src/openvic-simulation/map/State.hpp

@@ -28,19 +28,21 @@ namespace OpenVic {
 		friend struct StateManager;
 
 	private:
+		CountryInstance* previous_country_ptr = nullptr;	
+
 		StateSet const& PROPERTY(state_set);
-		CountryInstance* PROPERTY_PTR(owner);
 		ProvinceInstance* PROPERTY_PTR(capital);
 		memory::vector<ProvinceInstance*> SPAN_PROPERTY(provinces);
 		colony_status_t PROPERTY(colony_status);
 		fixed_point_t PROPERTY(industrial_power);
 
 		IndexedFlatMap_PROPERTY(PopType, memory::vector<Pop*>, pops_cache_by_type);
 
+		void _update_country();
+
 	public:
 		State(
 			StateSet const& new_state_set,
-			CountryInstance* new_owner,
 			ProvinceInstance* new_capital,
 			memory::vector<ProvinceInstance*>&& new_provinces,
 			colony_status_t new_colony_status,
@@ -54,6 +56,7 @@ namespace OpenVic {
 		State& operator=(State const&) = delete;
 
 		memory::string get_identifier() const;
+		CountryInstance* get_owner() const;
 
 		constexpr bool is_colonial_state() const {
 			return is_colonial(colony_status);