tmp

Author: Hop311

src/headless/main.cpp

@@ -172,16 +172,99 @@ static bool run_headless(Dataloader::path_vector_t const& roots, bool run_tests)
 
 	Logger::info("National value of ", country.get_identifier(), " is ", country.get_national_value());
 
+	// IssueManager const& issue_manager = game_manager.get_definition_manager().get_politics_manager().get_issue_manager();
+
+	// size_t reform_type_count = 0, reform_group_count = 0, reform_count = 0;
+
+	// for (ReformType const& reform_type : issue_manager.get_reform_types()) {
+	// 	Logger::info("ReformType #", reform_type_count, " = ", reform_type);
+	// 	reform_type_count++;
+	// 	for (ReformGroup const* reform_group : reform_type.get_reform_groups()) {
+	// 		Logger::info("ReformGroup #", reform_group_count, " = ", reform_group);
+	// 		reform_group_count++;
+	// 		for (Reform const* reform : reform_group->get_reforms()) {
+	// 			Logger::info("Reform #", reform_count, " = ", reform);
+	// 			reform_count++;
+	// 		}
+	// 	}
+	// }
+	// Logger::info("Official reform type count = ", issue_manager.get_reform_type_count(), ", reform group count = ", issue_manager.get_reform_group_count(), ", reform count = ", issue_manager.get_reform_count());
+	// Logger::info("Un-official reform type count = ", reform_type_count, ", reform group count = ", reform_group_count, ", reform count = ", reform_count);
+
 	return ret;
 }
 
 /*
 	$ program [-h] [-t] [-b] [path]+
 */
 
