Condition scripts

src/headless/main.cpp

@@ -90,45 +90,78 @@ static bool run_headless(Dataloader::path_vector_t const& roots, bool run_tests)
 	ret &= game_manager.update_clock();
 
 	// TODO - REMOVE TEST CODE
-	Logger::info("===== Ranking system test... =====");
-	if (game_manager.get_instance_manager()) {
-		const auto print_ranking_list = [](std::string_view title, std::vector<CountryInstance*> const& countries) -> void {
-			std::string text;
-			for (CountryInstance const* country : countries) {
-				text += StringUtils::append_string_views(
-					"\n    ", country->get_identifier(),
-					" - Total #", std::to_string(country->get_total_rank()), " (", country->get_total_score().to_string(1),
-					"), Prestige #", std::to_string(country->get_prestige_rank()), " (", country->get_prestige().to_string(1),
-					"), Industry #", std::to_string(country->get_industrial_rank()), " (", country->get_industrial_power().to_string(1),
-					"), Military #", std::to_string(country->get_military_rank()), " (", country->get_military_power().to_string(1), ")"
-				);
-			}
-			Logger::info(title, ":", text);
-		};
-
-		CountryInstanceManager const& country_instance_manager =
-			game_manager.get_instance_manager()->get_country_instance_manager();
-
-		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;
+	// Logger::info("===== Ranking system test... =====");
+	// if (game_manager.get_instance_manager()) {
+	// 	const auto print_ranking_list = [](std::string_view title, std::vector<CountryInstance*> const& countries) -> void {
+	// 		std::string text;
+	// 		for (CountryInstance const* country : countries) {
+	// 			text += StringUtils::append_string_views(
+	// 				"\n    ", country->get_identifier(),
+	// 				" - Total #", std::to_string(country->get_total_rank()), " (", country->get_total_score().to_string(1),
+	// 				"), Prestige #", std::to_string(country->get_prestige_rank()), " (", country->get_prestige().to_string(1),
+	// 				"), Industry #", std::to_string(country->get_industrial_rank()), " (", country->get_industrial_power().to_string(1),
+	// 				"), Military #", std::to_string(country->get_military_rank()), " (", country->get_military_power().to_string(1), ")"
+	// 			);
+	// 		}
+	// 		Logger::info(title, ":", text);
+	// 	};
+
+	// 	CountryInstanceManager const& country_instance_manager =
+	// 		game_manager.get_instance_manager()->get_country_instance_manager();
+
+	// 	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;
+	// }
+
+	Pop const& pop = *game_manager.get_instance_manager()->get_map_instance().get_province_instance_by_index(300)->get_pops().begin();
+
+	Logger::info(
+		"Pop has type ", pop.get_type()->get_identifier(),
+		", size ", pop.get_size(),
+		", culture ", pop.get_culture().get_identifier(),
+		", religion ", pop.get_religion().get_identifier(),
+		", ideology:"
+	);
+	for (auto [ideology, support] : pop.get_ideology_distribution()) {
+		Logger::info("    ", ideology.get_identifier(), " - ", support);
 	}
 
+	ProvinceInstance const& province = *pop.get_location();
+	Logger::info("Province ", province.get_identifier(), " has ", province.get_total_population(), " pops with ideology:");
+	for (auto [ideology, support] : province.get_ideology_distribution()) {
+		Logger::info("    ", ideology.get_identifier(), " - ", support);
+	}
+
+	State const& state = *province.get_state();
+	Logger::info("State ", state.get_identifier(), " has ", state.get_total_population(), " pops with ideology:");
+	for (auto [ideology, support] : state.get_ideology_distribution()) {
+		Logger::info("    ", ideology.get_identifier(), " - ", support);
+	}
+
+	CountryInstance const& country = *state.get_owner();
+	Logger::info("Country ", country.get_identifier(), " has ", country.get_total_population(), " pops with ideology:");
+	for (auto [ideology, support] : country.get_ideology_distribution()) {
+		Logger::info("    ", ideology.get_identifier(), " - ", support);
+	}
+
+	Logger::info("National value of ", country.get_identifier(), " is ", country.get_national_value());
+
 	return ret;
 }
 

