From 41d50b15ac978530a53ed99eea36f180e1d27b16 Mon Sep 17 00:00:00 2001 From: hop311 Date: Fri, 14 Jun 2024 23:06:19 +0100 Subject: Renamed Country to CountryDefinition --- src/openvic-simulation/DefinitionManager.hpp | 4 +- src/openvic-simulation/InstanceManager.cpp | 4 +- src/openvic-simulation/country/Country.cpp | 215 ---------------- src/openvic-simulation/country/Country.hpp | 99 -------- .../country/CountryDefinition.cpp | 215 ++++++++++++++++ .../country/CountryDefinition.hpp | 99 ++++++++ src/openvic-simulation/country/CountryInstance.cpp | 43 ++-- src/openvic-simulation/country/CountryInstance.hpp | 14 +- src/openvic-simulation/dataloader/Dataloader.cpp | 11 +- .../diplomacy/CountryRelation.cpp | 4 +- src/openvic-simulation/history/CountryHistory.cpp | 15 +- src/openvic-simulation/history/CountryHistory.hpp | 21 +- .../history/DiplomaticHistory.cpp | 270 +++++++++++---------- .../history/DiplomaticHistory.hpp | 41 ++-- src/openvic-simulation/history/ProvinceHistory.cpp | 18 +- src/openvic-simulation/history/ProvinceHistory.hpp | 10 +- src/openvic-simulation/map/MapInstance.cpp | 2 +- src/openvic-simulation/map/MapInstance.hpp | 4 +- src/openvic-simulation/map/Mapmode.cpp | 2 +- src/openvic-simulation/map/ProvinceInstance.cpp | 8 +- src/openvic-simulation/map/ProvinceInstance.hpp | 13 +- src/openvic-simulation/map/State.cpp | 5 +- src/openvic-simulation/map/State.hpp | 6 +- src/openvic-simulation/pop/Culture.cpp | 38 +-- src/openvic-simulation/pop/Culture.hpp | 25 +- src/openvic-simulation/pop/Pop.cpp | 4 +- src/openvic-simulation/pop/Pop.hpp | 2 +- src/openvic-simulation/scripts/Condition.cpp | 10 +- .../types/IdentifierRegistry.hpp | 32 +-- 29 files changed, 643 insertions(+), 591 deletions(-) delete mode 100644 src/openvic-simulation/country/Country.cpp delete mode 100644 src/openvic-simulation/country/Country.hpp create mode 100644 src/openvic-simulation/country/CountryDefinition.cpp create mode 100644 src/openvic-simulation/country/CountryDefinition.hpp diff --git a/src/openvic-simulation/DefinitionManager.hpp b/src/openvic-simulation/DefinitionManager.hpp index e2e28dc..9b5bf21 100644 --- a/src/openvic-simulation/DefinitionManager.hpp +++ b/src/openvic-simulation/DefinitionManager.hpp @@ -1,6 +1,6 @@ #pragma once -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/diplomacy/DiplomaticAction.hpp" #include "openvic-simulation/economy/EconomyManager.hpp" #include "openvic-simulation/history/HistoryManager.hpp" @@ -29,7 +29,7 @@ namespace OpenVic { HistoryManager PROPERTY_REF(history_manager); ResearchManager PROPERTY_REF(research_manager); PopManager PROPERTY_REF(pop_manager); - CountryManager PROPERTY_REF(country_manager); + CountryDefinitionManager PROPERTY_REF(country_definition_manager); CrimeManager PROPERTY_REF(crime_manager); EventManager PROPERTY_REF(event_manager); DecisionManager PROPERTY_REF(decision_manager); diff --git a/src/openvic-simulation/InstanceManager.cpp b/src/openvic-simulation/InstanceManager.cpp index 659931c..7ee5fb8 100644 --- a/src/openvic-simulation/InstanceManager.cpp +++ b/src/openvic-simulation/InstanceManager.cpp @@ -98,11 +98,11 @@ bool InstanceManager::load_bookmark(Bookmark const* new_bookmark) { // TODO - the following arguments are for generating test pop attributes definition_manager.get_politics_manager().get_ideology_manager(), definition_manager.get_politics_manager().get_issue_manager(), - *definition_manager.get_country_manager().get_country_by_identifier("ENG") + *definition_manager.get_country_definition_manager().get_country_definition_by_identifier("ENG") ); ret &= map_instance.get_state_manager().generate_states(map_instance); - ret &= country_instance_manager.generate_country_instances(definition_manager.get_country_manager()); + ret &= country_instance_manager.generate_country_instances(definition_manager.get_country_definition_manager()); ret &= country_instance_manager.apply_history_to_countries( definition_manager.get_history_manager().get_country_manager(), today, unit_instance_manager, map_instance ); diff --git a/src/openvic-simulation/country/Country.cpp b/src/openvic-simulation/country/Country.cpp deleted file mode 100644 index d21df89..0000000 --- a/src/openvic-simulation/country/Country.cpp +++ /dev/null @@ -1,215 +0,0 @@ -#include "Country.hpp" - -#include - -#include "openvic-simulation/dataloader/Dataloader.hpp" -#include "openvic-simulation/dataloader/NodeTools.hpp" -#include "openvic-simulation/DefinitionManager.hpp" -#include "openvic-simulation/politics/Government.hpp" -#include "openvic-simulation/politics/Ideology.hpp" -#include "openvic-simulation/politics/Issue.hpp" -#include "openvic-simulation/pop/Culture.hpp" -#include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include - -using namespace OpenVic; -using namespace OpenVic::NodeTools; - -CountryParty::CountryParty( - std::string_view new_identifier, Date new_start_date, Date new_end_date, Ideology const& new_ideology, - policy_map_t&& new_policies -) : HasIdentifierAndColour { new_identifier, new_ideology.get_colour(), false }, start_date { new_start_date }, - end_date { new_end_date }, ideology { new_ideology }, policies { std::move(new_policies) } {} - -Country::Country( - std::string_view new_identifier, - colour_t new_colour, - size_t new_index, - GraphicalCultureType const& new_graphical_culture, - IdentifierRegistry&& new_parties, - unit_names_map_t&& new_unit_names, - bool new_dynamic_tag, - government_colour_map_t&& new_alternative_colours, - colour_t new_primary_unit_colour, - colour_t new_secondary_unit_colour, - colour_t new_tertiary_unit_colour -) : HasIdentifierAndColour { new_identifier, new_colour, false }, - index { new_index }, - graphical_culture { new_graphical_culture }, - parties { std::move(new_parties) }, - unit_names { std::move(new_unit_names) }, - dynamic_tag { new_dynamic_tag }, - alternative_colours { std::move(new_alternative_colours) }, - primary_unit_colour { new_primary_unit_colour }, - secondary_unit_colour { new_secondary_unit_colour }, - tertiary_unit_colour { new_tertiary_unit_colour } {} - -bool CountryManager::add_country( - std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture, - IdentifierRegistry&& parties, Country::unit_names_map_t&& unit_names, bool dynamic_tag, - Country::government_colour_map_t&& alternative_colours -) { - if (identifier.empty()) { - Logger::error("Invalid country identifier - empty!"); - return false; - } - if (!valid_basic_identifier(identifier)) { - Logger::error( - "Invalid country identifier: ", identifier, " (can only contain alphanumeric characters and underscores)" - ); - return false; - } - if (graphical_culture == nullptr) { - Logger::error("Null graphical culture for country ", identifier); - return false; - } - - static constexpr colour_t default_colour = colour_t::fill_as(colour_t::max_value); - - return countries.add_item({ - identifier, colour, countries.size(), *graphical_culture, std::move(parties), std::move(unit_names), - dynamic_tag, std::move(alternative_colours), - /* Default to country colour for the chest and grey for the others. Update later if necessary. */ - colour, default_colour, default_colour - }); -} - -bool CountryManager::load_countries( - DefinitionManager const& definition_manager, Dataloader const& dataloader, ast::NodeCPtr root -) { - static constexpr std::string_view common_dir = "common/"; - bool is_dynamic = false; - - const bool ret = expect_dictionary_reserve_length( - countries, - [this, &definition_manager, &is_dynamic, &dataloader](std::string_view key, ast::NodeCPtr value) -> bool { - if (key == "dynamic_tags") { - return expect_bool([&is_dynamic](bool val) -> bool { - if (val == is_dynamic) { - Logger::warning("Redundant \"is_dynamic\", already ", val ? "true" : "false"); - } else { - if (is_dynamic) { - Logger::warning("Changing \"is_dynamic\" back to false"); - } - is_dynamic = val; - } - return true; - })(value); - } - if (expect_string( - [this, &definition_manager, is_dynamic, &dataloader, &key](std::string_view filepath) -> bool { - if (load_country_data_file( - definition_manager, key, is_dynamic, - Dataloader::parse_defines( - dataloader.lookup_file(StringUtils::append_string_views(common_dir, filepath)) - ).get_file_node() - )) { - return true; - } - Logger::error("Failed to load country data file: ", filepath); - return false; - } - )(value)) { - return true; - } - Logger::error("Failed to load country: ", key); - return false; - } - )(root); - lock_countries(); - return ret; -} - -bool CountryManager::load_country_colours(ast::NodeCPtr root){ - return countries.expect_item_dictionary([](Country& country, ast::NodeCPtr colour_node) -> bool { - return expect_dictionary_keys( - "color1", ONE_EXACTLY, expect_colour(assign_variable_callback(country.primary_unit_colour)), - "color2", ONE_EXACTLY, expect_colour(assign_variable_callback(country.secondary_unit_colour)), - "color3", ONE_EXACTLY, expect_colour(assign_variable_callback(country.tertiary_unit_colour)) - )(colour_node); - })(root); -} - -node_callback_t CountryManager::load_country_party( - PoliticsManager const& politics_manager, IdentifierRegistry& country_parties -) const { - return [&politics_manager, &country_parties](ast::NodeCPtr value) -> bool { - std::string_view party_name; - Date start_date, end_date; - Ideology const* ideology; - CountryParty::policy_map_t policies; - - bool ret = expect_dictionary_keys_and_default( - [&politics_manager, &policies, &party_name](std::string_view key, ast::NodeCPtr value) -> bool { - return politics_manager.get_issue_manager().expect_issue_group_str( - [&politics_manager, &policies, value, &party_name](IssueGroup const& group) -> bool { - if (policies.contains(&group)) { - Logger::error("Country party ", party_name, " has duplicate entry for ", group.get_identifier()); - return false; - } - return politics_manager.get_issue_manager().expect_issue_identifier( - [&policies, &group](Issue const& issue) -> bool { - if (&issue.get_group() == &group) { - return map_callback(policies, &group)(&issue); - } - // TODO - change this back to error/false once TGC no longer has this issue - Logger::warning("Invalid policy ", issue.get_identifier(), ", group is ", - issue.get_group().get_identifier(), " when ", group.get_identifier(), " was expected"); - return true; - } - )(value); - } - )(key); - }, - "name", ONE_EXACTLY, expect_string(assign_variable_callback(party_name)), - "start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start_date)), - "end_date", ONE_EXACTLY, expect_date(assign_variable_callback(end_date)), - "ideology", ONE_EXACTLY, - politics_manager.get_ideology_manager().expect_ideology_identifier(assign_variable_callback_pointer(ideology)) - )(value); - - ret &= country_parties.add_item( - { party_name, start_date, end_date, *ideology, std::move(policies) }, duplicate_warning_callback - ); - - return ret; - }; -} - -bool CountryManager::load_country_data_file( - DefinitionManager const& definition_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root -) { - colour_t colour; - GraphicalCultureType const* graphical_culture; - IdentifierRegistry parties { "country parties" }; - Country::unit_names_map_t unit_names; - Country::government_colour_map_t alternative_colours; - bool ret = expect_dictionary_keys_and_default( - [&definition_manager, &alternative_colours](std::string_view key, ast::NodeCPtr value) -> bool { - return definition_manager.get_politics_manager().get_government_type_manager().expect_government_type_str( - [&alternative_colours, value](GovernmentType const& government_type) -> bool { - return expect_colour(map_callback(alternative_colours, &government_type))(value); - } - )(key); - }, - "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), - "graphical_culture", ONE_EXACTLY, - definition_manager.get_pop_manager().get_culture_manager().expect_graphical_culture_type_identifier( - assign_variable_callback_pointer(graphical_culture) - ), - "party", ZERO_OR_MORE, load_country_party(definition_manager.get_politics_manager(), parties), - "unit_names", ZERO_OR_ONE, - definition_manager.get_military_manager().get_unit_type_manager().expect_unit_type_dictionary_reserve_length( - unit_names, - [&unit_names](UnitType const& unit, ast::NodeCPtr value) -> bool { - return name_list_callback(map_callback(unit_names, &unit))(value); - } - ) - )(root); - - ret &= add_country( - name, colour, graphical_culture, std::move(parties), std::move(unit_names), is_dynamic, std::move(alternative_colours) - ); - return ret; -} diff --git a/src/openvic-simulation/country/Country.hpp b/src/openvic-simulation/country/Country.hpp deleted file mode 100644 index 001f1ff..0000000 --- a/src/openvic-simulation/country/Country.hpp +++ /dev/null @@ -1,99 +0,0 @@ -#pragma once - -#include - -#include - -#include "openvic-simulation/dataloader/Dataloader.hpp" -#include "openvic-simulation/military/UnitType.hpp" -#include "openvic-simulation/politics/Government.hpp" -#include "openvic-simulation/politics/Ideology.hpp" -#include "openvic-simulation/politics/Issue.hpp" -#include "openvic-simulation/politics/PoliticsManager.hpp" -#include "openvic-simulation/pop/Culture.hpp" -#include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" - -namespace OpenVic { - struct DefinitionManager; - struct CountryManager; - - struct CountryParty : HasIdentifierAndColour { - friend struct CountryManager; - - using policy_map_t = ordered_map; - - private: - const Date PROPERTY(start_date); - const Date PROPERTY(end_date); - Ideology const& PROPERTY(ideology); - policy_map_t PROPERTY(policies); - - CountryParty( - std::string_view new_identifier, Date new_start_date, Date new_end_date, Ideology const& new_ideology, - policy_map_t&& new_policies - ); - - public: - CountryParty(CountryParty&&) = default; - }; - - /* Generic information about a TAG */ - struct Country : HasIdentifierAndColour { - friend struct CountryManager; - - using unit_names_map_t = ordered_map; - using government_colour_map_t = ordered_map; - - private: - const size_t PROPERTY(index); - GraphicalCultureType const& PROPERTY(graphical_culture); - /* Not const to allow elements to be moved, otherwise a copy is forced - * which causes a compile error as the copy constructor has been deleted. */ - IdentifierRegistry IDENTIFIER_REGISTRY_CUSTOM_PLURAL(party, parties); - unit_names_map_t PROPERTY(unit_names); - const bool PROPERTY_CUSTOM_PREFIX(dynamic_tag, is); - government_colour_map_t PROPERTY(alternative_colours); - colour_t PROPERTY(primary_unit_colour); - colour_t PROPERTY(secondary_unit_colour); - colour_t PROPERTY(tertiary_unit_colour); - // Unit colours not const due to being added after construction - - Country( - std::string_view new_identifier, colour_t new_colour, size_t new_index, - GraphicalCultureType const& new_graphical_culture, IdentifierRegistry&& new_parties, - unit_names_map_t&& new_unit_names, bool new_dynamic_tag, government_colour_map_t&& new_alternative_colours, - colour_t new_primary_unit_colour, colour_t new_secondary_unit_colour, colour_t new_tertiary_unit_colour - ); - - public: - Country(Country&&) = default; - - // TODO - get_colour including alternative colours - }; - - struct CountryManager { - private: - IdentifierRegistry IDENTIFIER_REGISTRY_CUSTOM_PLURAL(country, countries); - - NodeTools::node_callback_t load_country_party( - PoliticsManager const& politics_manager, IdentifierRegistry& country_parties - ) const; - - public: - bool add_country( - std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture, - IdentifierRegistry&& parties, Country::unit_names_map_t&& unit_names, bool dynamic_tag, - Country::government_colour_map_t&& alternative_colours - ); - - bool load_country_colours(ast::NodeCPtr root); - - bool load_countries(DefinitionManager const& definition_manager, Dataloader const& dataloader, ast::NodeCPtr root); - bool load_country_data_file( - DefinitionManager const& definition_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root - ); - }; -} diff --git a/src/openvic-simulation/country/CountryDefinition.cpp b/src/openvic-simulation/country/CountryDefinition.cpp new file mode 100644 index 0000000..e414e9e --- /dev/null +++ b/src/openvic-simulation/country/CountryDefinition.cpp @@ -0,0 +1,215 @@ +#include "CountryDefinition.hpp" + +#include + +#include "openvic-simulation/dataloader/Dataloader.hpp" +#include "openvic-simulation/dataloader/NodeTools.hpp" +#include "openvic-simulation/DefinitionManager.hpp" +#include "openvic-simulation/politics/Government.hpp" +#include "openvic-simulation/politics/Ideology.hpp" +#include "openvic-simulation/politics/Issue.hpp" +#include "openvic-simulation/pop/Culture.hpp" +#include "openvic-simulation/types/Colour.hpp" +#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include + +using namespace OpenVic; +using namespace OpenVic::NodeTools; + +CountryParty::CountryParty( + std::string_view new_identifier, Date new_start_date, Date new_end_date, Ideology const& new_ideology, + policy_map_t&& new_policies +) : HasIdentifierAndColour { new_identifier, new_ideology.get_colour(), false }, start_date { new_start_date }, + end_date { new_end_date }, ideology { new_ideology }, policies { std::move(new_policies) } {} + +CountryDefinition::CountryDefinition( + std::string_view new_identifier, + colour_t new_colour, + size_t new_index, + GraphicalCultureType const& new_graphical_culture, + IdentifierRegistry&& new_parties, + unit_names_map_t&& new_unit_names, + bool new_dynamic_tag, + government_colour_map_t&& new_alternative_colours, + colour_t new_primary_unit_colour, + colour_t new_secondary_unit_colour, + colour_t new_tertiary_unit_colour +) : HasIdentifierAndColour { new_identifier, new_colour, false }, + index { new_index }, + graphical_culture { new_graphical_culture }, + parties { std::move(new_parties) }, + unit_names { std::move(new_unit_names) }, + dynamic_tag { new_dynamic_tag }, + alternative_colours { std::move(new_alternative_colours) }, + primary_unit_colour { new_primary_unit_colour }, + secondary_unit_colour { new_secondary_unit_colour }, + tertiary_unit_colour { new_tertiary_unit_colour } {} + +bool CountryDefinitionManager::add_country( + std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture, + IdentifierRegistry&& parties, CountryDefinition::unit_names_map_t&& unit_names, bool dynamic_tag, + CountryDefinition::government_colour_map_t&& alternative_colours +) { + if (identifier.empty()) { + Logger::error("Invalid country identifier - empty!"); + return false; + } + if (!valid_basic_identifier(identifier)) { + Logger::error( + "Invalid country identifier: ", identifier, " (can only contain alphanumeric characters and underscores)" + ); + return false; + } + if (graphical_culture == nullptr) { + Logger::error("Null graphical culture for country ", identifier); + return false; + } + + static constexpr colour_t default_colour = colour_t::fill_as(colour_t::max_value); + + return country_definitions.add_item({ + identifier, colour, get_country_definition_count(), *graphical_culture, std::move(parties), std::move(unit_names), + dynamic_tag, std::move(alternative_colours), + /* Default to country colour for the chest and grey for the others. Update later if necessary. */ + colour, default_colour, default_colour + }); +} + +bool CountryDefinitionManager::load_countries( + DefinitionManager const& definition_manager, Dataloader const& dataloader, ast::NodeCPtr root +) { + static constexpr std::string_view common_dir = "common/"; + bool is_dynamic = false; + + const bool ret = expect_dictionary_reserve_length( + country_definitions, + [this, &definition_manager, &is_dynamic, &dataloader](std::string_view key, ast::NodeCPtr value) -> bool { + if (key == "dynamic_tags") { + return expect_bool([&is_dynamic](bool val) -> bool { + if (val == is_dynamic) { + Logger::warning("Redundant \"is_dynamic\", already ", val ? "true" : "false"); + } else { + if (is_dynamic) { + Logger::warning("Changing \"is_dynamic\" back to false"); + } + is_dynamic = val; + } + return true; + })(value); + } + if (expect_string( + [this, &definition_manager, is_dynamic, &dataloader, &key](std::string_view filepath) -> bool { + if (load_country_data_file( + definition_manager, key, is_dynamic, + Dataloader::parse_defines( + dataloader.lookup_file(StringUtils::append_string_views(common_dir, filepath)) + ).get_file_node() + )) { + return true; + } + Logger::error("Failed to load country data file: ", filepath); + return false; + } + )(value)) { + return true; + } + Logger::error("Failed to load country: ", key); + return false; + } + )(root); + lock_country_definitions(); + return ret; +} + +bool CountryDefinitionManager::load_country_colours(ast::NodeCPtr root){ + return country_definitions.expect_item_dictionary([](CountryDefinition& country, ast::NodeCPtr colour_node) -> bool { + return expect_dictionary_keys( + "color1", ONE_EXACTLY, expect_colour(assign_variable_callback(country.primary_unit_colour)), + "color2", ONE_EXACTLY, expect_colour(assign_variable_callback(country.secondary_unit_colour)), + "color3", ONE_EXACTLY, expect_colour(assign_variable_callback(country.tertiary_unit_colour)) + )(colour_node); + })(root); +} + +node_callback_t CountryDefinitionManager::load_country_party( + PoliticsManager const& politics_manager, IdentifierRegistry& country_parties +) const { + return [&politics_manager, &country_parties](ast::NodeCPtr value) -> bool { + std::string_view party_name; + Date start_date, end_date; + Ideology const* ideology; + CountryParty::policy_map_t policies; + + bool ret = expect_dictionary_keys_and_default( + [&politics_manager, &policies, &party_name](std::string_view key, ast::NodeCPtr value) -> bool { + return politics_manager.get_issue_manager().expect_issue_group_str( + [&politics_manager, &policies, value, &party_name](IssueGroup const& group) -> bool { + if (policies.contains(&group)) { + Logger::error("Country party ", party_name, " has duplicate entry for ", group.get_identifier()); + return false; + } + return politics_manager.get_issue_manager().expect_issue_identifier( + [&policies, &group](Issue const& issue) -> bool { + if (&issue.get_group() == &group) { + return map_callback(policies, &group)(&issue); + } + // TODO - change this back to error/false once TGC no longer has this issue + Logger::warning("Invalid policy ", issue.get_identifier(), ", group is ", + issue.get_group().get_identifier(), " when ", group.get_identifier(), " was expected"); + return true; + } + )(value); + } + )(key); + }, + "name", ONE_EXACTLY, expect_string(assign_variable_callback(party_name)), + "start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start_date)), + "end_date", ONE_EXACTLY, expect_date(assign_variable_callback(end_date)), + "ideology", ONE_EXACTLY, + politics_manager.get_ideology_manager().expect_ideology_identifier(assign_variable_callback_pointer(ideology)) + )(value); + + ret &= country_parties.add_item( + { party_name, start_date, end_date, *ideology, std::move(policies) }, duplicate_warning_callback + ); + + return ret; + }; +} + +bool CountryDefinitionManager::load_country_data_file( + DefinitionManager const& definition_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root +) { + colour_t colour; + GraphicalCultureType const* graphical_culture; + IdentifierRegistry parties { "country parties" }; + CountryDefinition::unit_names_map_t unit_names; + CountryDefinition::government_colour_map_t alternative_colours; + bool ret = expect_dictionary_keys_and_default( + [&definition_manager, &alternative_colours](std::string_view key, ast::NodeCPtr value) -> bool { + return definition_manager.get_politics_manager().get_government_type_manager().expect_government_type_str( + [&alternative_colours, value](GovernmentType const& government_type) -> bool { + return expect_colour(map_callback(alternative_colours, &government_type))(value); + } + )(key); + }, + "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), + "graphical_culture", ONE_EXACTLY, + definition_manager.get_pop_manager().get_culture_manager().expect_graphical_culture_type_identifier( + assign_variable_callback_pointer(graphical_culture) + ), + "party", ZERO_OR_MORE, load_country_party(definition_manager.get_politics_manager(), parties), + "unit_names", ZERO_OR_ONE, + definition_manager.get_military_manager().get_unit_type_manager().expect_unit_type_dictionary_reserve_length( + unit_names, + [&unit_names](UnitType const& unit, ast::NodeCPtr value) -> bool { + return name_list_callback(map_callback(unit_names, &unit))(value); + } + ) + )(root); + + ret &= add_country( + name, colour, graphical_culture, std::move(parties), std::move(unit_names), is_dynamic, std::move(alternative_colours) + ); + return ret; +} diff --git a/src/openvic-simulation/country/CountryDefinition.hpp b/src/openvic-simulation/country/CountryDefinition.hpp new file mode 100644 index 0000000..70e62b9 --- /dev/null +++ b/src/openvic-simulation/country/CountryDefinition.hpp @@ -0,0 +1,99 @@ +#pragma once + +#include + +#include + +#include "openvic-simulation/dataloader/Dataloader.hpp" +#include "openvic-simulation/military/UnitType.hpp" +#include "openvic-simulation/politics/Government.hpp" +#include "openvic-simulation/politics/Ideology.hpp" +#include "openvic-simulation/politics/Issue.hpp" +#include "openvic-simulation/politics/PoliticsManager.hpp" +#include "openvic-simulation/pop/Culture.hpp" +#include "openvic-simulation/types/Colour.hpp" +#include "openvic-simulation/types/Date.hpp" +#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/types/OrderedContainers.hpp" + +namespace OpenVic { + struct DefinitionManager; + struct CountryDefinitionManager; + + struct CountryParty : HasIdentifierAndColour { + friend struct CountryDefinitionManager; + + using policy_map_t = ordered_map; + + private: + const Date PROPERTY(start_date); + const Date PROPERTY(end_date); + Ideology const& PROPERTY(ideology); + policy_map_t PROPERTY(policies); + + CountryParty( + std::string_view new_identifier, Date new_start_date, Date new_end_date, Ideology const& new_ideology, + policy_map_t&& new_policies + ); + + public: + CountryParty(CountryParty&&) = default; + }; + + /* Generic information about a TAG */ + struct CountryDefinition : HasIdentifierAndColour { + friend struct CountryDefinitionManager; + + using unit_names_map_t = ordered_map; + using government_colour_map_t = ordered_map; + + private: + const size_t PROPERTY(index); + GraphicalCultureType const& PROPERTY(graphical_culture); + /* Not const to allow elements to be moved, otherwise a copy is forced + * which causes a compile error as the copy constructor has been deleted. */ + IdentifierRegistry IDENTIFIER_REGISTRY_CUSTOM_PLURAL(party, parties); + unit_names_map_t PROPERTY(unit_names); + const bool PROPERTY_CUSTOM_PREFIX(dynamic_tag, is); + government_colour_map_t PROPERTY(alternative_colours); + colour_t PROPERTY(primary_unit_colour); + colour_t PROPERTY(secondary_unit_colour); + colour_t PROPERTY(tertiary_unit_colour); + // Unit colours not const due to being added after construction + + CountryDefinition( + std::string_view new_identifier, colour_t new_colour, size_t new_index, + GraphicalCultureType const& new_graphical_culture, IdentifierRegistry&& new_parties, + unit_names_map_t&& new_unit_names, bool new_dynamic_tag, government_colour_map_t&& new_alternative_colours, + colour_t new_primary_unit_colour, colour_t new_secondary_unit_colour, colour_t new_tertiary_unit_colour + ); + + public: + CountryDefinition(CountryDefinition&&) = default; + + // TODO - get_colour including alternative colours + }; + + struct CountryDefinitionManager { + private: + IdentifierRegistry IDENTIFIER_REGISTRY(country_definition); + + NodeTools::node_callback_t load_country_party( + PoliticsManager const& politics_manager, IdentifierRegistry& country_parties + ) const; + + public: + bool add_country( + std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture, + IdentifierRegistry&& parties, CountryDefinition::unit_names_map_t&& unit_names, bool dynamic_tag, + CountryDefinition::government_colour_map_t&& alternative_colours + ); + + bool load_country_colours(ast::NodeCPtr root); + + bool load_countries(DefinitionManager const& definition_manager, Dataloader const& dataloader, ast::NodeCPtr root); + bool load_country_data_file( + DefinitionManager const& definition_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root + ); + }; +} diff --git a/src/openvic-simulation/country/CountryInstance.cpp b/src/openvic-simulation/country/CountryInstance.cpp index 25f40ed..2debd8a 100644 --- a/src/openvic-simulation/country/CountryInstance.cpp +++ b/src/openvic-simulation/country/CountryInstance.cpp @@ -1,23 +1,26 @@ #include "CountryInstance.hpp" -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/history/CountryHistory.hpp" #include "openvic-simulation/military/UnitInstance.hpp" using namespace OpenVic; -CountryInstance::CountryInstance(Country const* new_base_country) - : base_country { new_base_country }, primary_culture { nullptr }, religion { nullptr }, ruling_party { nullptr }, +CountryInstance::CountryInstance(CountryDefinition const* new_country_definition) + : country_definition { new_country_definition }, primary_culture { nullptr }, religion { nullptr }, ruling_party { nullptr }, last_election {}, capital { nullptr }, government_type { nullptr }, plurality { 0 }, national_value { nullptr }, civilised { false }, prestige { 0 } {} std::string_view CountryInstance::get_identifier() const { - return base_country != nullptr ? base_country->get_identifier() : "NULL"; + return country_definition != nullptr ? country_definition->get_identifier() : "NULL"; } bool CountryInstance::add_accepted_culture(Culture const* new_accepted_culture) { if (std::find(accepted_cultures.begin(), accepted_cultures.end(), new_accepted_culture) != accepted_cultures.end()) { - Logger::warning("Attempted to add accepted culture ", new_accepted_culture->get_identifier(), " to country ", base_country->get_identifier(), ": already present!"); + Logger::warning( + "Attempted to add accepted culture ", new_accepted_culture->get_identifier(), " to country ", + country_definition->get_identifier(), ": already present!" + ); return false; } accepted_cultures.push_back(new_accepted_culture); @@ -27,7 +30,10 @@ bool CountryInstance::add_accepted_culture(Culture const* new_accepted_culture) bool CountryInstance::remove_accepted_culture(Culture const* culture_to_remove) { auto existing_entry = std::find(accepted_cultures.begin(), accepted_cultures.end(), culture_to_remove); if (existing_entry == accepted_cultures.end()) { - Logger::warning("Attempted to remove accepted culture ", culture_to_remove->get_identifier(), " from country ", base_country->get_identifier(), ": not present!"); + Logger::warning( + "Attempted to remove accepted culture ", culture_to_remove->get_identifier(), " from country ", + country_definition->get_identifier(), ": not present!" + ); return false; } accepted_cultures.erase(existing_entry); @@ -44,7 +50,10 @@ bool CountryInstance::remove_from_upper_house(Ideology const* party) { bool CountryInstance::add_reform(Reform const* new_reform) { if (std::find(reforms.begin(), reforms.end(), new_reform) != reforms.end()) { - Logger::warning("Attempted to add reform ", new_reform->get_identifier(), " to country ", base_country->get_identifier(), ": already present!"); + Logger::warning( + "Attempted to add reform ", new_reform->get_identifier(), " to country ", country_definition->get_identifier(), + ": already present!" + ); return false; } reforms.push_back(new_reform); @@ -54,7 +63,10 @@ bool CountryInstance::add_reform(Reform const* new_reform) { bool CountryInstance::remove_reform(Reform const* reform_to_remove) { auto existing_entry = std::find(reforms.begin(), reforms.end(), reform_to_remove); if (existing_entry == reforms.end()) { - Logger::warning("Attempted to remove reform ", reform_to_remove->get_identifier(), " from country ", base_country->get_identifier(), ": not present!"); + Logger::warning( + "Attempted to remove reform ", reform_to_remove->get_identifier(), " from country ", + country_definition->get_identifier(), ": not present!" + ); return false; } reforms.erase(existing_entry); @@ -98,11 +110,11 @@ bool CountryInstance::apply_history_to_country(CountryHistoryEntry const* entry) return ret; } -bool CountryInstanceManager::generate_country_instances(CountryManager const& country_manager) { - reserve_more(country_instances, country_manager.get_country_count()); +bool CountryInstanceManager::generate_country_instances(CountryDefinitionManager const& country_definition_manager) { + reserve_more(country_instances, country_definition_manager.get_country_definition_count()); - for (Country const& country : country_manager.get_countries()) { - country_instances.push_back({ &country }); + for (CountryDefinition const& country_definition : country_definition_manager.get_country_definitions()) { + country_instances.add_item({ &country_definition }); } return true; @@ -114,9 +126,10 @@ bool CountryInstanceManager::apply_history_to_countries( ) { bool ret = true; - for (CountryInstance& country_instance : country_instances) { - if (!country_instance.get_base_country()->is_dynamic_tag()) { - CountryHistoryMap const* history_map = history_manager.get_country_history(country_instance.get_base_country()); + for (CountryInstance& country_instance : country_instances.get_items()) { + if (!country_instance.get_country_definition()->is_dynamic_tag()) { + CountryHistoryMap const* history_map = + history_manager.get_country_history(country_instance.get_country_definition()); if (history_map != nullptr) { CountryHistoryEntry const* oob_history_entry = nullptr; diff --git a/src/openvic-simulation/country/CountryInstance.hpp b/src/openvic-simulation/country/CountryInstance.hpp index 68d2bb2..45924b2 100644 --- a/src/openvic-simulation/country/CountryInstance.hpp +++ b/src/openvic-simulation/country/CountryInstance.hpp @@ -4,10 +4,11 @@ #include "openvic-simulation/types/Date.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" +#include "openvic-simulation/types/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Getters.hpp" namespace OpenVic { - struct Country; + struct CountryDefinition; struct Culture; struct Religion; struct CountryParty; @@ -21,8 +22,9 @@ namespace OpenVic { /* Representation of an existing country that is currently in-game. */ struct CountryInstance { friend struct CountryInstanceManager; + private: - Country const* PROPERTY_RW(base_country); + CountryDefinition const* PROPERTY_RW(country_definition); Culture const* PROPERTY_RW(primary_culture); std::vector PROPERTY(accepted_cultures); Religion const* PROPERTY_RW(religion); @@ -40,7 +42,7 @@ namespace OpenVic { std::vector PROPERTY(reforms); // TODO: should be map of reform groups to active reforms: must set defaults & validate applied history // TODO: Military units + OOBs; will probably need an extensible deployment class - CountryInstance(Country const* new_base_country); + CountryInstance(CountryDefinition const* new_country_definition); public: std::string_view get_identifier() const; @@ -56,17 +58,17 @@ namespace OpenVic { bool apply_history_to_country(CountryHistoryEntry const* entry); }; - struct CountryManager; + struct CountryDefinitionManager; struct CountryHistoryManager; struct UnitInstanceManager; struct MapInstance; struct CountryInstanceManager { private: - std::vector PROPERTY(country_instances); + IdentifierRegistry IDENTIFIER_REGISTRY(country_instance); public: - bool generate_country_instances(CountryManager const& country_manager); + bool generate_country_instances(CountryDefinitionManager const& country_definition_manager); bool apply_history_to_countries( CountryHistoryManager const& history_manager, Date date, UnitInstanceManager& unit_instance_manager, diff --git a/src/openvic-simulation/dataloader/Dataloader.cpp b/src/openvic-simulation/dataloader/Dataloader.cpp index a927f5a..dab479f 100644 --- a/src/openvic-simulation/dataloader/Dataloader.cpp +++ b/src/openvic-simulation/dataloader/Dataloader.cpp @@ -528,7 +528,8 @@ bool Dataloader::_load_history(DefinitionManager& definition_manager, bool unuse const std::string filename = file.stem().string(); const std::string_view country_id = extract_basic_identifier_prefix(filename); - Country const* country = definition_manager.get_country_manager().get_country_by_identifier(country_id); + CountryDefinition const* country = + definition_manager.get_country_definition_manager().get_country_definition_by_identifier(country_id); if (country == nullptr) { if (unused_history_file_warnings) { Logger::warning("Found history file for non-existent country: ", country_id); @@ -628,7 +629,7 @@ bool Dataloader::_load_history(DefinitionManager& definition_manager, bool unuse lookup_files_in_dir(diplomacy_history_directory, ".txt"), [this, &definition_manager, &diplomatic_history_manager](fs::path const& file) -> bool { return diplomatic_history_manager.load_diplomacy_history_file( - definition_manager.get_country_manager(), parse_defines(file).get_file_node() + definition_manager.get_country_definition_manager(), parse_defines(file).get_file_node() ); } ); @@ -1008,20 +1009,20 @@ bool Dataloader::load_defines(DefinitionManager& definition_manager) { Logger::error("Failed to load bookmarks!"); ret = false; } - if (!definition_manager.get_country_manager().load_countries( + if (!definition_manager.get_country_definition_manager().load_countries( definition_manager, *this, parse_defines(lookup_file(countries_file)).get_file_node() )) { Logger::error("Failed to load countries!"); ret = false; } - if (!definition_manager.get_country_manager().load_country_colours( + if (!definition_manager.get_country_definition_manager().load_country_colours( parse_defines(lookup_file(country_colours_file)).get_file_node() )) { Logger::error("Failed to load country colours!"); ret = false; } if (!definition_manager.get_pop_manager().get_culture_manager().load_culture_file( - definition_manager.get_country_manager(), parse_defines(lookup_file(culture_file)).get_file_node() + definition_manager.get_country_definition_manager(), parse_defines(lookup_file(culture_file)).get_file_node() )) { Logger::error("Failed to load cultures!"); ret = false; diff --git a/src/openvic-simulation/diplomacy/CountryRelation.cpp b/src/openvic-simulation/diplomacy/CountryRelation.cpp index 2e058ab..0f97da1 100644 --- a/src/openvic-simulation/diplomacy/CountryRelation.cpp +++ b/src/openvic-simulation/diplomacy/CountryRelation.cpp @@ -2,7 +2,7 @@ #include -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/utility/ErrorMacros.hpp" @@ -11,7 +11,7 @@ using namespace OpenVic; CountryRelationInstanceProxy::CountryRelationInstanceProxy(std::string_view id) : country_id { id } {} CountryRelationInstanceProxy::CountryRelationInstanceProxy(CountryInstance const* country) - : country_id { country->get_base_country()->get_identifier() } {} + : country_id { country->get_country_definition()->get_identifier() } {} CountryRelationInstanceProxy::operator std::string_view() const { return country_id; diff --git a/src/openvic-simulation/history/CountryHistory.cpp b/src/openvic-simulation/history/CountryHistory.cpp index b316353..5eba9ee 100644 --- a/src/openvic-simulation/history/CountryHistory.cpp +++ b/src/openvic-simulation/history/CountryHistory.cpp @@ -1,14 +1,15 @@ #include "CountryHistory.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/DefinitionManager.hpp" using namespace OpenVic; using namespace OpenVic::NodeTools; -CountryHistoryEntry::CountryHistoryEntry(Country const& new_country, Date new_date) +CountryHistoryEntry::CountryHistoryEntry(CountryDefinition const& new_country, Date new_date) : HistoryEntry { new_date }, country { new_country } {} -CountryHistoryMap::CountryHistoryMap(Country const& new_country) : country { new_country } {} +CountryHistoryMap::CountryHistoryMap(CountryDefinition const& new_country) : country { new_country } {} std::unique_ptr CountryHistoryMap::_make_entry(Date date) const { return std::unique_ptr { new CountryHistoryEntry { country, date } }; @@ -21,14 +22,14 @@ bool CountryHistoryMap::_load_history_entry( PoliticsManager const& politics_manager = definition_manager.get_politics_manager(); IssueManager const& issue_manager = politics_manager.get_issue_manager(); CultureManager const& culture_manager = definition_manager.get_pop_manager().get_culture_manager(); - CountryManager const& country_manager = definition_manager.get_country_manager(); + CountryDefinitionManager const& country_definition_manager = definition_manager.get_country_definition_manager(); TechnologyManager const& technology_manager = definition_manager.get_research_manager().get_technology_manager(); InventionManager const& invention_manager = definition_manager.get_research_manager().get_invention_manager(); DecisionManager const& decision_manager = definition_manager.get_decision_manager(); return expect_dictionary_keys_and_default( [this, &definition_manager, &dataloader, &deployment_manager, &issue_manager, &technology_manager, &invention_manager, - &country_manager, &entry](std::string_view key, ast::NodeCPtr value) -> bool { + &country_definition_manager, &entry](std::string_view key, ast::NodeCPtr value) -> bool { ReformGroup const* reform_group = issue_manager.get_reform_group_by_identifier(key); if (reform_group != nullptr) { return issue_manager.expect_reform_identifier([&entry, reform_group](Reform const& reform) -> bool { @@ -109,7 +110,7 @@ bool CountryHistoryMap::_load_history_entry( assign_variable_callback_pointer_opt(entry.tech_school) ), "foreign_investment", ZERO_OR_ONE, - country_manager.expect_country_decimal_map(move_variable_callback(entry.foreign_investment)), + country_definition_manager.expect_country_definition_decimal_map(move_variable_callback(entry.foreign_investment)), "literacy", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.literacy)), "non_state_culture_literacy", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.nonstate_culture_literacy)), @@ -200,7 +201,7 @@ bool CountryHistoryManager::is_locked() const { return locked; } -CountryHistoryMap const* CountryHistoryManager::get_country_history(Country const* country) const { +CountryHistoryMap const* CountryHistoryManager::get_country_history(CountryDefinition const* country) const { if (country == nullptr) { Logger::error("Attempted to access history of null country"); return nullptr; @@ -215,7 +216,7 @@ CountryHistoryMap const* CountryHistoryManager::get_country_history(Country cons } bool CountryHistoryManager::load_country_history_file( - DefinitionManager& definition_manager, Dataloader const& dataloader, Country const& country, ast::NodeCPtr root + DefinitionManager& definition_manager, Dataloader const& dataloader, CountryDefinition const& country, ast::NodeCPtr root ) { if (locked) { Logger::error("Attempted to load country history file for ", country, " after country history registry was locked!"); diff --git a/src/openvic-simulation/history/CountryHistory.hpp b/src/openvic-simulation/history/CountryHistory.hpp index cf934f5..0de76c6 100644 --- a/src/openvic-simulation/history/CountryHistory.hpp +++ b/src/openvic-simulation/history/CountryHistory.hpp @@ -10,7 +10,7 @@ namespace OpenVic { struct CountryHistoryMap; - struct Country; + struct CountryDefinition; struct Culture; struct Religion; struct CountryParty; @@ -29,7 +29,7 @@ namespace OpenVic { friend struct CountryHistoryMap; private: - Country const& PROPERTY(country); + CountryDefinition const& PROPERTY(country); std::optional PROPERTY(primary_culture); std::vector PROPERTY(accepted_cultures); @@ -48,7 +48,7 @@ namespace OpenVic { std::optional PROPERTY(tech_school); ordered_map PROPERTY(technologies); ordered_map PROPERTY(inventions); - fixed_point_map_t PROPERTY(foreign_investment); + fixed_point_map_t PROPERTY(foreign_investment); std::optional PROPERTY(consciousness); std::optional PROPERTY(nonstate_consciousness); std::optional PROPERTY(literacy); @@ -58,9 +58,9 @@ namespace OpenVic { string_set_t PROPERTY(country_flags); string_set_t PROPERTY(global_flags); ordered_map PROPERTY(government_flag_overrides); - ordered_set decisions; + ordered_set PROPERTY(decisions); - CountryHistoryEntry(Country const& new_country, Date new_date); + CountryHistoryEntry(CountryDefinition const& new_country, Date new_date); }; class Dataloader; @@ -71,10 +71,10 @@ namespace OpenVic { friend struct CountryHistoryManager; private: - Country const& PROPERTY(country); + CountryDefinition const& PROPERTY(country); protected: - CountryHistoryMap(Country const& new_country); + CountryHistoryMap(CountryDefinition const& new_country); std::unique_ptr _make_entry(Date date) const override; bool _load_history_entry( @@ -85,7 +85,7 @@ namespace OpenVic { struct CountryHistoryManager { private: - ordered_map country_histories; + ordered_map country_histories; bool locked = false; public: @@ -95,10 +95,11 @@ namespace OpenVic { void lock_country_histories(); bool is_locked() const; - CountryHistoryMap const* get_country_history(Country const* country) const; + CountryHistoryMap const* get_country_history(CountryDefinition const* country) const; bool load_country_history_file( - DefinitionManager& definition_manager, Dataloader const& dataloader, Country const& country, ast::NodeCPtr root + DefinitionManager& definition_manager, Dataloader const& dataloader, CountryDefinition const& country, + ast::NodeCPtr root ); }; diff --git a/src/openvic-simulation/history/DiplomaticHistory.cpp b/src/openvic-simulation/history/DiplomaticHistory.cpp index c9b2379..a06c0d1 100644 --- a/src/openvic-simulation/history/DiplomaticHistory.cpp +++ b/src/openvic-simulation/history/DiplomaticHistory.cpp @@ -7,17 +7,17 @@ using namespace OpenVic::NodeTools; WarHistory::added_wargoal_t::added_wargoal_t( Date new_added, - Country const* new_actor, - Country const* new_receiver, + CountryDefinition const* new_actor, + CountryDefinition const* new_receiver, WargoalType const* new_wargoal, - std::optional new_third_party, + std::optional new_third_party, std::optional new_target ) : added { new_added }, actor { new_actor }, receiver { new_receiver }, wargoal { new_wargoal }, third_party { new_third_party }, target { new_target } {} WarHistory::war_participant_t::war_participant_t( - Country const* new_country, - const Period new_period + CountryDefinition const* new_country, + Period new_period ) : country { new_country }, period { new_period } {} WarHistory::WarHistory( @@ -29,22 +29,22 @@ WarHistory::WarHistory( wargoals { std::move(new_wargoals) } {} AllianceHistory::AllianceHistory( - Country const* new_first, - Country const* new_second, - const Period new_period + CountryDefinition const* new_first, + CountryDefinition const* new_second, + Period new_period ) : first { new_first }, second { new_second }, period { new_period } {} ReparationsHistory::ReparationsHistory( - Country const* new_receiver, - Country const* new_sender, - const Period new_period + CountryDefinition const* new_receiver, + CountryDefinition const* new_sender, + Period new_period ) : receiver { new_receiver }, sender { new_sender }, period { new_period } {} SubjectHistory::SubjectHistory( - Country const* new_overlord, - Country const* new_subject, - const type_t new_type, - const Period new_period + CountryDefinition const* new_overlord, + CountryDefinition const* new_subject, + type_t new_type, + Period new_period ) : overlord { new_overlord }, subject { new_subject }, type { new_type }, period { new_period } {} void DiplomaticHistoryManager::reserve_more_wars(size_t size) { @@ -108,19 +108,23 @@ std::vector DiplomaticHistoryManager::get_wars(Date date) con return ret; } -bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const& country_manager, ast::NodeCPtr root) { +bool DiplomaticHistoryManager::load_diplomacy_history_file( + CountryDefinitionManager const& country_definition_manager, ast::NodeCPtr root +) { return expect_dictionary_keys( - "alliance", ZERO_OR_MORE, [this, &country_manager](ast::NodeCPtr node) -> bool { - Country const* first = nullptr; - Country const* second = nullptr; + "alliance", ZERO_OR_MORE, [this, &country_definition_manager](ast::NodeCPtr node) -> bool { + CountryDefinition const* first = nullptr; + CountryDefinition const* second = nullptr; Date start {}; std::optional end {}; bool ret = expect_dictionary_keys( - "first", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(first)), - "second", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(second)), + "first", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(first) + ), + "second", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(second) + ), "start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)), "end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end)) )(node); @@ -128,17 +132,19 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const& alliances.push_back({ first, second, { start, end } }); return ret; }, - "vassal", ZERO_OR_MORE, [this, &country_manager](ast::NodeCPtr node) -> bool { - Country const* overlord = nullptr; - Country const* subject = nullptr; + "vassal", ZERO_OR_MORE, [this, &country_definition_manager](ast::NodeCPtr node) -> bool { + CountryDefinition const* overlord = nullptr; + CountryDefinition const* subject = nullptr; Date start {}; std::optional end {}; bool ret = expect_dictionary_keys( - "first", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(overlord)), - "second", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(subject)), + "first", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(overlord) + ), + "second", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(subject) + ), "start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)), "end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end)) )(node); @@ -146,17 +152,19 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const& subjects.push_back({ overlord, subject, SubjectHistory::type_t::VASSAL, { start, end } }); return ret; }, - "union", ZERO_OR_MORE, [this, &country_manager](ast::NodeCPtr node) -> bool { - Country const* overlord = nullptr; - Country const* subject = nullptr; + "union", ZERO_OR_MORE, [this, &country_definition_manager](ast::NodeCPtr node) -> bool { + CountryDefinition const* overlord = nullptr; + CountryDefinition const* subject = nullptr; Date start {}; std::optional end {}; bool ret = expect_dictionary_keys( - "first", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(overlord)), - "second", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(subject)), + "first", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(overlord) + ), + "second", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(subject) + ), "start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)), "end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end)) )(node); @@ -164,17 +172,19 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const& subjects.push_back({ overlord, subject, SubjectHistory::type_t::UNION, { start, end } }); return ret; }, - "substate", ZERO_OR_MORE, [this, &country_manager](ast::NodeCPtr node) -> bool { - Country const* overlord = nullptr; - Country const* subject = nullptr; + "substate", ZERO_OR_MORE, [this, &country_definition_manager](ast::NodeCPtr node) -> bool { + CountryDefinition const* overlord = nullptr; + CountryDefinition const* subject = nullptr; Date start {}; std::optional end {}; bool ret = expect_dictionary_keys( - "first", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(overlord)), - "second", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(subject)), + "first", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(overlord) + ), + "second", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(subject) + ), "start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)), "end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end)) )(node); @@ -182,17 +192,19 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const& subjects.push_back({ overlord, subject, SubjectHistory::type_t::SUBSTATE, { start, end } }); return ret; }, - "reparations", ZERO_OR_MORE, [this, &country_manager](ast::NodeCPtr node) -> bool { - Country const* receiver = nullptr; - Country const* sender = nullptr; + "reparations", ZERO_OR_MORE, [this, &country_definition_manager](ast::NodeCPtr node) -> bool { + CountryDefinition const* receiver = nullptr; + CountryDefinition const* sender = nullptr; Date start {}; std::optional end {}; bool ret = expect_dictionary_keys( - "first", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(receiver)), - "second", ONE_EXACTLY, - country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(sender)), + "first", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(receiver) + ), + "second", ONE_EXACTLY, country_definition_manager.expect_country_definition_identifier_or_string( + assign_variable_callback_pointer(sender) + ), "start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)), "end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end)) )(node); @@ -217,111 +229,115 @@ bool DiplomaticHistoryManager::load_war_history_file(DefinitionManager const& de bool ret = expect_date_str(assign_variable_callback(current_date))(key); ret &= expect_dictionary_keys( - "add_attacker", ZERO_OR_MORE, definition_manager.get_country_manager().expect_country_identifier( - [&attackers, ¤t_date, &name](Country const& country) -> bool { - for (auto const& attacker : attackers) { - if (attacker.get_country() == &country) { - Logger::error( - "In history of war ", name, " at date ", current_date.to_string(), - ": Attempted to add attacking country ", attacker.get_country()->get_identifier(), - " which is already present!" - ); - return false; + "add_attacker", ZERO_OR_MORE, + definition_manager.get_country_definition_manager().expect_country_definition_identifier( + [&attackers, ¤t_date, &name](CountryDefinition const& country) -> bool { + for (auto const& attacker : attackers) { + if (attacker.get_country() == &country) { + Logger::error( + "In history of war ", name, " at date ", current_date.to_string(), + ": Attempted to add attacking country ", attacker.get_country()->get_identifier(), + " which is already present!" + ); + return false; + } } - } - attackers.push_back({ &country, { current_date, {} } }); - return true; - } - ), - "add_defender", ZERO_OR_MORE, definition_manager.get_country_manager().expect_country_identifier( - [&defenders, ¤t_date, &name](Country const& country) -> bool { - for (auto const& defender : defenders) { - if (defender.get_country() == &country) { - Logger::error( - "In history of war ", name, " at date ", current_date.to_string(), - ": Attempted to add defending country ", defender.get_country()->get_identifier(), - " which is already present!" - ); - return false; - } + attackers.push_back({ &country, { current_date, {} } }); + return true; } - - defenders.push_back({ &country, { current_date, {} } }); - return true; - } - ), - "rem_attacker", ZERO_OR_MORE, definition_manager.get_country_manager().expect_country_identifier( - [&attackers, ¤t_date, &name](Country const& country) -> bool { - WarHistory::war_participant_t* participant_to_remove = nullptr; - - for (auto& attacker : attackers) { - if (attacker.country == &country) { - participant_to_remove = &attacker; - break; + ), + "add_defender", ZERO_OR_MORE, + definition_manager.get_country_definition_manager().expect_country_definition_identifier( + [&defenders, ¤t_date, &name](CountryDefinition const& country) -> bool { + for (auto const& defender : defenders) { + if (defender.get_country() == &country) { + Logger::error( + "In history of war ", name, " at date ", current_date.to_string(), + ": Attempted to add defending country ", defender.get_country()->get_identifier(), + " which is already present!" + ); + return false; + } } - } - if (participant_to_remove == nullptr) { - Logger::warning( - "In history of war ", name, " at date ", current_date.to_string(), - ": Attempted to remove attacking country ", country.get_identifier(), - " which was not present!" - ); + defenders.push_back({ &country, { current_date, {} } }); return true; } + ), + "rem_attacker", ZERO_OR_MORE, + definition_manager.get_country_definition_manager().expect_country_definition_identifier( + [&attackers, ¤t_date, &name](CountryDefinition const& country) -> bool { + WarHistory::war_participant_t* participant_to_remove = nullptr; + + for (auto& attacker : attackers) { + if (attacker.country == &country) { + participant_to_remove = &attacker; + break; + } + } - return participant_to_remove->period.try_set_end(current_date); - } - ), - "rem_defender", ZERO_OR_MORE, definition_manager.get_country_manager().expect_country_identifier( - [&defenders, ¤t_date, &name](Country const& country) -> bool { - WarHistory::war_participant_t* participant_to_remove = nullptr; - - for (auto& defender : defenders) { - if (defender.country == &country) { - participant_to_remove = &defender; - break; + if (participant_to_remove == nullptr) { + Logger::warning( + "In history of war ", name, " at date ", current_date.to_string(), + ": Attempted to remove attacking country ", country.get_identifier(), + " which was not present!" + ); + return true; } - } - if (participant_to_remove == nullptr) { - Logger::warning( - "In history of war ", name, " at date ", current_date.to_string(), - ": Attempted to remove attacking country ", country.get_identifier(), - " which was not present!" - ); - return true; + return participant_to_remove->period.try_set_end(current_date); } + ), + "rem_defender", ZERO_OR_MORE, + definition_manager.get_country_definition_manager().expect_country_definition_identifier( + [&defenders, ¤t_date, &name](CountryDefinition const& country) -> bool { + WarHistory::war_participant_t* participant_to_remove = nullptr; + + for (auto& defender : defenders) { + if (defender.country == &country) { + participant_to_remove = &defender; + break; + } + } - return participant_to_remove->period.try_set_end(current_date); - } - ), + if (participant_to_remove == nullptr) { + Logger::warning( + "In history of war ", name, " at date ", current_date.to_string(), + ": Attempted to remove attacking country ", country.get_identifier(), + " which was not present!" + ); + return true; + } + + return participant_to_remove->period.try_set_end(current_date); + } + ), "war_goal", ZERO_OR_MORE, [&definition_manager, &wargoals, ¤t_date](ast::NodeCPtr value) -> bool { - Country const* actor = nullptr; - Country const* receiver = nullptr; + CountryDefinition const* actor = nullptr; + CountryDefinition const* receiver = nullptr; WargoalType const* type = nullptr; - std::optional third_party {}; + std::optional third_party {}; std::optional target {}; bool ret = expect_dictionary_keys( "actor", ONE_EXACTLY, - definition_manager.get_country_manager().expect_country_identifier( + definition_manager.get_country_definition_manager().expect_country_definition_identifier( assign_variable_callback_pointer(actor) ), "receiver", ONE_EXACTLY, - definition_manager.get_country_manager().expect_country_identifier( + definition_manager.get_country_definition_manager().expect_country_definition_identifier( assign_variable_callback_pointer(receiver) ), "casus_belli", ONE_EXACTLY, definition_manager.get_military_manager().get_wargoal_type_manager() .expect_wargoal_type_identifier(assign_variable_callback_pointer(type)), "country", ZERO_OR_ONE, - definition_manager.get_country_manager().expect_country_identifier( - assign_variable_callback_pointer(*third_party) + definition_manager.get_country_definition_manager().expect_country_definition_identifier( + assign_variable_callback_pointer_opt(third_party) ), "state_province_id", ZERO_OR_ONE, definition_manager.get_map_definition().expect_province_definition_identifier( - assign_variable_callback_pointer(*target) + assign_variable_callback_pointer_opt(target) ) )(value); diff --git a/src/openvic-simulation/history/DiplomaticHistory.hpp b/src/openvic-simulation/history/DiplomaticHistory.hpp index 6055806..c6c6911 100644 --- a/src/openvic-simulation/history/DiplomaticHistory.hpp +++ b/src/openvic-simulation/history/DiplomaticHistory.hpp @@ -10,7 +10,7 @@ namespace OpenVic { struct DiplomaticHistoryManager; - struct Country; + struct CountryDefinition; struct WargoalType; struct ProvinceDefinition; @@ -22,17 +22,18 @@ namespace OpenVic { private: Date PROPERTY_CUSTOM_PREFIX(added, get_date); - Country const* PROPERTY(actor); - Country const* PROPERTY(receiver); + CountryDefinition const* PROPERTY(actor); + CountryDefinition const* PROPERTY(receiver); WargoalType const* PROPERTY(wargoal); // TODO - could these just be nullptr when unset rather than using optionals? - std::optional PROPERTY(third_party); + std::optional PROPERTY(third_party); std::optional PROPERTY(target); added_wargoal_t( - Date new_added, Country const* new_actor, Country const* new_receiver, WargoalType const* new_wargoal, - std::optional new_third_party, std::optional new_target + Date new_added, CountryDefinition const* new_actor, CountryDefinition const* new_receiver, + WargoalType const* new_wargoal, std::optional new_third_party, + std::optional new_target ); }; @@ -40,10 +41,10 @@ namespace OpenVic { friend struct DiplomaticHistoryManager; private: - Country const* PROPERTY(country); + CountryDefinition const* PROPERTY(country); Period PROPERTY(period); - war_participant_t(Country const* new_country, const Period period); + war_participant_t(CountryDefinition const* new_country, Period period); }; private: @@ -64,22 +65,22 @@ namespace OpenVic { friend struct DiplomaticHistoryManager; private: - Country const* PROPERTY(first); - Country const* PROPERTY(second); + CountryDefinition const* PROPERTY(first); + CountryDefinition const* PROPERTY(second); const Period PROPERTY(period); - AllianceHistory(Country const* new_first, Country const* new_second, const Period period); + AllianceHistory(CountryDefinition const* new_first, CountryDefinition const* new_second, Period period); }; struct ReparationsHistory { friend struct DiplomaticHistoryManager; private: - Country const* PROPERTY(receiver); - Country const* PROPERTY(sender); + CountryDefinition const* PROPERTY(receiver); + CountryDefinition const* PROPERTY(sender); const Period PROPERTY(period); - ReparationsHistory(Country const* new_receiver, Country const* new_sender, const Period period); + ReparationsHistory(CountryDefinition const* new_receiver, CountryDefinition const* new_sender, Period period); }; struct SubjectHistory { @@ -92,15 +93,17 @@ namespace OpenVic { }; private: - Country const* PROPERTY(overlord); - Country const* PROPERTY(subject); + CountryDefinition const* PROPERTY(overlord); + CountryDefinition const* PROPERTY(subject); const type_t PROPERTY_CUSTOM_PREFIX(type, get_subject); const Period PROPERTY(period); - SubjectHistory(Country const* new_overlord, Country const* new_subject, const type_t new_type, const Period period); + SubjectHistory( + CountryDefinition const* new_overlord, CountryDefinition const* new_subject, type_t new_type, Period period + ); }; - struct CountryManager; + struct CountryDefinitionManager; struct DefinitionManager; struct DiplomaticHistoryManager { @@ -125,7 +128,7 @@ namespace OpenVic { * should be checked for by functions that use get_wars() */ std::vector get_wars(Date date) const; - bool load_diplomacy_history_file(CountryManager const& country_manager, ast::NodeCPtr root); + bool load_diplomacy_history_file(CountryDefinitionManager const& country_definition_manager, ast::NodeCPtr root); bool load_war_history_file(DefinitionManager const& definition_manager, ast::NodeCPtr root); }; } diff --git a/src/openvic-simulation/history/ProvinceHistory.cpp b/src/openvic-simulation/history/ProvinceHistory.cpp index ffbda51..f2291e8 100644 --- a/src/openvic-simulation/history/ProvinceHistory.cpp +++ b/src/openvic-simulation/history/ProvinceHistory.cpp @@ -19,7 +19,7 @@ bool ProvinceHistoryMap::_load_history_entry( DefinitionManager const& definition_manager, ProvinceHistoryEntry& entry, ast::NodeCPtr root ) { BuildingTypeManager const& building_type_manager = definition_manager.get_economy_manager().get_building_type_manager(); - CountryManager const& country_manager = definition_manager.get_country_manager(); + CountryDefinitionManager const& country_definition_manager = definition_manager.get_country_definition_manager(); GoodDefinitionManager const& good_definition_manager = definition_manager.get_economy_manager().get_good_definition_manager(); IdeologyManager const& ideology_manager = definition_manager.get_politics_manager().get_ideology_manager(); @@ -53,12 +53,16 @@ bool ProvinceHistoryMap::_load_history_entry( return _load_history_sub_entry_callback(definition_manager, entry.get_date(), value, key, value); }, - "owner", ZERO_OR_ONE, - country_manager.expect_country_identifier(assign_variable_callback_pointer_opt(entry.owner, true)), - "controller", ZERO_OR_ONE, - country_manager.expect_country_identifier(assign_variable_callback_pointer_opt(entry.controller, true)), - "add_core", ZERO_OR_MORE, country_manager.expect_country_identifier(vector_callback_pointer(entry.add_cores)), - "remove_core", ZERO_OR_MORE, country_manager.expect_country_identifier( + "owner", ZERO_OR_ONE, country_definition_manager.expect_country_definition_identifier( + assign_variable_callback_pointer_opt(entry.owner, true) + ), + "controller", ZERO_OR_ONE, country_definition_manager.expect_country_definition_identifier( + assign_variable_callback_pointer_opt(entry.controller, true) + ), + "add_core", ZERO_OR_MORE, country_definition_manager.expect_country_definition_identifier( + vector_callback_pointer(entry.add_cores) + ), + "remove_core", ZERO_OR_MORE, country_definition_manager.expect_country_definition_identifier( vector_callback_pointer(entry.remove_cores) ), "colonial", ZERO_OR_ONE, diff --git a/src/openvic-simulation/history/ProvinceHistory.hpp b/src/openvic-simulation/history/ProvinceHistory.hpp index 7c283f4..d6bf150 100644 --- a/src/openvic-simulation/history/ProvinceHistory.hpp +++ b/src/openvic-simulation/history/ProvinceHistory.hpp @@ -15,7 +15,7 @@ namespace OpenVic { struct ProvinceHistoryMap; struct ProvinceDefinition; - struct Country; + struct CountryDefinition; struct GoodDefinition; struct TerrainType; struct Ideology; @@ -27,12 +27,12 @@ namespace OpenVic { private: ProvinceDefinition const& PROPERTY(province); - std::optional PROPERTY(owner); - std::optional PROPERTY(controller); + std::optional PROPERTY(owner); + std::optional PROPERTY(controller); std::optional PROPERTY(colonial); std::optional PROPERTY(slave); - std::vector PROPERTY(add_cores); - std::vector PROPERTY(remove_cores); + std::vector PROPERTY(add_cores); + std::vector PROPERTY(remove_cores); std::optional PROPERTY(rgo); std::optional PROPERTY(life_rating); std::optional PROPERTY(terrain_type); diff --git a/src/openvic-simulation/map/MapInstance.cpp b/src/openvic-simulation/map/MapInstance.cpp index 093d341..1547ade 100644 --- a/src/openvic-simulation/map/MapInstance.cpp +++ b/src/openvic-simulation/map/MapInstance.cpp @@ -86,7 +86,7 @@ bool MapInstance::setup(BuildingTypeManager const& building_type_manager) { bool MapInstance::apply_history_to_provinces( ProvinceHistoryManager const& history_manager, Date date, IdeologyManager const& ideology_manager, - IssueManager const& issue_manager, Country const& country + IssueManager const& issue_manager, CountryDefinition const& country ) { bool ret = true; diff --git a/src/openvic-simulation/map/MapInstance.hpp b/src/openvic-simulation/map/MapInstance.hpp index 353a3a4..2c0ff74 100644 --- a/src/openvic-simulation/map/MapInstance.hpp +++ b/src/openvic-simulation/map/MapInstance.hpp @@ -12,7 +12,7 @@ namespace OpenVic { struct ProvinceHistoryManager; struct IdeologyManager; struct IssueManager; - struct Country; + struct CountryDefinition; /* REQUIREMENTS: * MAP-4 @@ -47,7 +47,7 @@ namespace OpenVic { bool setup(BuildingTypeManager const& building_type_manager); bool apply_history_to_provinces( ProvinceHistoryManager const& history_manager, Date date, IdeologyManager const& ideology_manager, - IssueManager const& issue_manager, Country const& country + IssueManager const& issue_manager, CountryDefinition const& country ); void update_gamestate(Date today); diff --git a/src/openvic-simulation/map/Mapmode.cpp b/src/openvic-simulation/map/Mapmode.cpp index 410ea2b..f03b0e8 100644 --- a/src/openvic-simulation/map/Mapmode.cpp +++ b/src/openvic-simulation/map/Mapmode.cpp @@ -2,7 +2,7 @@ #include -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/map/MapDefinition.hpp" #include "openvic-simulation/map/MapInstance.hpp" #include "openvic-simulation/map/ProvinceDefinition.hpp" diff --git a/src/openvic-simulation/map/ProvinceInstance.cpp b/src/openvic-simulation/map/ProvinceInstance.cpp index 2a0863d..967d72b 100644 --- a/src/openvic-simulation/map/ProvinceInstance.cpp +++ b/src/openvic-simulation/map/ProvinceInstance.cpp @@ -1,6 +1,6 @@ #include "ProvinceInstance.hpp" -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/history/ProvinceHistory.hpp" #include "openvic-simulation/map/ProvinceDefinition.hpp" #include "openvic-simulation/military/UnitInstance.hpp" @@ -176,7 +176,7 @@ bool ProvinceInstance::apply_history_to_province(ProvinceHistoryEntry const* ent if (entry->get_owner()) owner = *entry->get_owner(); if (entry->get_controller()) controller = *entry->get_controller(); if (entry->get_slave()) slave = *entry->get_slave(); - for (Country const* core : entry->get_remove_cores()) { + for (CountryDefinition const* core : entry->get_remove_cores()) { const typename decltype(cores)::iterator existing_core = std::find(cores.begin(), cores.end(), core); if (existing_core != cores.end()) { cores.erase(existing_core); @@ -186,7 +186,7 @@ bool ProvinceInstance::apply_history_to_province(ProvinceHistoryEntry const* ent ); } } - for (Country const* core : entry->get_add_cores()) { + for (CountryDefinition const* core : entry->get_add_cores()) { const typename decltype(cores)::iterator existing_core = std::find(cores.begin(), cores.end(), core); if (existing_core == cores.end()) { cores.push_back(core); @@ -215,7 +215,7 @@ bool ProvinceInstance::apply_history_to_province(ProvinceHistoryEntry const* ent } void ProvinceInstance::setup_pop_test_values( - IdeologyManager const& ideology_manager, IssueManager const& issue_manager, Country const& country + IdeologyManager const& ideology_manager, IssueManager const& issue_manager, CountryDefinition const& country ) { for (Pop& pop : pops) { pop.setup_pop_test_values(ideology_manager, issue_manager, country); diff --git a/src/openvic-simulation/map/ProvinceInstance.hpp b/src/openvic-simulation/map/ProvinceInstance.hpp index 67ce423..8e8ec93 100644 --- a/src/openvic-simulation/map/ProvinceInstance.hpp +++ b/src/openvic-simulation/map/ProvinceInstance.hpp @@ -11,7 +11,7 @@ namespace OpenVic { struct ProvinceDefinition; struct TerrainType; struct State; - struct Country; + struct CountryDefinition; struct Crime; struct GoodDefinition; struct ArmyInstance; @@ -31,16 +31,17 @@ namespace OpenVic { enum struct colony_status_t : uint8_t { STATE, PROTECTORATE, COLONY }; + private: ProvinceDefinition const& PROPERTY(province_definition); - /* Mutable attributes (reset before loading history) */ TerrainType const* PROPERTY(terrain_type); life_rating_t PROPERTY(life_rating); colony_status_t PROPERTY(colony_status); State const* PROPERTY_RW(state); - Country const* PROPERTY(owner); - Country const* PROPERTY(controller); - std::vector PROPERTY(cores); + CountryDefinition const* PROPERTY(owner); + CountryDefinition const* PROPERTY(controller); + // Cores being CountryDefinitions means then they won't be affected by tag switched (as desired) + std::vector PROPERTY(cores); bool PROPERTY(slave); Crime const* PROPERTY_RW(crime); // TODO - change this into a factory-like structure @@ -86,7 +87,7 @@ namespace OpenVic { bool apply_history_to_province(ProvinceHistoryEntry const* entry); void setup_pop_test_values( - IdeologyManager const& ideology_manager, IssueManager const& issue_manager, Country const& country + IdeologyManager const& ideology_manager, IssueManager const& issue_manager, CountryDefinition const& country ); }; } diff --git a/src/openvic-simulation/map/State.cpp b/src/openvic-simulation/map/State.cpp index 46ff11d..42d84cc 100644 --- a/src/openvic-simulation/map/State.cpp +++ b/src/openvic-simulation/map/State.cpp @@ -1,6 +1,5 @@ #include "State.hpp" -#include "openvic-simulation/country/Country.hpp" #include "openvic-simulation/map/MapDefinition.hpp" #include "openvic-simulation/map/MapInstance.hpp" #include "openvic-simulation/map/ProvinceInstance.hpp" @@ -9,8 +8,8 @@ using namespace OpenVic; State::State( - StateSet const& new_state_set, Country const* owner, ProvinceInstance* capital, std::vector&& provinces, - ProvinceInstance::colony_status_t colony_status + StateSet const& new_state_set, CountryDefinition const* owner, ProvinceInstance* capital, + std::vector&& provinces, ProvinceInstance::colony_status_t colony_status ) : state_set { new_state_set }, owner { owner }, capital { capital }, provinces { std::move(provinces) }, colony_status { colony_status } {} diff --git a/src/openvic-simulation/map/State.hpp b/src/openvic-simulation/map/State.hpp index ff8acfa..6111668 100644 --- a/src/openvic-simulation/map/State.hpp +++ b/src/openvic-simulation/map/State.hpp @@ -9,7 +9,7 @@ namespace OpenVic { struct StateManager; struct StateSet; - struct Country; + struct CountryDefinition; struct ProvinceInstance; struct State { @@ -17,7 +17,7 @@ namespace OpenVic { private: StateSet const& PROPERTY(state_set); - Country const* PROPERTY(owner); + CountryDefinition const* PROPERTY(owner); ProvinceInstance* PROPERTY(capital); std::vector PROPERTY(provinces); ProvinceInstance::colony_status_t PROPERTY(colony_status); @@ -25,7 +25,7 @@ namespace OpenVic { Pop::pop_size_t PROPERTY(total_population); State( - StateSet const& new_state_set, Country const* owner, ProvinceInstance* capital, + StateSet const& new_state_set, CountryDefinition const* owner, ProvinceInstance* capital, std::vector&& provinces, ProvinceInstance::colony_status_t colony_status ); diff --git a/src/openvic-simulation/pop/Culture.cpp b/src/openvic-simulation/pop/Culture.cpp index 18ed3d8..93d4d19 100644 --- a/src/openvic-simulation/pop/Culture.cpp +++ b/src/openvic-simulation/pop/Culture.cpp @@ -1,6 +1,6 @@ #include "Culture.hpp" -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/types/Colour.hpp" @@ -11,13 +11,13 @@ GraphicalCultureType::GraphicalCultureType(std::string_view new_identifier) : Ha CultureGroup::CultureGroup( std::string_view new_identifier, std::string_view new_leader, GraphicalCultureType const& new_unit_graphical_culture_type, - bool new_is_overseas, Country const* new_union_country + bool new_is_overseas, CountryDefinition const* new_union_country ) : HasIdentifier { new_identifier }, leader { new_leader }, unit_graphical_culture_type { new_unit_graphical_culture_type }, is_overseas { new_is_overseas }, union_country { new_union_country } {} Culture::Culture( std::string_view new_identifier, colour_t new_colour, CultureGroup const& new_group, name_list_t&& new_first_names, - name_list_t&& new_last_names, fixed_point_t new_radicalism, Country const* new_primary_country + name_list_t&& new_last_names, fixed_point_t new_radicalism, CountryDefinition const* new_primary_country ) : HasIdentifierAndColour { new_identifier, new_colour, false }, group { new_group }, first_names { std::move(new_first_names) }, last_names { std::move(new_last_names) }, radicalism { new_radicalism }, primary_country { new_primary_country } {} @@ -34,7 +34,7 @@ bool CultureManager::add_graphical_culture_type(std::string_view identifier) { bool CultureManager::add_culture_group( std::string_view identifier, std::string_view leader, GraphicalCultureType const* graphical_culture_type, bool is_overseas, - Country const* union_country + CountryDefinition const* union_country ) { if (!graphical_culture_types.is_locked()) { Logger::error("Cannot register culture groups until graphical culture types are locked!"); @@ -57,7 +57,7 @@ bool CultureManager::add_culture_group( bool CultureManager::add_culture( std::string_view identifier, colour_t colour, CultureGroup const& group, name_list_t&& first_names, - name_list_t&& last_names, fixed_point_t radicalism, Country const* primary_country + name_list_t&& last_names, fixed_point_t radicalism, CountryDefinition const* primary_country ) { if (!culture_groups.is_locked()) { Logger::error("Cannot register cultures until culture groups are locked!"); @@ -95,20 +95,21 @@ bool CultureManager::load_graphical_culture_type_file(ast::NodeCPtr root) { } bool CultureManager::_load_culture_group( - CountryManager const& country_manager, size_t& total_expected_cultures, std::string_view culture_group_key, - ast::NodeCPtr culture_group_node + CountryDefinitionManager const& country_definition_manager, size_t& total_expected_cultures, + std::string_view culture_group_key, ast::NodeCPtr culture_group_node ) { std::string_view leader {}; GraphicalCultureType const* unit_graphical_culture_type = default_graphical_culture_type; bool is_overseas = true; - Country const* union_country = nullptr; + CountryDefinition const* union_country = nullptr; bool ret = expect_dictionary_keys_and_default( increment_callback(total_expected_cultures), "leader", ONE_EXACTLY, expect_identifier(assign_variable_callback(leader)), "unit", ZERO_OR_ONE, expect_graphical_culture_type_identifier(assign_variable_callback_pointer(unit_graphical_culture_type)), - "union", ZERO_OR_ONE, country_manager.expect_country_identifier(assign_variable_callback_pointer(union_country)), + "union", ZERO_OR_ONE, + country_definition_manager.expect_country_definition_identifier(assign_variable_callback_pointer(union_country)), "is_overseas", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_overseas)) )(culture_group_node); ret &= add_culture_group(culture_group_key, leader, unit_graphical_culture_type, is_overseas, union_country); @@ -116,20 +117,21 @@ bool CultureManager::_load_culture_group( } bool CultureManager::_load_culture( - CountryManager const& country_manager, CultureGroup const& culture_group, std::string_view culture_key, + CountryDefinitionManager const& country_definition_manager, CultureGroup const& culture_group, std::string_view culture_key, ast::NodeCPtr culture_node ) { colour_t colour = colour_t::null(); name_list_t first_names {}, last_names {}; fixed_point_t radicalism = 0; - Country const* primary_country = nullptr; + CountryDefinition const* primary_country = nullptr; bool ret = expect_dictionary_keys( "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), "first_names", ONE_EXACTLY, name_list_callback(move_variable_callback(first_names)), "last_names", ONE_EXACTLY, name_list_callback(move_variable_callback(last_names)), "radicalism", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(radicalism)), - "primary", ZERO_OR_ONE, country_manager.expect_country_identifier(assign_variable_callback_pointer(primary_country)) + "primary", ZERO_OR_ONE, + country_definition_manager.expect_country_definition_identifier(assign_variable_callback_pointer(primary_country)) )(culture_node); ret &= add_culture( culture_key, colour, culture_group, std::move(first_names), std::move(last_names), radicalism, primary_country @@ -157,7 +159,7 @@ bool CultureManager::_load_culture( * POP-267, POP-268, POP-269, POP-270, POP-271, POP-272, POP-273, POP-274, POP-275, POP-276, POP-277, POP-278, POP-279, * POP-280, POP-281, POP-282, POP-283, POP-284 */ -bool CultureManager::load_culture_file(CountryManager const& country_manager, ast::NodeCPtr root) { +bool CultureManager::load_culture_file(CountryDefinitionManager const& country_definition_manager, ast::NodeCPtr root) { if (!graphical_culture_types.is_locked()) { Logger::error("Cannot load culture groups until graphical culture types are locked!"); return false; @@ -165,24 +167,24 @@ bool CultureManager::load_culture_file(CountryManager const& country_manager, as size_t total_expected_cultures = 0; bool ret = expect_dictionary_reserve_length(culture_groups, - [this, &country_manager, &total_expected_cultures]( + [this, &country_definition_manager, &total_expected_cultures]( std::string_view key, ast::NodeCPtr value ) -> bool { - return _load_culture_group(country_manager, total_expected_cultures, key, value); + return _load_culture_group(country_definition_manager, total_expected_cultures, key, value); } )(root); lock_culture_groups(); reserve_more_cultures(total_expected_cultures); ret &= expect_culture_group_dictionary( - [this, &country_manager](CultureGroup const& culture_group, ast::NodeCPtr culture_group_value) -> bool { + [this, &country_definition_manager](CultureGroup const& culture_group, ast::NodeCPtr culture_group_value) -> bool { return expect_dictionary( - [this, &country_manager, &culture_group](std::string_view key, ast::NodeCPtr value) -> bool { + [this, &country_definition_manager, &culture_group](std::string_view key, ast::NodeCPtr value) -> bool { static const string_set_t reserved_keys = { "leader", "unit", "union", "is_overseas" }; if (reserved_keys.contains(key)) { return true; } - return _load_culture(country_manager, culture_group, key, value); + return _load_culture(country_definition_manager, culture_group, key, value); } )(culture_group_value); } diff --git a/src/openvic-simulation/pop/Culture.hpp b/src/openvic-simulation/pop/Culture.hpp index 72ea3ee..9fe06de 100644 --- a/src/openvic-simulation/pop/Culture.hpp +++ b/src/openvic-simulation/pop/Culture.hpp @@ -5,8 +5,8 @@ namespace OpenVic { struct CultureManager; - struct Country; - struct CountryManager; + struct CountryDefinition; + struct CountryDefinitionManager; struct GraphicalCultureType : HasIdentifier { friend struct CultureManager; @@ -25,11 +25,12 @@ namespace OpenVic { std::string PROPERTY(leader); GraphicalCultureType const& PROPERTY(unit_graphical_culture_type); bool PROPERTY(is_overseas); - Country const* PROPERTY(union_country); + CountryDefinition const* PROPERTY(union_country); CultureGroup( std::string_view new_identifier, std::string_view new_leader, - GraphicalCultureType const& new_unit_graphical_culture_type, bool new_is_overseas, Country const* new_union_country + GraphicalCultureType const& new_unit_graphical_culture_type, bool new_is_overseas, + CountryDefinition const* new_union_country ); public: @@ -44,11 +45,11 @@ namespace OpenVic { name_list_t PROPERTY(first_names); name_list_t PROPERTY(last_names); fixed_point_t PROPERTY(radicalism); - Country const* PROPERTY(primary_country); + CountryDefinition const* PROPERTY(primary_country); Culture( std::string_view new_identifier, colour_t new_colour, CultureGroup const& new_group, name_list_t&& new_first_names, - name_list_t&& new_last_names, fixed_point_t new_radicalism, Country const* new_primary_country + name_list_t&& new_last_names, fixed_point_t new_radicalism, CountryDefinition const* new_primary_country ); public: @@ -64,12 +65,12 @@ namespace OpenVic { GraphicalCultureType const* PROPERTY(default_graphical_culture_type); bool _load_culture_group( - CountryManager const& country_manager, size_t& total_expected_cultures, + CountryDefinitionManager const& country_definition_manager, size_t& total_expected_cultures, std::string_view culture_group_key, ast::NodeCPtr culture_group_node ); bool _load_culture( - CountryManager const& country_manager, CultureGroup const& culture_group, std::string_view culture_key, - ast::NodeCPtr node + CountryDefinitionManager const& country_definition_manager, CultureGroup const& culture_group, + std::string_view culture_key, ast::NodeCPtr node ); public: @@ -79,15 +80,15 @@ namespace OpenVic { bool add_culture_group( std::string_view identifier, std::string_view leader, GraphicalCultureType const* graphical_culture_type, - bool is_overseas, Country const* union_country + bool is_overseas, CountryDefinition const* union_country ); bool add_culture( std::string_view identifier, colour_t colour, CultureGroup const& group, name_list_t&& first_names, - name_list_t&& last_names, fixed_point_t radicalism, Country const* primary_country + name_list_t&& last_names, fixed_point_t radicalism, CountryDefinition const* primary_country ); bool load_graphical_culture_type_file(ast::NodeCPtr root); - bool load_culture_file(CountryManager const& country_manager, ast::NodeCPtr root); + bool load_culture_file(CountryDefinitionManager const& country_definition_manager, ast::NodeCPtr root); }; } diff --git a/src/openvic-simulation/pop/Pop.cpp b/src/openvic-simulation/pop/Pop.cpp index b1bf56f..4f8bdcb 100644 --- a/src/openvic-simulation/pop/Pop.cpp +++ b/src/openvic-simulation/pop/Pop.cpp @@ -1,6 +1,6 @@ #include "Pop.hpp" -#include "openvic-simulation/country/Country.hpp" +#include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/military/UnitType.hpp" #include "openvic-simulation/politics/Ideology.hpp" #include "openvic-simulation/politics/Issue.hpp" @@ -50,7 +50,7 @@ Pop::Pop( } void Pop::setup_pop_test_values( - IdeologyManager const& ideology_manager, IssueManager const& issue_manager, Country const& country + IdeologyManager const& ideology_manager, IssueManager const& issue_manager, CountryDefinition const& country ) { /* Returns +/- range% of size. */ const auto test_size = [this](int32_t range) -> pop_size_t { diff --git a/src/openvic-simulation/pop/Pop.hpp b/src/openvic-simulation/pop/Pop.hpp index a5033ef..b069f02 100644 --- a/src/openvic-simulation/pop/Pop.hpp +++ b/src/openvic-simulation/pop/Pop.hpp @@ -87,7 +87,7 @@ namespace OpenVic { Pop& operator=(Pop&&) = delete; void setup_pop_test_values( - IdeologyManager const& ideology_manager, IssueManager const& issue_manager, Country const& country + IdeologyManager const& ideology_manager, IssueManager const& issue_manager, CountryDefinition const& country ); }; diff --git a/src/openvic-simulation/scripts/Condition.cpp b/src/openvic-simulation/scripts/Condition.cpp index e5679f8..7abd717 100644 --- a/src/openvic-simulation/scripts/Condition.cpp +++ b/src/openvic-simulation/scripts/Condition.cpp @@ -352,7 +352,7 @@ bool ConditionManager::setup_conditions(DefinitionManager const& definition_mana /* Scopes from other registries */ import_identifiers( - definition_manager.get_country_manager().get_country_identifiers(), + definition_manager.get_country_definition_manager().get_country_definition_identifiers(), GROUP, COUNTRY, COUNTRY, @@ -484,7 +484,9 @@ callback_t ConditionManager::expect_parse_identifier( EXPECT_CALL_PLACEHOLDER(GLOBAL_FLAG); EXPECT_CALL_PLACEHOLDER(COUNTRY_FLAG); EXPECT_CALL_PLACEHOLDER(PROVINCE_FLAG); - EXPECT_CALL(COUNTRY_TAG, country, definition_manager.get_country_manager(), "THIS", "FROM", "OWNER"); + EXPECT_CALL( + COUNTRY_TAG, country_definition, definition_manager.get_country_definition_manager(), "THIS", "FROM", "OWNER" + ); EXPECT_CALL(PROVINCE_ID, province_definition, definition_manager.get_map_definition(), "THIS", "FROM"); EXPECT_CALL(REGION, region, definition_manager.get_map_definition()); EXPECT_CALL(IDEOLOGY, ideology, definition_manager.get_politics_manager().get_ideology_manager()); @@ -507,7 +509,9 @@ callback_t ConditionManager::expect_parse_identifier( EXPECT_CALL(MODIFIER, triggered_modifier, definition_manager.get_modifier_manager()); EXPECT_CALL(MODIFIER, static_modifier, definition_manager.get_modifier_manager()); EXPECT_CALL(NATIONAL_VALUE, national_value, definition_manager.get_politics_manager().get_national_value_manager()); - EXPECT_CALL(CULTURE_UNION, country, definition_manager.get_country_manager(), "THIS", "FROM", "THIS_UNION"); + EXPECT_CALL( + CULTURE_UNION, country_definition, definition_manager.get_country_definition_manager(), "THIS", "FROM", "THIS_UNION" + ); EXPECT_CALL(CONTINENT, continent, definition_manager.get_map_definition()); EXPECT_CALL(CRIME, crime_modifier, definition_manager.get_crime_manager()); EXPECT_CALL(TERRAIN, terrain_type, definition_manager.get_map_definition().get_terrain_type_manager()); diff --git a/src/openvic-simulation/types/IdentifierRegistry.hpp b/src/openvic-simulation/types/IdentifierRegistry.hpp index 8c8ba11..fe83a43 100644 --- a/src/openvic-simulation/types/IdentifierRegistry.hpp +++ b/src/openvic-simulation/types/IdentifierRegistry.hpp @@ -4,7 +4,6 @@ #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/Logger.hpp" @@ -28,6 +27,11 @@ namespace OpenVic { return true; } + template + concept HasGetIdentifier = requires(T const& t) { + { t.get_identifier() } -> std::same_as; + }; + /* Registry Value Info - the type that is being registered, and a unique identifier string getter. */ template concept RegistryValueInfo = requires( @@ -37,8 +41,8 @@ namespace OpenVic { { ValueInfo::get_external_value(item) } -> std::same_as; { ValueInfo::get_external_value(const_item) } -> std::same_as; }; - template Value> - struct RegistryValueInfoHasIdentifier { + template + struct RegistryValueInfoHasGetIdentifier { using internal_value_type = Value; using external_value_type = Value; @@ -484,34 +488,34 @@ namespace OpenVic { RegistryStorageInfo::item_type> using InstanceRegistry = UniqueKeyRegistry; - /* HasIdentifier Specialisations */ + /* HasGetIdentifier Specialisations */ template< - std::derived_from Value, template typename StorageInfo = RegistryStorageInfoVector, + HasGetIdentifier Value, template typename StorageInfo = RegistryStorageInfoVector, StringMapCase Case = StringMapCaseSensitive > - using IdentifierRegistry = ValueRegistry, StorageInfo, Case>; + using IdentifierRegistry = ValueRegistry, StorageInfo, Case>; template< - std::derived_from Value, template typename StorageInfo = RegistryStorageInfoVector, + HasGetIdentifier Value, template typename StorageInfo = RegistryStorageInfoVector, StringMapCase Case = StringMapCaseSensitive > using IdentifierPointerRegistry = - ValueRegistry>, StorageInfo, Case>; + ValueRegistry>, StorageInfo, Case>; template< - std::derived_from Value, template typename StorageInfo = RegistryStorageInfoVector, + HasGetIdentifier Value, template typename StorageInfo = RegistryStorageInfoVector, StringMapCase Case = StringMapCaseSensitive > - using IdentifierInstanceRegistry = InstanceRegistry, StorageInfo, Case>; + using IdentifierInstanceRegistry = InstanceRegistry, StorageInfo, Case>; - /* Case-Insensitive HasIdentifier Specialisations */ - template Value, template typename StorageInfo = RegistryStorageInfoVector> + /* Case-Insensitive HasGetIdentifier Specialisations */ + template typename StorageInfo = RegistryStorageInfoVector> using CaseInsensitiveIdentifierRegistry = IdentifierRegistry; - template Value, template typename StorageInfo = RegistryStorageInfoVector> + template typename StorageInfo = RegistryStorageInfoVector> using CaseInsensitiveIdentifierPointerRegistry = IdentifierPointerRegistry; - template Value, template typename StorageInfo = RegistryStorageInfoVector> + template typename StorageInfo = RegistryStorageInfoVector> using CaseInsensitiveIdentifierInstanceRegistry = IdentifierInstanceRegistry; /* Macros to generate declaration and constant accessor methods for a UniqueKeyRegistry member variable. */ -- cgit v1.2.3-56-ga3b1 From 45d66d887983177612d7cb8e715d5b28c1f87f31 Mon Sep 17 00:00:00 2001 From: hop311 Date: Thu, 27 Jun 2024 20:28:34 +0100 Subject: Use minimal PopBase for pop history --- src/openvic-simulation/history/ProvinceHistory.cpp | 2 +- src/openvic-simulation/history/ProvinceHistory.hpp | 4 +- src/openvic-simulation/map/ProvinceInstance.cpp | 10 ++-- src/openvic-simulation/map/ProvinceInstance.hpp | 4 +- src/openvic-simulation/pop/Pop.cpp | 38 ++++++++-------- src/openvic-simulation/pop/Pop.hpp | 53 ++++++++++++---------- 6 files changed, 58 insertions(+), 53 deletions(-) diff --git a/src/openvic-simulation/history/ProvinceHistory.cpp b/src/openvic-simulation/history/ProvinceHistory.cpp index f2291e8..1fa6e90 100644 --- a/src/openvic-simulation/history/ProvinceHistory.cpp +++ b/src/openvic-simulation/history/ProvinceHistory.cpp @@ -214,7 +214,7 @@ bool ProvinceHistoryEntry::_load_province_pop_history( return pop_manager.expect_pop_type_dictionary_reserve_length( pops, [this, &pop_manager, &rebel_manager, non_integer_size](PopType const& pop_type, ast::NodeCPtr pop_node) -> bool { - return pop_manager.load_pop_into_vector(rebel_manager, pops, pop_type, pop_node, non_integer_size); + return pop_manager.load_pop_bases_into_vector(rebel_manager, pops, pop_type, pop_node, non_integer_size); } )(root); } diff --git a/src/openvic-simulation/history/ProvinceHistory.hpp b/src/openvic-simulation/history/ProvinceHistory.hpp index d6bf150..85853d7 100644 --- a/src/openvic-simulation/history/ProvinceHistory.hpp +++ b/src/openvic-simulation/history/ProvinceHistory.hpp @@ -39,9 +39,7 @@ namespace OpenVic { ordered_map PROPERTY(province_buildings); ordered_map PROPERTY(state_buildings); fixed_point_map_t PROPERTY(party_loyalties); - - // TODO - use minimal pop representation (size, type, culture, religion, consciousness, militancy, rebel type) - std::vector PROPERTY(pops); + std::vector PROPERTY(pops); ProvinceHistoryEntry(ProvinceDefinition const& new_province, Date new_date); diff --git a/src/openvic-simulation/map/ProvinceInstance.cpp b/src/openvic-simulation/map/ProvinceInstance.cpp index 967d72b..61b1527 100644 --- a/src/openvic-simulation/map/ProvinceInstance.cpp +++ b/src/openvic-simulation/map/ProvinceInstance.cpp @@ -39,8 +39,8 @@ bool ProvinceInstance::expand_building(size_t building_index) { return building->expand(); } -void ProvinceInstance::_add_pop(Pop pop) { - pop.set_location(this); +void ProvinceInstance::_add_pop(Pop&& pop) { + pop.set_location(*this); pops.push_back(std::move(pop)); } @@ -54,11 +54,11 @@ bool ProvinceInstance::add_pop(Pop&& pop) { } } -bool ProvinceInstance::add_pop_vec(std::vector const& pop_vec) { +bool ProvinceInstance::add_pop_vec(std::vector const& pop_vec) { if (!province_definition.is_water()) { reserve_more(pops, pop_vec.size()); - for (Pop const& pop : pop_vec) { - _add_pop(pop); + for (PopBase const& pop : pop_vec) { + _add_pop(Pop { pop }); } return true; } else { diff --git a/src/openvic-simulation/map/ProvinceInstance.hpp b/src/openvic-simulation/map/ProvinceInstance.hpp index 8e8ec93..ca7f149 100644 --- a/src/openvic-simulation/map/ProvinceInstance.hpp +++ b/src/openvic-simulation/map/ProvinceInstance.hpp @@ -59,7 +59,7 @@ namespace OpenVic { ProvinceInstance(ProvinceDefinition const& new_province_definition); - void _add_pop(Pop pop); + void _add_pop(Pop&& pop); void _update_pops(); public: @@ -72,7 +72,7 @@ namespace OpenVic { bool expand_building(size_t building_index); bool add_pop(Pop&& pop); - bool add_pop_vec(std::vector const& pop_vec); + bool add_pop_vec(std::vector const& pop_vec); size_t get_pop_count() const; void update_gamestate(Date today); diff --git a/src/openvic-simulation/pop/Pop.cpp b/src/openvic-simulation/pop/Pop.cpp index 4f8bdcb..8f4c445 100644 --- a/src/openvic-simulation/pop/Pop.cpp +++ b/src/openvic-simulation/pop/Pop.cpp @@ -1,6 +1,7 @@ #include "Pop.hpp" #include "openvic-simulation/country/CountryDefinition.hpp" +#include "openvic-simulation/map/ProvinceInstance.hpp" #include "openvic-simulation/military/UnitType.hpp" #include "openvic-simulation/politics/Ideology.hpp" #include "openvic-simulation/politics/Issue.hpp" @@ -12,18 +13,14 @@ using namespace OpenVic::NodeTools; using enum PopType::income_type_t; -Pop::Pop( - PopType const& new_type, - Culture const& new_culture, - Religion const& new_religion, - pop_size_t new_size, - fixed_point_t new_militancy, - fixed_point_t new_consciousness, - RebelType const* new_rebel_type -) : type { new_type }, - culture { new_culture }, - religion { new_religion }, - size { new_size }, +PopBase::PopBase( + PopType const& new_type, Culture const& new_culture, Religion const& new_religion, pop_size_t new_size, + fixed_point_t new_militancy, fixed_point_t new_consciousness, RebelType const* new_rebel_type +) : type { new_type }, culture { new_culture }, religion { new_religion }, size { new_size }, militancy { new_militancy }, + consciousness { new_consciousness }, rebel_type { new_rebel_type } {} + +Pop::Pop(PopBase const& pop_base) + : PopBase { pop_base }, location { nullptr }, total_change { 0 }, num_grown { 0 }, @@ -32,9 +29,6 @@ Pop::Pop( num_migrated_internal { 0 }, num_migrated_external { 0 }, num_migrated_colonial { 0 }, - militancy { new_militancy }, - consciousness { new_consciousness }, - rebel_type { new_rebel_type }, ideologies {}, issues {}, votes {}, @@ -117,6 +111,14 @@ void Pop::setup_pop_test_values( luxury_needs_fulfilled = test_range(); } +void Pop::set_location(ProvinceInstance const& new_location) { + if (location != &new_location) { + location = &new_location; + + // TODO - update location dependent attributes + } +} + Strata::Strata(std::string_view new_identifier) : HasIdentifier { new_identifier } {} PopType::PopType( @@ -596,8 +598,8 @@ bool PopManager::load_pop_type_chances_file(ast::NodeCPtr root) { )(root); } -bool PopManager::load_pop_into_vector( - RebelManager const& rebel_manager, std::vector& vec, PopType const& type, ast::NodeCPtr pop_node, +bool PopManager::load_pop_bases_into_vector( + RebelManager const& rebel_manager, std::vector& vec, PopType const& type, ast::NodeCPtr pop_node, bool *non_integer_size ) const { Culture const* culture = nullptr; @@ -620,7 +622,7 @@ bool PopManager::load_pop_into_vector( } if (culture != nullptr && religion != nullptr && size >= 1) { - vec.emplace_back(Pop { type, *culture, *religion, size.to_int64_t(), militancy, consciousness, rebel_type }); + vec.emplace_back(PopBase { type, *culture, *religion, size.to_int64_t(), militancy, consciousness, rebel_type }); } else { Logger::warning( "Some pop arguments are invalid: culture = ", culture, ", religion = ", religion, ", size = ", size diff --git a/src/openvic-simulation/pop/Pop.hpp b/src/openvic-simulation/pop/Pop.hpp index b069f02..8ac6d4c 100644 --- a/src/openvic-simulation/pop/Pop.hpp +++ b/src/openvic-simulation/pop/Pop.hpp @@ -26,22 +26,36 @@ namespace OpenVic { struct ProvinceInstance; struct CountryParty; - /* REQUIREMENTS: - * POP-18, POP-19, POP-20, POP-21, POP-34, POP-35, POP-36, POP-37 - */ - struct Pop { + struct PopBase { friend struct PopManager; using pop_size_t = int64_t; + protected: + PopType const& PROPERTY_ACCESS(type, protected); + Culture const& PROPERTY_ACCESS(culture, protected); + Religion const& PROPERTY_ACCESS(religion, protected); + pop_size_t PROPERTY_ACCESS(size, protected); + fixed_point_t PROPERTY_ACCESS(militancy, protected); + fixed_point_t PROPERTY_ACCESS(consciousness, protected); + RebelType const* PROPERTY_ACCESS(rebel_type, protected); + + PopBase( + PopType const& new_type, Culture const& new_culture, Religion const& new_religion, pop_size_t new_size, + fixed_point_t new_militancy, fixed_point_t new_consciousness, RebelType const* new_rebel_type + ); + }; + + /* REQUIREMENTS: + * POP-18, POP-19, POP-20, POP-21, POP-34, POP-35, POP-36, POP-37 + */ + struct Pop : PopBase { + friend struct ProvinceInstance; + static constexpr pop_size_t MAX_SIZE = std::numeric_limits::max(); private: - PopType const& PROPERTY(type); - Culture const& PROPERTY(culture); - Religion const& PROPERTY(religion); - pop_size_t PROPERTY(size); - ProvinceInstance const* PROPERTY_RW(location); + ProvinceInstance const* PROPERTY(location); /* Last day's size change by source. */ pop_size_t PROPERTY(total_change); @@ -52,10 +66,7 @@ namespace OpenVic { pop_size_t PROPERTY(num_migrated_external); pop_size_t PROPERTY(num_migrated_colonial); - fixed_point_t PROPERTY(militancy); - fixed_point_t PROPERTY(consciousness); fixed_point_t PROPERTY(literacy); - RebelType const* PROPERTY(rebel_type); fixed_point_map_t PROPERTY(ideologies); fixed_point_map_t PROPERTY(issues); @@ -70,18 +81,10 @@ namespace OpenVic { fixed_point_t PROPERTY(everyday_needs_fulfilled); fixed_point_t PROPERTY(luxury_needs_fulfilled); - Pop( - PopType const& new_type, - Culture const& new_culture, - Religion const& new_religion, - pop_size_t new_size, - fixed_point_t new_militancy, - fixed_point_t new_consciousness, - RebelType const* new_rebel_type - ); + Pop(PopBase const& pop_base); public: - Pop(Pop const&) = default; + Pop(Pop const&) = delete; Pop(Pop&&) = default; Pop& operator=(Pop const&) = delete; Pop& operator=(Pop&&) = delete; @@ -89,6 +92,8 @@ namespace OpenVic { void setup_pop_test_values( IdeologyManager const& ideology_manager, IssueManager const& issue_manager, CountryDefinition const& country ); + + void set_location(ProvinceInstance const& new_location); }; struct Strata : HasIdentifier { @@ -319,8 +324,8 @@ namespace OpenVic { bool load_pop_type_chances_file(ast::NodeCPtr root); - bool load_pop_into_vector( - RebelManager const& rebel_manager, std::vector& vec, PopType const& type, ast::NodeCPtr pop_node, + bool load_pop_bases_into_vector( + RebelManager const& rebel_manager, std::vector& vec, PopType const& type, ast::NodeCPtr pop_node, bool *non_integer_size ) const; -- cgit v1.2.3-56-ga3b1