+// #define PT(x) Logger::info("pre PT"); Logger::info(#x " = ", (x));
+// #define PD(x) PT((x).get_timespan()); Logger::info("pre PD"); Logger::info(#x " = ", (x));
+
+// #define ACT(x) Logger::info(#x); x;
+
 int main(int argc, char const* argv[]) {
 	Logger::set_logger_funcs();
 
+	// static constexpr Timespan RECENT_TIME_LIMIT = Timespan::from_years(5);
+
+	// PT(RECENT_TIME_LIMIT)
+
+	// ACT(Date last_war_loss_date);
+	// ACT(Date today);
+
+	// auto test_dates = [&today, &last_war_loss_date]() -> void {
+	// 	Logger::info("", last_war_loss_date + 1);
+	// 	PD(last_war_loss_date)
+	// 	PD(today)
+	// 	Logger::info("diff = ", today - last_war_loss_date, ", diff < limit = ", (today - last_war_loss_date) < RECENT_TIME_LIMIT ? "yes" : "no", "\n");
+	// };
+
+	// test_dates();
+
+	// ACT(today += RECENT_TIME_LIMIT);
+
+	// test_dates();
+
+	// ACT(last_war_loss_date++);
+
+	// test_dates();
+
+	// ACT(last_war_loss_date -= 2);
+
+	// test_dates();
+
+	// ACT(today = {}; last_war_loss_date = Date {}; last_war_loss_date -= RECENT_TIME_LIMIT);
+
+	// test_dates();
+
+	// ACT(last_war_loss_date++);
+
+	// test_dates();
+
+	// ACT(last_war_loss_date -= 2);
+
+	// test_dates();
+
+	// // PD(Date {} - RECENT_TIME_LIMIT);
+	// ACT(Date test = Date {} - RECENT_TIME_LIMIT);
+	// PD(test);
+
+	// auto x = Date {} - RECENT_TIME_LIMIT;
+	// // PD(x);
+
+	// Logger::info("\n\n ===== END PROGRAM =====\n\n");
+
+	// for (int i = 0; i < 100; ++i) {
+	// 	Date d = -i;
+	// 	Logger::info(
+	// 		"i = ", i, ", d = ", d, ", raw d = ", d.get_timespan(), ", components = ",
+	// 		static_cast<int32_t>(d.get_year()), ".", static_cast<int32_t>(d.get_month()), ".", static_cast<int32_t>(d.get_day())
+	// 	);
+	// }
+
+	// return 0;
+
 	char const* program_name = StringUtils::get_filename(argc > 0 ? argv[0] : nullptr, "<program>");
 	fs::path root;
 	bool run_tests = false;

src/openvic-simulation/country/CountryInstance.cpp

@@ -1420,7 +1420,15 @@ fixed_point_t CountryInstance::get_modifier_effect_value(ModifierEffect const& e
 }
 
 void CountryInstance::update_gamestate(InstanceManager& instance_manager) {
-	if (!is_civilised()) {
+	DefinitionManager const& definition_manager = instance_manager.get_definition_manager();
+	DefineManager const& define_manager = definition_manager.get_define_manager();
+	ModifierEffectCache const& modifier_effect_cache = definition_manager.get_modifier_manager().get_modifier_effect_cache();
+
+	if (is_civilised()) {
+		civilisation_progress = fixed_point_t::_0();
+	} else {
+		civilisation_progress = get_modifier_effect_value(*modifier_effect_cache.get_civilization_progress_modifier());
+
 		if (civilisation_progress <= PRIMITIVE_CIVILISATION_PROGRESS) {
 			country_status = COUNTRY_STATUS_PRIMITIVE;
 		} else if (civilisation_progress <= UNCIVILISED_CIVILISATION_PROGRESS) {
@@ -1449,10 +1457,6 @@ void CountryInstance::update_gamestate(InstanceManager& instance_manager) {
 		}
 	}
 
-	DefinitionManager const& definition_manager = instance_manager.get_definition_manager();
-	DefineManager const& define_manager = definition_manager.get_define_manager();
-	ModifierEffectCache const& modifier_effect_cache = definition_manager.get_modifier_manager().get_modifier_effect_cache();
-
 	// Order of updates might need to be changed/functions split up to account for dependencies
 	// Updates population stats (including research and leadership points from pops)
 	_update_population();
@@ -1499,7 +1503,7 @@ void CountryInstance::country_reset_before_tick() {
 	for (auto pair : goods_data) {
 		pair.second.clear_daily_recorded_data();
 	}
-	
+
 	taxable_income_by_pop_type.fill(fixed_point_t::_0());
 }
 
@@ -1704,19 +1708,26 @@ void CountryInstanceManager::update_rankings(Date today, DefineManager const& de
 	// 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, [max_great_power_rank, today](CountryInstance* great_power) -> bool {
+		if (OV_likely(great_power->get_country_status() == COUNTRY_STATUS_GREAT_POWER)) {
+			if (OV_unlikely(
+				great_power->get_total_rank() > max_great_power_rank && great_power->get_lose_great_power_date() < today
+			)) {
+				great_power->country_status = COUNTRY_STATUS_CIVILISED;
+				return true;
+			} else {
+				return false;
+			}
 		}
-	}
-	std::erase_if(great_powers, [](CountryInstance const* country) -> bool {
-		return country->get_country_status() != COUNTRY_STATUS_GREAT_POWER;
+		return true;
 	});
 
 	// 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;
+		if (secondary_power->country_status == COUNTRY_STATUS_SECONDARY_POWER) {
+			secondary_power->country_status = COUNTRY_STATUS_CIVILISED;
+		}
 	}
 	secondary_powers.clear();
 
@@ -1845,7 +1856,11 @@ bool CountryInstanceManager::apply_history_to_countries(InstanceManager& instanc
 	UnitInstanceManager& unit_instance_manager = instance_manager.get_unit_instance_manager();
 	MapInstance& map_instance = instance_manager.get_map_instance();
 
+	const Date starting_last_war_loss_date = today - RECENT_TIME_LIMIT;
+
 	for (CountryInstance& country_instance : country_instances.get_items()) {
+		country_instance.last_war_loss_date = starting_last_war_loss_date;
+
 		if (!country_instance.get_country_definition()->is_dynamic_tag()) {
 			CountryHistoryMap const* history_map =
 				history_manager.get_country_history(country_instance.get_country_definition());
@@ -1931,6 +1946,10 @@ void CountryInstanceManager::update_gamestate(InstanceManager& instance_manager)
 		country.update_gamestate(instance_manager);
 	}
 
+	// TODO - work out how to have ranking effects applied (e.g. static modifiers) applied at game start
+	// we can't just move update_rankings to the top of this function as it will choose initial GPs based on
+	// incomplete scores. Although we should check if the base game includes all info or if it really does choose
+	// starting GPs based purely on stuff like prestige which is set by history before the first game update.
 	update_rankings(instance_manager.get_today(), instance_manager.get_definition_manager().get_define_manager());
 }
 

src/openvic-simulation/country/CountryInstance.hpp

@@ -239,6 +239,9 @@ namespace OpenVic {
 		fixed_point_t PROPERTY(prestige);
 		size_t PROPERTY(prestige_rank, 0);
 		fixed_point_t PROPERTY(diplomatic_points);
+		// The last time this country lost a war, i.e. accepted a peace offer sent from their offer tab or the enemy's demand
+		// tab, even white peace. Used for the "has_recently_lost_war" condition (true if the date is less than 5 years ago).
+		Date PROPERTY(last_war_loss_date);
 		// TODO - colonial power, current wars
 
 		/* Military */

src/openvic-simulation/politics/PoliticsInstanceManager.cpp

@@ -44,3 +44,19 @@ void PoliticsInstanceManager::unlock_ideology(Ideology const& ideology) {
 		);
 	}
 }
+
+void PoliticsInstanceManager::set_great_wars_enabled(bool enabled) {
+	// if (enabled && !great_wars_enabled) {
+		// TODO - trigger "Great Wars discovered!" popup
+	// }
+
+	great_wars_enabled = enabled;
+}
+
+void PoliticsInstanceManager::set_world_wars_enabled(bool enabled) {
+	if (enabled) {
+		set_great_wars_enabled(true);
+	}
+
+	world_wars_enabled = enabled;
+}

src/openvic-simulation/politics/PoliticsInstanceManager.hpp

@@ -18,6 +18,9 @@ namespace OpenVic {
 
 		IndexedMap<Ideology, std::optional<Date>> PROPERTY(ideology_spawn_date);
 
+		bool PROPERTY(great_wars_enabled, false);
+		bool PROPERTY(world_wars_enabled, false);
+
 	public:
 		PoliticsInstanceManager(InstanceManager const& new_instance_manager);
 		PoliticsInstanceManager(PoliticsInstanceManager&&) = default;
@@ -27,5 +30,9 @@ namespace OpenVic {
 		std::optional<Date> const& get_ideology_spawn_date(Ideology const& ideology) const;
 		bool is_ideology_unlocked(Ideology const& ideology) const;
 		void unlock_ideology(Ideology const& ideology);
+
+		// Enabling world wars automatically enables great wars too, although the same doesn't apply to disabling them
+		void set_great_wars_enabled(bool enabled);
+		void set_world_wars_enabled(bool enabled);
 	};
 }