src/openvic-simulation/InstanceManager.cpp

@@ -44,7 +44,7 @@ void InstanceManager::update_gamestate() {
 	Logger::info("Update: ", today);
 	update_modifier_sums();
 	// Update gamestate...
-	map_instance.update_gamestate(today, definition_manager.get_define_manager());
+	map_instance.update_gamestate(*this);
 	country_instance_manager.update_gamestate(*this);
 
 	gamestate_updated();
@@ -141,9 +141,7 @@ bool InstanceManager::load_bookmark(Bookmark const* new_bookmark) {
 	// It is important that province history is applied before country history as province history includes
 	// generating pops which then have stats like literacy and consciousness set by country history.
 
-	ret &= country_instance_manager.apply_history_to_countries(
-		definition_manager.get_history_manager().get_country_manager(), today, unit_instance_manager, map_instance
-	);
+	ret &= country_instance_manager.apply_history_to_countries(*this);
 
 	ret &= map_instance.get_state_manager().generate_states(
 		map_instance,
@@ -154,10 +152,7 @@ bool InstanceManager::load_bookmark(Bookmark const* new_bookmark) {
 
 	if (ret) {
 		update_modifier_sums();
-		map_instance.initialise_for_new_game(
-			today,
-			definition_manager.get_define_manager()
-		);
+		map_instance.initialise_for_new_game(*this);
 		market_instance.execute_orders();
 	}
 

src/openvic-simulation/country/CountryInstance.cpp

@@ -41,6 +41,7 @@ CountryInstance::CountryInstance(
 	country_definition { new_country_definition },
 	colour { ERROR_COLOUR },
 	capital { nullptr },
+	ai { true },
 	releasable_vassal { true },
 	owns_colonial_province { false },
 	country_status { COUNTRY_STATUS_UNCIVILISED },
@@ -216,6 +217,11 @@ bool CountryInstance::is_secondary_power() const {
 	return country_status == COUNTRY_STATUS_SECONDARY_POWER;
 }
 
+bool CountryInstance::is_at_war() const {
+	// TODO - implement this properly once we have wars
+	return false;
+}
+
 bool CountryInstance::is_neighbour(CountryInstance const& country) const {
 	return neighbouring_countries.contains(&country);
 }
@@ -786,9 +792,7 @@ void CountryInstance::apply_foreign_investments(
 	}
 }
 
-bool CountryInstance::apply_history_to_country(
-	CountryHistoryEntry const& entry, MapInstance& map_instance, CountryInstanceManager const& country_instance_manager
-) {
+bool CountryInstance::apply_history_to_country(CountryHistoryEntry const& entry, InstanceManager const& instance_manager) {
 	constexpr auto set_optional = []<typename T>(T& target, std::optional<T> const& source) {
 		if (source) {
 			target = *source;
@@ -812,7 +816,7 @@ bool CountryInstance::apply_history_to_country(
 	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());
+		capital = &instance_manager.get_map_instance().get_province_instance_from_definition(**entry.get_capital());
 	}
 	set_optional(government_type, entry.get_government_type());
 	set_optional(plurality, entry.get_plurality());
@@ -834,10 +838,23 @@ bool CountryInstance::apply_history_to_country(
 	for (auto const& [technology, level] : entry.get_technologies()) {
 		ret &= set_technology_unlock_level(*technology, level);
 	}
+
+	for (
+		Invention const& invention :
+			instance_manager.get_definition_manager().get_research_manager().get_invention_manager().get_inventions()
+	) {
+		if (
+			invention.get_limit().execute(instance_manager, this, this) &&
+			invention.get_chance().execute(instance_manager, this, this) > 0
+		) {
+			ret &= unlock_invention(invention);
+		}
+	}
+
 	for (auto const& [invention, activated] : entry.get_inventions()) {
 		ret &= set_invention_unlock_level(*invention, activated ? 1 : 0);
 	}
-	apply_foreign_investments(entry.get_foreign_investment(), country_instance_manager);
+	apply_foreign_investments(entry.get_foreign_investment(), instance_manager.get_country_instance_manager());
 
 	set_optional(releasable_vassal, entry.is_releasable_vassal());
 
@@ -1428,10 +1445,13 @@ bool CountryInstanceManager::generate_country_instances(
 	return ret;
 }
 
-bool CountryInstanceManager::apply_history_to_countries(
-	CountryHistoryManager const& history_manager, Date date, UnitInstanceManager& unit_instance_manager,
-	MapInstance& map_instance
-) {
+bool CountryInstanceManager::apply_history_to_countries(InstanceManager& instance_manager) {
+	CountryHistoryManager const& history_manager =
+		instance_manager.get_definition_manager().get_history_manager().get_country_manager();
+	const Date today = instance_manager.get_today();
+	UnitInstanceManager& unit_instance_manager = instance_manager.get_unit_instance_manager();
+	MapInstance& map_instance = instance_manager.get_map_instance();
+
 	bool ret = true;
 
 	for (CountryInstance& country_instance : country_instances.get_items()) {
@@ -1448,8 +1468,8 @@ bool CountryInstanceManager::apply_history_to_countries(
 				std::optional<fixed_point_t> nonstate_culture_literacy;
 
 				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_date <= today) {
+						ret &= country_instance.apply_history_to_country(*entry, instance_manager);
 
 						if (entry->get_inital_oob().has_value()) {
 							oob_history_entry = entry.get();

src/openvic-simulation/country/CountryInstance.hpp

@@ -81,6 +81,7 @@ namespace OpenVic {
 		CountryDefinition const* PROPERTY(country_definition);
 		colour_t PROPERTY(colour); // Cached to avoid searching government overrides for every province
 		ProvinceInstance const* PROPERTY(capital);
+		bool PROPERTY_CUSTOM_PREFIX(ai, is);
 		bool PROPERTY_CUSTOM_PREFIX(releasable_vassal, is);
 		bool PROPERTY(owns_colonial_province);
 
@@ -248,6 +249,7 @@ namespace OpenVic {
 		bool can_colonise() const;
 		bool is_great_power() const;
 		bool is_secondary_power() const;
+		bool is_at_war() const;
 		bool is_neighbour(CountryInstance const& country) const;
 
 		// These functions take "std::string const&" rather than "std::string_view" as they're only used with script arguments
@@ -380,9 +382,7 @@ namespace OpenVic {
 			CountryInstanceManager const& country_instance_manager
 		);
 
-		bool apply_history_to_country(
-			CountryHistoryEntry const& entry, MapInstance& map_instance, CountryInstanceManager const& country_instance_manager
-		);
+		bool apply_history_to_country(CountryHistoryEntry const& entry, InstanceManager const& instance_manager);
 
 	private:
 		void _update_production(DefineManager const& define_manager);
@@ -451,10 +451,7 @@ namespace OpenVic {
 			decltype(CountryInstance::tax_rate_by_strata):: keys_type const& strata_keys
 		);
 
-		bool apply_history_to_countries(
-			CountryHistoryManager const& history_manager, Date date, UnitInstanceManager& unit_instance_manager,
-			MapInstance& map_instance
-		);
+		bool apply_history_to_countries(InstanceManager& instance_manager);
 
 		void update_modifier_sums(Date today, StaticModifierCache const& static_modifier_cache);
 		void update_gamestate(InstanceManager& instance_manager);

src/openvic-simulation/map/MapInstance.cpp

@@ -1,6 +1,7 @@
 #include "MapInstance.hpp"
 
 #include "openvic-simulation/history/ProvinceHistory.hpp"
+#include "openvic-simulation/InstanceManager.hpp"
 #include "openvic-simulation/map/MapDefinition.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
@@ -144,12 +145,12 @@ void MapInstance::update_modifier_sums(const Date today, StaticModifierCache con
 	}
 }
 
-void MapInstance::update_gamestate(const Date today, DefineManager const& define_manager) {
+void MapInstance::update_gamestate(InstanceManager const& instance_manager) {
 	highest_province_population = 0;
 	total_map_population = 0;
 
 	for (ProvinceInstance& province : province_instances.get_items()) {
-		province.update_gamestate(today, define_manager);
+		province.update_gamestate(instance_manager);
 
 		// Update population stats
 		const pop_size_t province_population = province.get_total_population();
@@ -168,11 +169,11 @@ void MapInstance::map_tick(const Date today) {
 	}
 }
 
-void MapInstance::initialise_for_new_game(
-	const Date today,
-	DefineManager const& define_manager
-) {
-	update_gamestate(today, define_manager);
+void MapInstance::initialise_for_new_game(InstanceManager const& instance_manager) {
+	update_gamestate(instance_manager);
+
+	const Date today = instance_manager.get_today();
+
 	for (ProvinceInstance& province : province_instances.get_items()) {
 		province.initialise_rgo();
 		province.province_tick(today);

src/openvic-simulation/map/MapInstance.hpp

@@ -57,8 +57,8 @@ namespace OpenVic {
 		);
 
 		void update_modifier_sums(const Date today, StaticModifierCache const& static_modifier_cache);
-		void update_gamestate(const Date today, DefineManager const& define_manager);
+		void update_gamestate(InstanceManager const& instance_manager);
 		void map_tick(const Date today);
-		void initialise_for_new_game(const Date today, DefineManager const& define_manager);
+		void initialise_for_new_game(InstanceManager const& instance_manager);
 	};
 }

src/openvic-simulation/map/ProvinceInstance.cpp

@@ -2,9 +2,11 @@
 
 #include "openvic-simulation/country/CountryInstance.hpp"
 #include "openvic-simulation/defines/Define.hpp"
+#include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/economy/production/ProductionType.hpp"
 #include "openvic-simulation/economy/production/ResourceGatheringOperation.hpp"
 #include "openvic-simulation/history/ProvinceHistory.hpp"
+#include "openvic-simulation/InstanceManager.hpp"
 #include "openvic-simulation/map/Crime.hpp"
 #include "openvic-simulation/map/ProvinceDefinition.hpp"
 #include "openvic-simulation/map/Region.hpp"
@@ -226,7 +228,7 @@ size_t ProvinceInstance::get_pop_count() const {
 /* REQUIREMENTS:
  * MAP-65, MAP-68, MAP-70, MAP-234
  */
-void ProvinceInstance::_update_pops(DefineManager const& define_manager) {
+void ProvinceInstance::_update_pops(InstanceManager const& instance_manager) {
 	total_population = 0;
 	average_literacy = 0;
 	average_consciousness = 0;
@@ -251,7 +253,8 @@ void ProvinceInstance::_update_pops(DefineManager const& define_manager) {
 
 	max_supported_regiments = 0;
 
-	MilitaryDefines const& military_defines = define_manager.get_military_defines();
+	MilitaryDefines const& military_defines =
+		instance_manager.get_definition_manager().get_define_manager().get_military_defines();
 
 	using enum colony_status_t;
 
@@ -261,7 +264,7 @@ void ProvinceInstance::_update_pops(DefineManager const& define_manager) {
 		: is_owner_core() ? fixed_point_t::_1() : military_defines.get_pop_size_per_regiment_non_core_multiplier();
 
 	for (Pop& pop : pops) {
-		pop.update_gamestate(define_manager, owner, pop_size_per_regiment_multiplier);
+		pop.update_gamestate(instance_manager, owner, pop_size_per_regiment_multiplier);
 
 		const pop_size_t pop_size_s = pop.get_size();
 		// TODO - change casting if pop_size_t changes type
@@ -443,7 +446,7 @@ bool ProvinceInstance::convert_rgo_worker_pops_to_equivalent(ProductionType cons
 	return is_valid_operation;
 }
 
-void ProvinceInstance::update_gamestate(const Date today, DefineManager const& define_manager) {
+void ProvinceInstance::update_gamestate(InstanceManager const& instance_manager) {
 	land_regiment_count = 0;
 	for (ArmyInstance const* army : armies) {
 		land_regiment_count += army->get_unit_count();
@@ -454,10 +457,12 @@ void ProvinceInstance::update_gamestate(const Date today, DefineManager const& d
 		}
 	}
 
+	const Date today = instance_manager.get_today();
+
 	for (BuildingInstance& building : buildings.get_items()) {
 		building.update_gamestate(today);
 	}
-	_update_pops(define_manager);
+	_update_pops(instance_manager);
 }
 
 void ProvinceInstance::province_tick(const Date today) {