Merge pull request #195 from OpenVicProject/ranking

Ranking System

1 files changed, 399 insertions, 67 deletions

diff --git a/src/openvic-simulation/country/CountryInstance.cpp b/src/openvic-simulation/country/CountryInstance.cpp
index 3c2e7bb..4fab010 100644
--- a/src/openvic-simulation/country/CountryInstance.cpp
+++ b/src/openvic-simulation/country/CountryInstance.cpp
@@ -3,12 +3,15 @@
 #include "openvic-simulation/country/CountryDefinition.hpp"
 #include "openvic-simulation/history/CountryHistory.hpp"
 #include "openvic-simulation/map/MapInstance.hpp"
+#include "openvic-simulation/misc/Define.hpp"
 #include "openvic-simulation/politics/Ideology.hpp"
 #include "openvic-simulation/research/Invention.hpp"
 #include "openvic-simulation/research/Technology.hpp"
 
 using namespace OpenVic;
 
+using enum CountryInstance::country_status_t;
+
 static constexpr colour_t ERROR_COLOUR = colour_t::from_integer(0xFF0000);
 
 CountryInstance::CountryInstance(
@@ -17,20 +20,30 @@ CountryInstance::CountryInstance(
 	decltype(inventions)::keys_t const& invention_keys,
 	decltype(upper_house)::keys_t const& ideology_keys,
 	decltype(government_flag_overrides)::keys_t const& government_type_keys,
-	decltype(pop_type_distribution)::keys_t const& pop_type_keys
+	decltype(pop_type_distribution)::keys_t const& pop_type_keys,
+	decltype(unlocked_regiment_types)::keys_t const& unlocked_regiment_types_keys,
+	decltype(unlocked_ship_types)::keys_t const& unlocked_ship_types_keys
 ) : /* Main attributes */
 	country_definition { new_country_definition },
 	colour { ERROR_COLOUR },
 	capital { nullptr },
 	country_flags {},
-	civilised { false },
 	releasable_vassal { true },
+	country_status { COUNTRY_STATUS_UNCIVILISED },
+	lose_great_power_date {},
+	total_score { 0 },
+	total_rank { 0 },
 	owned_provinces {},
 	controlled_provinces {},
 	core_provinces {},
 	states {},
 
 	/* Production */
+	industrial_power { 0 },
+	industrial_power_from_states {},
+	industrial_power_from_investments {},
+	industrial_rank { 0 },
+	foreign_investments {},
 
 	/* Budget */
 	cash_stockpile { 0 },
@@ -73,32 +86,74 @@ CountryInstance::CountryInstance(
 	/* Trade */
 
 	/* Diplomacy */
-	total_rank { 0 },
 	prestige { 0 },
 	prestige_rank { 0 },
-	industrial_power { 0 },
-	industrial_rank { 0 },
-	military_power { 0 },
-	military_rank { 0 },
 	diplomatic_points { 0 },
 
 	/* Military */
+	military_power { 0 },
+	military_power_from_land { 0 },
+	military_power_from_sea { 0 },
+	military_power_from_leaders { 0 },
+	military_rank { 0 },
 	generals {},
 	admirals {},
 	armies {},
 	navies {},
 	regiment_count { 0 },
-	mobilisation_regiment_potential { 0 },
+	max_supported_regiment_count { 0 },
+	mobilisation_potential_regiment_count { 0 },
+	mobilisation_max_regiment_count { 0 },
+	mobilisation_impact { 0 },
+	supply_consumption { 1 },
 	ship_count { 0 },
 	total_consumed_ship_supply { 0 },
 	max_ship_supply { 0 },
 	leadership_points { 0 },
-	war_exhaustion { 0 } {}
+	war_exhaustion { 0 },
+	mobilised { false },
+	disarmed { false },
+	unlocked_regiment_types { &unlocked_regiment_types_keys },
+	allowed_regiment_cultures { RegimentType::allowed_cultures_t::NO_CULTURES },
+	unlocked_ship_types { &unlocked_ship_types_keys } {
+
+	for (RegimentType const& regiment_type : *unlocked_regiment_types.get_keys()) {
+		if (regiment_type.is_active()) {
+			unlock_unit_type(regiment_type);
+		}
+	}
+
+	for (ShipType const& ship_type : *unlocked_ship_types.get_keys()) {
+		if (ship_type.is_active()) {
+			unlock_unit_type(ship_type);
+		}
+	}
+}
 
 std::string_view CountryInstance::get_identifier() const {
 	return country_definition->get_identifier();
 }
 
+bool CountryInstance::exists() const {
+	return !owned_provinces.empty();
+}
+
+bool CountryInstance::is_civilised() const {
+	return country_status <= COUNTRY_STATUS_CIVILISED;
+}
+
+bool CountryInstance::can_colonise() const {
+	return country_status <= COUNTRY_STATUS_SECONDARY_POWER;
+}
+
+bool CountryInstance::is_great_power() const {
+	return country_status == COUNTRY_STATUS_GREAT_POWER;
+}
+
+bool CountryInstance::is_secondary_power() const {
+	return country_status == COUNTRY_STATUS_SECONDARY_POWER;
+}
+
 bool CountryInstance::set_country_flag(std::string_view flag, bool warn) {
 	if (flag.empty()) {
 		Logger::error("Attempted to set empty country flag for country ", get_identifier());
@@ -245,12 +300,55 @@ template void CountryInstance::add_leader(LeaderBranched<UnitType::branch_t::NAV
 template bool CountryInstance::remove_leader(LeaderBranched<UnitType::branch_t::LAND> const*);
 template bool CountryInstance::remove_leader(LeaderBranched<UnitType::branch_t::NAVAL> const*);
 
-bool CountryInstance::apply_history_to_country(CountryHistoryEntry const* entry, MapInstance& map_instance) {
-	if (entry == nullptr) {
-		Logger::error("Trying to apply null country history to ", get_identifier());
-		return false;
+template<UnitType::branch_t Branch>
+void CountryInstance::unlock_unit_type(UnitTypeBranched<Branch> const& unit_type) {
+	IndexedMap<UnitTypeBranched<Branch>, bool>& unlocked_unit_types = get_unlocked_unit_types<Branch>();
+
+	decltype(unlocked_regiment_types)::value_ref_t unlock_value = unlocked_unit_types[unit_type];
+
+	if (unlock_value) {
+		Logger::warning(
+			"Attempted to unlock already-unlocked unit type \"", unit_type.get_identifier(),
+			"\" for country ", get_identifier()
+		);
+		return;
 	}
 
+	unlock_value = true;
+
+	if constexpr (Branch == UnitType::branch_t::LAND) {
+		allowed_regiment_cultures = RegimentType::allowed_cultures_get_most_permissive(
+			allowed_regiment_cultures, unit_type.get_allowed_cultures()
+		);
+	}
+}
+
+template void CountryInstance::unlock_unit_type(UnitTypeBranched<UnitType::branch_t::LAND> const&);
+template void CountryInstance::unlock_unit_type(UnitTypeBranched<UnitType::branch_t::NAVAL> const&);
+
+bool CountryInstance::is_primary_culture(Culture const& culture) const {
+	return &culture == primary_culture;
+}
+
+bool CountryInstance::is_accepted_culture(Culture const& culture) const {
+	return accepted_cultures.contains(&culture);
+}
+
+bool CountryInstance::is_primary_or_accepted_culture(Culture const& culture) const {
+	return is_primary_culture(culture) || is_accepted_culture(culture);
+}
+
+void CountryInstance::apply_foreign_investments(
+	fixed_point_map_t<CountryDefinition const*> const& investments, CountryInstanceManager const& country_instance_manager
+) {
+	for (auto const& [country, money_invested] : investments) {
+		foreign_investments[&country_instance_manager.get_country_instance_from_definition(*country)] = money_invested;
+	}
+}
+
+bool CountryInstance::apply_history_to_country(
+	CountryHistoryEntry const& entry, MapInstance& map_instance, CountryInstanceManager const& country_instance_manager
+) {
 	constexpr auto set_optional = []<typename T>(T& target, std::optional<T> const& source) {
 		if (source) {
 			target = *source;
@@ -259,60 +357,94 @@ bool CountryInstance::apply_history_to_country(CountryHistoryEntry const* entry,
 
 	bool ret = true;
 
-	set_optional(primary_culture, entry->get_primary_culture());
-	for (Culture const* culture : entry->get_accepted_cultures()) {
+	set_optional(primary_culture, entry.get_primary_culture());
+	for (Culture const* culture : entry.get_accepted_cultures()) {
 		ret &= add_accepted_culture(*culture);
 	}
-	set_optional(religion, entry->get_religion());
-	set_optional(ruling_party, entry->get_ruling_party());
-	set_optional(last_election, entry->get_last_election());
-	ret &= upper_house.copy(entry->get_upper_house());
-	if (entry->get_capital()) {
-		capital = &map_instance.get_province_instance_from_definition(**entry->get_capital());
-	}
-	set_optional(government_type, entry->get_government_type());
-	set_optional(plurality, entry->get_plurality());
-	set_optional(national_value, entry->get_national_value());
-	set_optional(civilised, entry->is_civilised());
-	set_optional(prestige, entry->get_prestige());
-	for (Reform const* reform : entry->get_reforms()) {
+	set_optional(religion, entry.get_religion());
+	set_optional(ruling_party, entry.get_ruling_party());
+	set_optional(last_election, entry.get_last_election());
+	ret &= upper_house.copy(entry.get_upper_house());
+	if (entry.get_capital()) {
+		capital = &map_instance.get_province_instance_from_definition(**entry.get_capital());
+	}
+	set_optional(government_type, entry.get_government_type());
+	set_optional(plurality, entry.get_plurality());
+	set_optional(national_value, entry.get_national_value());
+	if (entry.is_civilised()) {
+		country_status = *entry.is_civilised() ? COUNTRY_STATUS_CIVILISED : COUNTRY_STATUS_UNCIVILISED;
+	}
+	set_optional(prestige, entry.get_prestige());
+	for (Reform const* reform : entry.get_reforms()) {
 		ret &= add_reform(reform);
 	}
-	set_optional(tech_school, entry->get_tech_school());
+	set_optional(tech_school, entry.get_tech_school());
 	constexpr auto set_bool_map_to_indexed_map =
 		[]<typename T>(IndexedMap<T, bool>& target, ordered_map<T const*, bool> source) {
 			for (auto const& [key, value] : source) {
 				target[*key] = value;
 			}
 		};
-	set_bool_map_to_indexed_map(technologies, entry->get_technologies());
-	set_bool_map_to_indexed_map(inventions, entry->get_inventions());
-	// entry->get_foreign_investment();
+	set_bool_map_to_indexed_map(technologies, entry.get_technologies());
+	set_bool_map_to_indexed_map(inventions, entry.get_inventions());
+	apply_foreign_investments(entry.get_foreign_investment(), country_instance_manager);
 
 	// These need to be applied to pops
-	// entry->get_consciousness();
-	// entry->get_nonstate_consciousness();
-	// entry->get_literacy();
-	// entry->get_nonstate_culture_literacy();
-
-	set_optional(releasable_vassal, entry->is_releasable_vassal());
-	// entry->get_colonial_points();
-	for (std::string const& flag : entry->get_country_flags()) {
+	// entry.get_consciousness();
+	// entry.get_nonstate_consciousness();
+	// entry.get_literacy();
+	// entry.get_nonstate_culture_literacy();
+
+	set_optional(releasable_vassal, entry.is_releasable_vassal());
+	// entry.get_colonial_points();
+	for (std::string const& flag : entry.get_country_flags()) {
 		ret &= set_country_flag(flag, true);
 	}
-	for (std::string const& flag : entry->get_global_flags()) {
+	for (std::string const& flag : entry.get_global_flags()) {
 		// TODO - set global flag
 	}
-	government_flag_overrides.write_non_empty_values(entry->get_government_flag_overrides());
-	for (Decision const* decision : entry->get_decisions()) {
+	government_flag_overrides.write_non_empty_values(entry.get_government_flag_overrides());
+	for (Decision const* decision : entry.get_decisions()) {
 		// TODO - take decision
 	}
 
 	return ret;
 }
 
-void CountryInstance::_update_production() {
+void CountryInstance::_update_production(DefineManager const& define_manager) {
+	// Calculate industrial power from states and foreign investments
+	industrial_power = 0;
+	industrial_power_from_states.clear();
+	industrial_power_from_investments.clear();
+
+	for (State const* state : states) {
+		const fixed_point_t state_industrial_power = state->get_industrial_power();
+		if (state_industrial_power != 0) {
+			industrial_power += state_industrial_power;
+			industrial_power_from_states.emplace_back(state, state_industrial_power);
+		}
+	}
+
+	for (auto const& [country, money_invested] : foreign_investments) {
+		if (country->exists()) {
+			const fixed_point_t investment_industrial_power =
+				money_invested * define_manager.get_country_investment_industrial_score_factor() / 100;
 
+			if (investment_industrial_power != 0) {
+				industrial_power += investment_industrial_power;
+				industrial_power_from_investments.emplace_back(country, investment_industrial_power);
+			}
+		}
+	}
+
+	std::sort(
+		industrial_power_from_states.begin(), industrial_power_from_states.end(),
+		[](auto const& a, auto const& b) -> bool { return a.second > b.second; }
+	);
+	std::sort(
+		industrial_power_from_investments.begin(), industrial_power_from_investments.end(),
+		[](auto const& a, auto const& b) -> bool { return a.second > b.second; }
+	);
 }
 
 void CountryInstance::_update_budget() {
@@ -334,7 +466,7 @@ void CountryInstance::_update_population() {
 	national_militancy = 0;
 	pop_type_distribution.clear();
 
-	for (auto const& state : states) {
+	for (State const* state : states) {
 		total_population += state->get_total_population();
 
 		// TODO - change casting if Pop::pop_size_t changes type
@@ -360,11 +492,11 @@ void CountryInstance::_update_trade() {
 }
 
 void CountryInstance::_update_diplomacy() {
-	// TODO - update prestige, industrial_power, military_power (ranks will be updated after all countries have calculated their scores)
+	// TODO - add prestige from modifiers
 	// TODO - update diplomatic points and colonial power
 }
 
-void CountryInstance::_update_military() {
+void CountryInstance::_update_military(DefineManager const& define_manager, UnitTypeManager const& unit_type_manager) {
 	regiment_count = 0;
 
 	for (ArmyInstance const* army : armies) {
@@ -379,10 +511,91 @@ void CountryInstance::_update_military() {
 		total_consumed_ship_supply += navy->get_total_consumed_supply();
 	}
 
-	// TODO - update mobilisation_regiment_potential, max_ship_supply, leadership_points, war_exhaustion
+	// Calculate military power from land, sea, and leaders
+
+	size_t deployed_non_mobilised_regiments = 0;
+	for (ArmyInstance const* army : armies) {
+		for (RegimentInstance const* regiment : army->get_units()) {
+			if (!regiment->is_mobilised()) {
+				deployed_non_mobilised_regiments++;
+			}
+		}
+	}
+
+	max_supported_regiment_count = 0;
+	for (State const* state : states) {
+		max_supported_regiment_count += state->get_max_supported_regiments();
+	}
+
+	// TODO - apply country/tech modifiers to supply consumption
+	supply_consumption = 1;
+
+	const size_t regular_army_size = std::min(4 * deployed_non_mobilised_regiments, max_supported_regiment_count);
+
+	fixed_point_t sum_of_regiment_type_stats = 0;
+	for (RegimentType const& regiment_type : unit_type_manager.get_regiment_types()) {
+		// TODO - apply country/tech modifiers to regiment stats
+		sum_of_regiment_type_stats += (
+			regiment_type.get_attack() + regiment_type.get_defence() /*+ land_attack_modifier + land_defense_modifier*/
+		) * regiment_type.get_discipline();
+	}
+
+	military_power_from_land = supply_consumption * fixed_point_t::parse(regular_army_size) * sum_of_regiment_type_stats
+		/ fixed_point_t::parse(7 * (1 + unit_type_manager.get_regiment_type_count()));
+
+	if (disarmed) {
+		military_power_from_land *= define_manager.get_disarmed_penalty();
+	}
+
+	military_power_from_sea = 0;
+	for (NavyInstance const* navy : navies) {
+		for (ShipInstance const* ship : navy->get_units()) {
+			ShipType const& ship_type = ship->get_unit_type();
+
+			if (ship_type.is_capital()) {
+
+				// TODO - include gun power and hull modifiers + naval attack and defense modifiers
+
+				military_power_from_sea += (ship_type.get_gun_power() /*+ naval_attack_modifier*/)
+					* (ship_type.get_hull() /* + naval_defense_modifier*/);
+			}
+		}
+	}
+	military_power_from_sea /= 250;
+
+	military_power_from_leaders = fixed_point_t::parse(
+		std::min(generals.size() + admirals.size(), deployed_non_mobilised_regiments)
+	);
+
+	military_power = military_power_from_land + military_power_from_sea + military_power_from_leaders;
+
+	// Mobilisation calculations
+	mobilisation_impact = 0; // TODO - apply ruling party's war policy
+
+	mobilisation_max_regiment_count =
+		((fixed_point_t::_1() + mobilisation_impact) * fixed_point_t::parse(regiment_count)).to_int64_t();
+
+	mobilisation_potential_regiment_count = 0; // TODO - calculate max regiments from poor citizens
+	if (mobilisation_potential_regiment_count > mobilisation_max_regiment_count) {
+		mobilisation_potential_regiment_count = mobilisation_max_regiment_count;
+	}
+
+	// TODO - update max_ship_supply, leadership_points, war_exhaustion
 }
 
-void CountryInstance::update_gamestate() {
+void CountryInstance::update_gamestate(DefineManager const& define_manager, UnitTypeManager const& unit_type_manager) {
+	// Order of updates might need to be changed/functions split up to account for dependencies
+	_update_production(define_manager);
+	_update_budget();
+	_update_technology();
+	_update_politics();
+	_update_population();
+	_update_trade();
+	_update_diplomacy();
+	_update_military(define_manager, unit_type_manager);
+
+	total_score = prestige + industrial_power + military_power;
+
 	if (country_definition != nullptr) {
 		const CountryDefinition::government_colour_map_t::const_iterator it =
 			country_definition->get_alternative_colours().find(government_type);
@@ -405,22 +618,129 @@ void CountryInstance::update_gamestate() {
 	} else {
 		flag_government_type = nullptr;
 	}
-
-	// Order of updates might need to be changed/functions split up to account for dependencies
-	_update_production();
-	_update_budget();
-	_update_technology();
-	_update_politics();
-	_update_population();
-	_update_trade();
-	_update_diplomacy();
-	_update_military();
 }
 
 void CountryInstance::tick() {
 
 }
 
+void CountryInstanceManager::update_rankings(Date today, DefineManager const& define_manager) {
+	total_ranking.clear();
+
+	for (CountryInstance& country : country_instances.get_items()) {
+		if (country.exists()) {
+			total_ranking.push_back(&country);
+		}
+	}
+
+	prestige_ranking = total_ranking;
+	industrial_power_ranking = total_ranking;
+	military_power_ranking = total_ranking;
+
+	std::sort(
+		total_ranking.begin(), total_ranking.end(),
+		[](CountryInstance const* a, CountryInstance const* b) -> bool {
+			const bool a_civilised = a->is_civilised();
+			const bool b_civilised = b->is_civilised();
+			return a_civilised != b_civilised ? a_civilised : a->get_total_score() > b->get_total_score();
+		}
+	);
+	std::sort(
+		prestige_ranking.begin(), prestige_ranking.end(),
+		[](CountryInstance const* a, CountryInstance const* b) -> bool {
+			return a->get_prestige() > b->get_prestige();
+		}
+	);
+	std::sort(
+		industrial_power_ranking.begin(), industrial_power_ranking.end(),
+		[](CountryInstance const* a, CountryInstance const* b) -> bool {
+			return a->get_industrial_power() > b->get_industrial_power();
+		}
+	);
+	std::sort(
+		military_power_ranking.begin(), military_power_ranking.end(),
+		[](CountryInstance const* a, CountryInstance const* b) -> bool {
+			return a->get_military_power() > b->get_military_power();
+		}
+	);
+
+	for (size_t index = 0; index < total_ranking.size(); ++index) {
+		const size_t rank = index + 1;
+		total_ranking[index]->total_rank = rank;
+		prestige_ranking[index]->prestige_rank = rank;
+		industrial_power_ranking[index]->industrial_rank = rank;
+		military_power_ranking[index]->military_rank = rank;
+	}
+
+	const size_t max_great_power_rank = define_manager.get_great_power_rank();
+	const size_t max_secondary_power_rank = define_manager.get_secondary_power_rank();
+	const Timespan lose_great_power_grace_days = define_manager.get_lose_great_power_grace_days();
+
+	// Demote great powers who have been below the max great power rank for longer than the demotion grace period and
+	// remove them from the list. We don't just demote them all and clear the list as when rebuilding we'd need to look
+	// ahead for countries below the max great power rank but still within the demotion grace period.
+	for (CountryInstance* great_power : great_powers) {
+		if (great_power->get_total_rank() > max_great_power_rank && great_power->get_lose_great_power_date() < today) {
+			great_power->country_status = COUNTRY_STATUS_CIVILISED;
+		}
+	}
+	std::erase_if(great_powers, [](CountryInstance const* country) -> bool {
+		return country->get_country_status() != COUNTRY_STATUS_GREAT_POWER;
+	});
+
+	// Demote all secondary powers and clear the list. We will rebuilt the whole list from scratch, so there's no need to
+	// keep countries which are still above the max secondary power rank (they might become great powers instead anyway).
+	for (CountryInstance* secondary_power : secondary_powers) {
+		secondary_power->country_status = COUNTRY_STATUS_CIVILISED;
+	}
+	secondary_powers.clear();
+
+	// Calculate the maximum number of countries eligible for great or secondary power status. This accounts for the
+	// possibility of the max secondary power rank being higher than the max great power rank or both being zero, just
+	// in case someone wants to experiment with only having secondary powers when some great power slots are filled by
+	// countries in the demotion grace period, or having no great or secondary powers at all.
+	const size_t max_power_index = std::clamp(max_secondary_power_rank, max_great_power_rank, total_ranking.size());
+
+	for (size_t index = 0; index < max_power_index; index++) {
+		CountryInstance* country = total_ranking[index];
+
+		if (!country->is_civilised()) {
+			// All further countries are civilised and so ineligible for great or secondary power status.
+			break;
+		}
+
+		if (country->is_great_power()) {
+			// The country already has great power status and is in the great powers list.
+			continue;
+		}
+
+		if (great_powers.size() < max_great_power_rank && country->get_total_rank() <= max_great_power_rank) {
+			// The country is eligible for great power status and there are still slots available,
+			// so it is promoted and added to the list.
+			country->country_status = COUNTRY_STATUS_GREAT_POWER;
+			great_powers.push_back(country);
+		} else if (country->get_total_rank() <= max_secondary_power_rank) {
+			// The country is eligible for secondary power status and so is promoted and added to the list.
+			country->country_status = COUNTRY_STATUS_SECONDARY_POWER;
+			secondary_powers.push_back(country);
+		}
+	}
+
+	// Sort the great powers list by total rank, as pre-existing great powers may have changed rank order and new great
+	// powers will have beeen added to the end of the list regardless of rank.
+	std::sort(great_powers.begin(), great_powers.end(), [](CountryInstance const* a, CountryInstance const* b) -> bool {
+		return a->get_total_rank() < b->get_total_rank();
+	});
+
+	// Update the lose great power date for all great powers which are above the max great power rank.
+	const Date new_lose_great_power_date = today + lose_great_power_grace_days;
+	for (CountryInstance* great_power : great_powers) {
+		if (great_power->get_total_rank() <= max_great_power_rank) {
+			great_power->lose_great_power_date = new_lose_great_power_date;
+		}
+	}
+}
+
 CountryInstance& CountryInstanceManager::get_country_instance_from_definition(CountryDefinition const& country) {
 	return country_instances.get_items()[country.get_index()];
 }
@@ -435,13 +755,16 @@ bool CountryInstanceManager::generate_country_instances(
 	decltype(CountryInstance::inventions)::keys_t const& invention_keys,
 	decltype(CountryInstance::upper_house)::keys_t const& ideology_keys,
 	decltype(CountryInstance::government_flag_overrides)::keys_t const& government_type_keys,
-	decltype(CountryInstance::pop_type_distribution)::keys_t const& pop_type_keys
+	decltype(CountryInstance::pop_type_distribution)::keys_t const& pop_type_keys,
+	decltype(CountryInstance::unlocked_regiment_types)::keys_t const& unlocked_regiment_types_keys,
+	decltype(CountryInstance::unlocked_ship_types)::keys_t const& unlocked_ship_types_keys
 ) {
 	reserve_more(country_instances, country_definition_manager.get_country_definition_count());
 
 	for (CountryDefinition const& country_definition : country_definition_manager.get_country_definitions()) {
 		country_instances.add_item({
-			&country_definition, technology_keys, invention_keys, ideology_keys, government_type_keys, pop_type_keys
+			&country_definition, technology_keys, invention_keys, ideology_keys, government_type_keys, pop_type_keys,
+			unlocked_regiment_types_keys, unlocked_ship_types_keys
 		});
 	}
 
@@ -462,11 +785,16 @@ bool CountryInstanceManager::apply_history_to_countries(
 			if (history_map != nullptr) {
 				CountryHistoryEntry const* oob_history_entry = nullptr;
 
-				for (CountryHistoryEntry const* entry : history_map->get_entries_up_to(date)) {
-					ret &= country_instance.apply_history_to_country(entry, map_instance);
+				for (auto const& [entry_date, entry] : history_map->get_entries()) {
+					if (entry_date <= date) {
+						ret &= country_instance.apply_history_to_country(*entry, map_instance, *this);
 
-					if (entry->get_inital_oob()) {
-						oob_history_entry = entry;
+						if (entry->get_inital_oob()) {
+							oob_history_entry = entry.get();
+						}
+					} else {
+						// All foreign investments are applied regardless of the bookmark's date
+						country_instance.apply_foreign_investments(entry->get_foreign_investment(), *this);
 					}
 				}
 
@@ -485,10 +813,14 @@ bool CountryInstanceManager::apply_history_to_countries(
 	return ret;
 }
 
-void CountryInstanceManager::update_gamestate() {
+void CountryInstanceManager::update_gamestate(
+	Date today, DefineManager const& define_manager, UnitTypeManager const& unit_type_manager
+) {
 	for (CountryInstance& country : country_instances.get_items()) {
-		country.update_gamestate();
+		country.update_gamestate(define_manager, unit_type_manager);
 	}
+
+	update_rankings(today, define_manager);
 }
 
 void CountryInstanceManager::tick() {