diff options
18 files changed, 400 insertions, 253 deletions
diff --git a/src/openvic-simulation/country/Country.cpp b/src/openvic-simulation/country/Country.cpp index 2b022b0..604e11f 100644 --- a/src/openvic-simulation/country/Country.cpp +++ b/src/openvic-simulation/country/Country.cpp @@ -196,9 +196,9 @@ bool CountryManager::load_country_data_file( ), "party", ZERO_OR_MORE, load_country_party(game_manager.get_politics_manager(), parties), "unit_names", ZERO_OR_ONE, - game_manager.get_military_manager().get_unit_manager().expect_unit_dictionary_reserve_length( + game_manager.get_military_manager().get_unit_type_manager().expect_unit_type_dictionary_reserve_length( unit_names, - [&unit_names](Unit const& unit, ast::NodeCPtr value) -> bool { + [&unit_names](UnitType const& unit, ast::NodeCPtr value) -> bool { return name_list_callback(map_callback(unit_names, &unit))(value); } ) diff --git a/src/openvic-simulation/country/Country.hpp b/src/openvic-simulation/country/Country.hpp index fd6fa7e..f115489 100644 --- a/src/openvic-simulation/country/Country.hpp +++ b/src/openvic-simulation/country/Country.hpp @@ -10,7 +10,7 @@ #include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp> #include "openvic-simulation/dataloader/Dataloader.hpp" -#include "openvic-simulation/military/Unit.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" @@ -51,7 +51,7 @@ namespace OpenVic { struct Country : HasIdentifierAndColour { friend struct CountryManager; - using unit_names_map_t = ordered_map<Unit const*, name_list_t>; + using unit_names_map_t = ordered_map<UnitType const*, name_list_t>; using government_colour_map_t = ordered_map<GovernmentType const*, colour_t>; private: diff --git a/src/openvic-simulation/dataloader/Dataloader.cpp b/src/openvic-simulation/dataloader/Dataloader.cpp index 9df9725..d01f6ff 100644 --- a/src/openvic-simulation/dataloader/Dataloader.cpp +++ b/src/openvic-simulation/dataloader/Dataloader.cpp @@ -358,16 +358,16 @@ bool Dataloader::_load_pop_types(GameManager& game_manager) { bool Dataloader::_load_units(GameManager& game_manager) const { static constexpr std::string_view units_directory = "units"; - UnitManager& unit_manager = game_manager.get_military_manager().get_unit_manager(); + UnitTypeManager& unit_type_manager = game_manager.get_military_manager().get_unit_type_manager(); const path_vector_t unit_files = lookup_files_in_dir(units_directory, ".txt"); - unit_manager.reserve_all_units(unit_files.size()); + unit_type_manager.reserve_all_unit_types(unit_files.size()); bool ret = apply_to_files( unit_files, - [&game_manager, &unit_manager](fs::path const& file) -> bool { - return unit_manager.load_unit_file( + [&game_manager, &unit_type_manager](fs::path const& file) -> bool { + return unit_type_manager.load_unit_type_file( game_manager.get_economy_manager().get_good_manager(), game_manager.get_map().get_terrain_type_manager(), game_manager.get_modifier_manager(), @@ -376,9 +376,9 @@ bool Dataloader::_load_units(GameManager& game_manager) const { } ); - unit_manager.lock_all_units(); + unit_type_manager.lock_all_unit_types(); - if (!unit_manager.generate_modifiers(game_manager.get_modifier_manager())) { + if (!unit_type_manager.generate_modifiers(game_manager.get_modifier_manager())) { Logger::error("Failed to generate unit-based modifiers!"); ret = false; } @@ -449,7 +449,7 @@ bool Dataloader::_load_technologies(GameManager& game_manager) { [this, &game_manager, &technology_manager, &modifier_manager](fs::path const& file) -> bool { return technology_manager.load_technologies_file( modifier_manager, - game_manager.get_military_manager().get_unit_manager(), + game_manager.get_military_manager().get_unit_type_manager(), game_manager.get_economy_manager().get_building_type_manager(), parse_defines_cached(file).get_file_node() ); @@ -476,7 +476,7 @@ bool Dataloader::_load_inventions(GameManager& game_manager) { [this, &game_manager, &invention_manager](fs::path const& file) -> bool { return invention_manager.load_inventions_file( game_manager.get_modifier_manager(), - game_manager.get_military_manager().get_unit_manager(), + game_manager.get_military_manager().get_unit_type_manager(), game_manager.get_economy_manager().get_building_type_manager(), game_manager.get_crime_manager(), parse_defines_cached(file).get_file_node() @@ -932,7 +932,7 @@ bool Dataloader::load_defines(GameManager& game_manager) { ret = false; } if (!game_manager.get_pop_manager().load_delayed_parse_pop_type_data( - game_manager.get_military_manager().get_unit_manager(), + game_manager.get_military_manager().get_unit_type_manager(), game_manager.get_politics_manager().get_issue_manager() )) { Logger::error("Failed to load delayed parse pop type data (promotion and issue weights)!"); diff --git a/src/openvic-simulation/military/Deployment.cpp b/src/openvic-simulation/military/Deployment.cpp index 4e2693d..903df3a 100644 --- a/src/openvic-simulation/military/Deployment.cpp +++ b/src/openvic-simulation/military/Deployment.cpp @@ -5,31 +5,25 @@ using namespace OpenVic; using namespace OpenVic::NodeTools; -Leader::Leader( - std::string_view new_name, Unit::branch_t new_branch, Date new_date, LeaderTrait const* new_personality, - LeaderTrait const* new_background, fixed_point_t new_prestige, std::string_view new_picture -) : name { new_name }, branch { new_branch }, date { new_date }, personality { new_personality }, background { new_background }, - prestige { new_prestige }, picture { new_picture } {} - -Regiment::Regiment(std::string_view new_name, LandUnit const* new_type, Province const* new_home) +RegimentDeployment::RegimentDeployment(std::string_view new_name, RegimentType const* new_type, Province const* new_home) : name { new_name }, type { new_type }, home { new_home } {} -Ship::Ship(std::string_view new_name, NavalUnit const* new_type) : name { new_name }, type { new_type } {} +ShipDeployment::ShipDeployment(std::string_view new_name, ShipType const* new_type) : name { new_name }, type { new_type } {} -Army::Army(std::string_view new_name, Province const* new_location, std::vector<Regiment>&& new_regiments) +ArmyDeployment::ArmyDeployment(std::string_view new_name, Province const* new_location, std::vector<RegimentDeployment>&& new_regiments) : name { new_name }, location { new_location }, regiments { std::move(new_regiments) } {} -Navy::Navy(std::string_view new_name, Province const* new_location, std::vector<Ship>&& new_ships) +NavyDeployment::NavyDeployment(std::string_view new_name, Province const* new_location, std::vector<ShipDeployment>&& new_ships) : name { new_name }, location { new_location }, ships { std::move(new_ships) } {} Deployment::Deployment( - std::string_view new_path, std::vector<Army>&& new_armies, std::vector<Navy>&& new_navies, + std::string_view new_path, std::vector<ArmyDeployment>&& new_armies, std::vector<NavyDeployment>&& new_navies, std::vector<Leader>&& new_leaders ) : HasIdentifier { new_path }, armies { std::move(new_armies) }, navies { std::move(new_navies) }, leaders { std::move(new_leaders) } {} bool DeploymentManager::add_deployment( - std::string_view path, std::vector<Army>&& armies, std::vector<Navy>&& navies, std::vector<Leader>&& leaders + std::string_view path, std::vector<ArmyDeployment>&& armies, std::vector<NavyDeployment>&& navies, std::vector<Leader>&& leaders ) { if (path.empty()) { Logger::error("Attemped to load order of battle with no path! Something is very wrong!"); @@ -64,14 +58,14 @@ bool DeploymentManager::load_oob_file( return true; } } - std::vector<Army> armies; - std::vector<Navy> navies; + std::vector<ArmyDeployment> armies; + std::vector<NavyDeployment> navies; std::vector<Leader> leaders; bool ret = expect_dictionary_keys_and_default( key_value_success_callback, // TODO: load SOI information "leader", ZERO_OR_MORE, [&leaders, &game_manager](ast::NodeCPtr node) -> bool { std::string_view leader_name {}; - Unit::branch_t leader_branch = Unit::branch_t::INVALID_BRANCH; + UnitType::branch_t leader_branch = UnitType::branch_t::INVALID_BRANCH; Date leader_date {}; LeaderTrait const* leader_personality = nullptr; LeaderTrait const* leader_background = nullptr; @@ -81,7 +75,7 @@ bool DeploymentManager::load_oob_file( bool ret = expect_dictionary_keys( "name", ONE_EXACTLY, expect_identifier_or_string(assign_variable_callback(leader_name)), "date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(leader_date)), - "type", ONE_EXACTLY, UnitManager::expect_branch_identifier(assign_variable_callback(leader_branch)), + "type", ONE_EXACTLY, UnitTypeManager::expect_branch_identifier(assign_variable_callback(leader_branch)), "personality", ONE_EXACTLY, game_manager.get_military_manager().get_leader_trait_manager().expect_leader_trait_identifier_or_string( assign_variable_callback_pointer(leader_personality) @@ -116,7 +110,7 @@ bool DeploymentManager::load_oob_file( "army", ZERO_OR_MORE, [&armies, &game_manager](ast::NodeCPtr node) -> bool { std::string_view army_name {}; Province const* army_location = nullptr; - std::vector<Regiment> army_regiments {}; + std::vector<RegimentDeployment> army_regiments {}; const bool ret = expect_dictionary_keys( "name", ONE_EXACTLY, expect_string(assign_variable_callback(army_name)), @@ -124,17 +118,17 @@ bool DeploymentManager::load_oob_file( game_manager.get_map().expect_province_identifier(assign_variable_callback_pointer(army_location)), "regiment", ONE_OR_MORE, [&game_manager, &army_regiments](ast::NodeCPtr node) -> bool { std::string_view regiment_name {}; - LandUnit const* regiment_type = nullptr; + RegimentType const* regiment_type = nullptr; Province const* regiment_home = nullptr; const bool ret = expect_dictionary_keys( "name", ONE_EXACTLY, expect_string(assign_variable_callback(regiment_name)), - "type", ONE_EXACTLY, game_manager.get_military_manager().get_unit_manager() - .expect_land_unit_identifier(assign_variable_callback_pointer(regiment_type)), + "type", ONE_EXACTLY, game_manager.get_military_manager().get_unit_type_manager() + .expect_regiment_type_identifier(assign_variable_callback_pointer(regiment_type)), "home", ZERO_OR_ONE, game_manager.get_map() .expect_province_identifier(assign_variable_callback_pointer(regiment_home)) )(node); if (regiment_home == nullptr) { - Logger::warning("Regiment ", regiment_name, " has no home province!"); + Logger::warning("RegimentDeployment ", regiment_name, " has no home province!"); } army_regiments.emplace_back(regiment_name, regiment_type, regiment_home); return ret; @@ -148,7 +142,7 @@ bool DeploymentManager::load_oob_file( "navy", ZERO_OR_MORE, [&navies, &game_manager](ast::NodeCPtr node) -> bool { std::string_view navy_name {}; Province const* navy_location = nullptr; - std::vector<Ship> navy_ships {}; + std::vector<ShipDeployment> navy_ships {}; const bool ret = expect_dictionary_keys( "name", ONE_EXACTLY, expect_string(assign_variable_callback(navy_name)), @@ -156,11 +150,11 @@ bool DeploymentManager::load_oob_file( game_manager.get_map().expect_province_identifier(assign_variable_callback_pointer(navy_location)), "ship", ONE_OR_MORE, [&game_manager, &navy_ships](ast::NodeCPtr node) -> bool { std::string_view ship_name {}; - NavalUnit const* ship_type = nullptr; + ShipType const* ship_type = nullptr; const bool ret = expect_dictionary_keys( "name", ONE_EXACTLY, expect_string(assign_variable_callback(ship_name)), - "type", ONE_EXACTLY, game_manager.get_military_manager().get_unit_manager() - .expect_naval_unit_identifier(assign_variable_callback_pointer(ship_type)) + "type", ONE_EXACTLY, game_manager.get_military_manager().get_unit_type_manager() + .expect_ship_type_identifier(assign_variable_callback_pointer(ship_type)) )(node); navy_ships.emplace_back(ship_name, ship_type); return ret; diff --git a/src/openvic-simulation/military/Deployment.hpp b/src/openvic-simulation/military/Deployment.hpp index e774108..742914d 100644 --- a/src/openvic-simulation/military/Deployment.hpp +++ b/src/openvic-simulation/military/Deployment.hpp @@ -5,82 +5,62 @@ #include <vector> #include "openvic-simulation/dataloader/Dataloader.hpp" -#include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/map/Province.hpp" -#include "openvic-simulation/military/LeaderTrait.hpp" -#include "openvic-simulation/military/Unit.hpp" -#include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/fixed_point/FixedPoint.hpp" +#include "openvic-simulation/military/Leader.hpp" +#include "openvic-simulation/military/UnitType.hpp" namespace OpenVic { - struct Leader { + struct RegimentDeployment { private: - std::string PROPERTY(name); - Unit::branch_t PROPERTY(branch); /* type in defines */ - Date PROPERTY(date); - LeaderTrait const* PROPERTY(personality); - LeaderTrait const* PROPERTY(background); - fixed_point_t PROPERTY(prestige); - std::string PROPERTY(picture); - - public: - Leader( - std::string_view new_name, Unit::branch_t new_branch, Date new_date, LeaderTrait const* new_personality, - LeaderTrait const* new_background, fixed_point_t new_prestige, std::string_view new_picture - ); - }; - - struct Regiment { - private: - std::string PROPERTY(name); - LandUnit const* PROPERTY(type); + std::string PROPERTY(name); + RegimentType const* PROPERTY(type); Province const* PROPERTY(home); public: - Regiment(std::string_view new_name, LandUnit const* new_type, Province const* new_home); + RegimentDeployment(std::string_view new_name, RegimentType const* new_type, Province const* new_home); }; - struct Ship { + struct ShipDeployment { private: - std::string PROPERTY(name); - NavalUnit const* PROPERTY(type); + std::string PROPERTY(name); + ShipType const* PROPERTY(type); public: - Ship(std::string_view new_name, NavalUnit const* new_type); + ShipDeployment(std::string_view new_name, ShipType const* new_type); }; - struct Army { + struct ArmyDeployment { private: - std::string PROPERTY(name); - Province const* PROPERTY(location); - std::vector<Regiment> PROPERTY(regiments); + std::string PROPERTY(name); + Province const* PROPERTY(location); + std::vector<RegimentDeployment> PROPERTY(regiments); public: - Army(std::string_view new_name, Province const* new_location, std::vector<Regiment>&& new_regiments); + ArmyDeployment(std::string_view new_name, Province const* new_location, std::vector<RegimentDeployment>&& new_regiments); }; - struct Navy { + struct NavyDeployment { private: - std::string PROPERTY(name); - Province const* PROPERTY(location); - std::vector<Ship> PROPERTY(ships); + std::string PROPERTY(name); + Province const* PROPERTY(location); + std::vector<ShipDeployment> PROPERTY(ships); public: - Navy(std::string_view new_name, Province const* new_location, std::vector<Ship>&& new_ships); + NavyDeployment(std::string_view new_name, Province const* new_location, std::vector<ShipDeployment>&& new_ships); }; struct Deployment : HasIdentifier { friend std::unique_ptr<Deployment> std::make_unique<Deployment>( - std::string_view&&, std::vector<OpenVic::Army>&&, std::vector<OpenVic::Navy>&&, std::vector<OpenVic::Leader>&& + std::string_view&&, std::vector<OpenVic::ArmyDeployment>&&, std::vector<OpenVic::NavyDeployment>&&, std::vector<OpenVic::Leader>&& ); private: - std::vector<Army> PROPERTY(armies); - std::vector<Navy> PROPERTY(navies); + std::vector<ArmyDeployment> PROPERTY(armies); + std::vector<NavyDeployment> PROPERTY(navies); std::vector<Leader> PROPERTY(leaders); Deployment( - std::string_view new_path, std::vector<Army>&& new_armies, std::vector<Navy>&& new_navies, + std::string_view new_path, std::vector<ArmyDeployment>&& new_armies, std::vector<NavyDeployment>&& new_navies, std::vector<Leader>&& new_leaders ); @@ -95,7 +75,7 @@ namespace OpenVic { public: bool add_deployment( - std::string_view path, std::vector<Army>&& armies, std::vector<Navy>&& navies, std::vector<Leader>&& leaders + std::string_view path, std::vector<ArmyDeployment>&& armies, std::vector<NavyDeployment>&& navies, std::vector<Leader>&& leaders ); bool load_oob_file( diff --git a/src/openvic-simulation/military/Leader.cpp b/src/openvic-simulation/military/Leader.cpp new file mode 100644 index 0000000..d6be36f --- /dev/null +++ b/src/openvic-simulation/military/Leader.cpp @@ -0,0 +1,9 @@ +#include "Leader.hpp" + +using namespace OpenVic; + +Leader::Leader( + std::string_view new_name, UnitType::branch_t new_branch, Date new_date, LeaderTrait const* new_personality, + LeaderTrait const* new_background, fixed_point_t new_prestige, std::string_view new_picture +) : name { new_name }, branch { new_branch }, date { new_date }, personality { new_personality }, background { new_background }, + prestige { new_prestige }, picture { new_picture } {}
\ No newline at end of file diff --git a/src/openvic-simulation/military/Leader.hpp b/src/openvic-simulation/military/Leader.hpp new file mode 100644 index 0000000..180fd39 --- /dev/null +++ b/src/openvic-simulation/military/Leader.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "openvic-simulation/military/LeaderTrait.hpp" +#include "openvic-simulation/military/UnitType.hpp" + +namespace OpenVic { + struct Leader { + private: + std::string PROPERTY(name); + UnitType::branch_t PROPERTY(branch); /* type in defines */ + Date PROPERTY(date); + LeaderTrait const* PROPERTY(personality); + LeaderTrait const* PROPERTY(background); + fixed_point_t PROPERTY(prestige); + std::string PROPERTY(picture); + + public: + Leader( + std::string_view new_name, UnitType::branch_t new_branch, Date new_date, LeaderTrait const* new_personality, + LeaderTrait const* new_background, fixed_point_t new_prestige, std::string_view new_picture + ); + }; +}
\ No newline at end of file diff --git a/src/openvic-simulation/military/MilitaryManager.hpp b/src/openvic-simulation/military/MilitaryManager.hpp index 2efa3ea..343d789 100644 --- a/src/openvic-simulation/military/MilitaryManager.hpp +++ b/src/openvic-simulation/military/MilitaryManager.hpp @@ -2,13 +2,13 @@ #include "openvic-simulation/military/Deployment.hpp" #include "openvic-simulation/military/LeaderTrait.hpp" -#include "openvic-simulation/military/Unit.hpp" +#include "openvic-simulation/military/UnitType.hpp" #include "openvic-simulation/military/Wargoal.hpp" namespace OpenVic { struct MilitaryManager { private: - UnitManager PROPERTY_REF(unit_manager); + UnitTypeManager PROPERTY_REF(unit_type_manager); LeaderTraitManager PROPERTY_REF(leader_trait_manager); DeploymentManager PROPERTY_REF(deployment_manager); WargoalTypeManager PROPERTY_REF(wargoal_type_manager); diff --git a/src/openvic-simulation/military/UnitInstance.cpp b/src/openvic-simulation/military/UnitInstance.cpp new file mode 100644 index 0000000..7927b0f --- /dev/null +++ b/src/openvic-simulation/military/UnitInstance.cpp @@ -0,0 +1,31 @@ +#include "UnitInstance.hpp" +#include <vector> +#include "openvic-simulation/military/UnitType.hpp" + +using namespace OpenVic; + +RegimentInstance::RegimentInstance(std::string_view new_name, RegimentType const& new_regiment_type, Pop& new_pop) + : UnitInstance { new_name, new_regiment_type }, pop { new_pop } {} + +ShipInstance::ShipInstance(std::string_view new_name, ShipType const& new_ship_type) + : UnitInstance { new_name, new_ship_type } {} + +MovementInfo::MovementInfo() : path {}, movement_progress {} {} + +//TODO: pathfinding logic +MovementInfo::MovementInfo(Province const* starting_province, Province const* target_province) + : path { std::vector { starting_province, target_province } }, movement_progress { 0 } {} + +ArmyInstance::ArmyInstance( + std::string_view new_name, + std::vector<RegimentInstance*>&& new_units, + Leader const* new_leader, + Province const* new_position +) : UnitInstanceGroup { new_name, UnitType::branch_t::LAND, std::move(new_units), new_leader, new_position } {} + +NavyInstance::NavyInstance( + std::string_view new_name, + std::vector<ShipInstance*>&& new_units, + Leader const* new_leader, + Province const* new_position +) : UnitInstanceGroup { new_name, UnitType::branch_t::NAVAL, std::move(new_units), new_leader, new_position } {}
\ No newline at end of file diff --git a/src/openvic-simulation/military/UnitInstance.hpp b/src/openvic-simulation/military/UnitInstance.hpp new file mode 100644 index 0000000..dcca18a --- /dev/null +++ b/src/openvic-simulation/military/UnitInstance.hpp @@ -0,0 +1,110 @@ +#pragma once + +#include <concepts> +#include <string_view> +#include <vector> +#include "openvic-simulation/map/Province.hpp" +#include "openvic-simulation/military/Leader.hpp" +#include "openvic-simulation/military/UnitType.hpp" +#include "openvic-simulation/types/fixed_point/FixedPoint.hpp" + +namespace OpenVic { + template<std::derived_from<UnitType> T> + struct UnitInstance { + protected: + std::string PROPERTY(unit_name); + T const& PROPERTY(unit_type); //can't change + + fixed_point_t PROPERTY_RW(organisation); + fixed_point_t PROPERTY_RW(morale); + fixed_point_t PROPERTY_RW(strength); + + protected: + UnitInstance(std::string_view new_unit_name, T const& new_unit_type) : + unit_name { new_unit_name }, + unit_type { new_unit_type }, + organisation { new_unit_type.get_default_organisation() }, //TODO: modifiers + morale { 0 }, //TODO: modifiers + strength { new_unit_type.get_max_strength() } {} + public: + void set_unit_name(std::string_view new_unit_name) { + unit_name = new_unit_name; + } + }; + + struct RegimentInstance : UnitInstance<RegimentType> { + private: + Pop& PROPERTY(pop); + + public: + RegimentInstance(std::string_view new_name, RegimentType const& new_regiment_type, Pop& new_pop); + }; + + struct ShipInstance : UnitInstance<ShipType> { + public: + ShipInstance(std::string_view new_name, ShipType const& new_ship_type); + }; + + struct MovementInfo { + private: + std::vector<Province const*> PROPERTY(path); + fixed_point_t PROPERTY(movement_progress); + + public: + MovementInfo(); + MovementInfo(Province const* starting_province, Province const* target_province); // contains/calls pathfinding logic + }; + + template<utility::is_derived_from_specialization_of<UnitInstance> I> + struct UnitInstanceGroup { + private: + std::string PROPERTY(name); + const UnitType::branch_t PROPERTY(branch); + std::vector<I*> PROPERTY(units); + Leader const* PROPERTY_RW(leader); + Province const* PROPERTY_RW(position); + + MovementInfo PROPERTY_REF(movement_info); + + protected: + UnitInstanceGroup( + std::string_view new_name, + UnitType::branch_t new_branch, + std::vector<I*>&& new_units, + Leader const* new_leader, + Province const* new_position + ) : name { new_name }, + branch { new_branch }, + units { std::move(new_units) }, + leader { new_leader }, + position { new_position } {} + + public: + void set_name(std::string_view new_name) { + name = new_name; + } + }; + + struct ArmyInstance : UnitInstanceGroup<RegimentInstance> { + public: + ArmyInstance( + std::string_view new_name, + std::vector<RegimentInstance*>&& new_units, + Leader const* new_leader, + Province const* new_position + ); + }; + + struct NavyInstance : UnitInstanceGroup<ShipInstance> { + private: + std::vector<ArmyInstance const*> PROPERTY(carried_armies); + + public: + NavyInstance( + std::string_view new_name, + std::vector<ShipInstance*>&& new_ships, + Leader const* new_leader, + Province const* new_position + ); + }; +}
\ No newline at end of file diff --git a/src/openvic-simulation/military/Unit.cpp b/src/openvic-simulation/military/UnitType.cpp index 54fc763..1fafe35 100644 --- a/src/openvic-simulation/military/Unit.cpp +++ b/src/openvic-simulation/military/UnitType.cpp @@ -1,21 +1,21 @@ -#include "Unit.hpp" +#include "UnitType.hpp" #include "openvic-simulation/map/TerrainType.hpp" using namespace OpenVic; using namespace OpenVic::NodeTools; -using enum Unit::branch_t; -using enum Unit::unit_type_t; +using enum UnitType::branch_t; +using enum UnitType::unit_category_t; -Unit::Unit( - std::string_view new_identifier, branch_t new_branch, unit_args_t& unit_args +UnitType::UnitType( + std::string_view new_identifier, branch_t new_branch, unit_type_args_t& unit_args ) : HasIdentifier { new_identifier }, branch { new_branch }, icon { unit_args.icon }, sprite { unit_args.sprite }, active { unit_args.active }, - unit_type { unit_args.unit_type }, + unit_category { unit_args.unit_category }, floating_flag { unit_args.floating_flag }, priority { unit_args.priority }, max_strength { unit_args.max_strength }, @@ -30,52 +30,52 @@ Unit::Unit( supply_cost { std::move(unit_args.supply_cost) }, terrain_modifiers { std::move(unit_args.terrain_modifiers) } {} -LandUnit::LandUnit( - std::string_view new_identifier, unit_args_t& unit_args, land_unit_args_t const& land_unit_args -) : Unit { new_identifier, LAND, unit_args }, - allowed_cultures { land_unit_args.allowed_cultures }, - sprite_override { land_unit_args.sprite_override }, - sprite_mount { land_unit_args.sprite_mount }, - sprite_mount_attach_node { land_unit_args.sprite_mount_attach_node }, - reconnaissance { land_unit_args.reconnaissance }, - attack { land_unit_args.attack }, - defence { land_unit_args.defence }, - discipline { land_unit_args.discipline }, - support { land_unit_args.support }, - maneuver { land_unit_args.maneuver }, - siege { land_unit_args.siege } {} - -NavalUnit::NavalUnit( - std::string_view new_identifier, unit_args_t& unit_args, naval_unit_args_t const& naval_unit_args -) : Unit { new_identifier, NAVAL, unit_args }, - naval_icon { naval_unit_args.naval_icon }, - sail { naval_unit_args.sail }, - transport { naval_unit_args.transport }, - capital { naval_unit_args.capital }, - colonial_points { naval_unit_args.colonial_points }, - build_overseas { naval_unit_args.build_overseas }, - min_port_level { naval_unit_args.min_port_level }, - limit_per_port { naval_unit_args.limit_per_port }, - supply_consumption_score { naval_unit_args.supply_consumption_score }, - hull { naval_unit_args.hull }, - gun_power { naval_unit_args.gun_power }, - fire_range { naval_unit_args.fire_range }, - evasion { naval_unit_args.evasion }, - torpedo_attack { naval_unit_args.torpedo_attack } {} - -void UnitManager::reserve_all_units(size_t size) { - reserve_more_units(size); - reserve_more_land_units(size); - reserve_more_naval_units(size); +RegimentType::RegimentType( + std::string_view new_identifier, unit_type_args_t& unit_args, regiment_type_args_t const& regiment_type_args +) : UnitType { new_identifier, LAND, unit_args }, + allowed_cultures { regiment_type_args.allowed_cultures }, + sprite_override { regiment_type_args.sprite_override }, + sprite_mount { regiment_type_args.sprite_mount }, + sprite_mount_attach_node { regiment_type_args.sprite_mount_attach_node }, + reconnaissance { regiment_type_args.reconnaissance }, + attack { regiment_type_args.attack }, + defence { regiment_type_args.defence }, + discipline { regiment_type_args.discipline }, + support { regiment_type_args.support }, + maneuver { regiment_type_args.maneuver }, + siege { regiment_type_args.siege } {} + +ShipType::ShipType( + std::string_view new_identifier, unit_type_args_t& unit_args, ship_type_args_t const& ship_type_args +) : UnitType { new_identifier, NAVAL, unit_args }, + naval_icon { ship_type_args.naval_icon }, + sail { ship_type_args.sail }, + transport { ship_type_args.transport }, + capital { ship_type_args.capital }, + colonial_points { ship_type_args.colonial_points }, + build_overseas { ship_type_args.build_overseas }, + min_port_level { ship_type_args.min_port_level }, + limit_per_port { ship_type_args.limit_per_port }, + supply_consumption_score { ship_type_args.supply_consumption_score }, + hull { ship_type_args.hull }, + gun_power { ship_type_args.gun_power }, + fire_range { ship_type_args.fire_range }, + evasion { ship_type_args.evasion }, + torpedo_attack { ship_type_args.torpedo_attack } {} + +void UnitTypeManager::reserve_all_unit_types(size_t size) { + reserve_more_unit_types(size); + reserve_more_regiment_types(size); + reserve_more_ship_types(size); } -void UnitManager::lock_all_units() { - units.lock(); - land_units.lock(); - naval_units.lock(); +void UnitTypeManager::lock_all_unit_types() { + unit_types.lock(); + regiment_types.lock(); + ship_types.lock(); } -static bool _check_shared_parameters(std::string_view identifier, Unit::unit_args_t const& unit_args) { +static bool _check_shared_parameters(std::string_view identifier, UnitType::unit_type_args_t const& unit_args) { if (identifier.empty()) { Logger::error("Invalid unit identifier - empty!"); return false; @@ -86,7 +86,7 @@ static bool _check_shared_parameters(std::string_view identifier, Unit::unit_arg return false; } - if (unit_args.unit_type == INVALID_UNIT_TYPE) { + if (unit_args.unit_category == INVALID_UNIT_CATEGORY) { Logger::error("Invalid unit type for unit ", identifier, "!"); return false; } @@ -96,8 +96,8 @@ static bool _check_shared_parameters(std::string_view identifier, Unit::unit_arg return true; } -bool UnitManager::add_land_unit( - std::string_view identifier, Unit::unit_args_t& unit_args, LandUnit::land_unit_args_t const& land_unit_args +bool UnitTypeManager::add_regiment_type( + std::string_view identifier, UnitType::unit_type_args_t& unit_args, RegimentType::regiment_type_args_t const& regiment_type_args ) { if (!_check_shared_parameters(identifier, unit_args)) { return false; @@ -105,47 +105,47 @@ bool UnitManager::add_land_unit( // TODO check that sprite_override, sprite_mount, and sprite_mount_attach_node exist - if (naval_units.has_identifier(identifier)) { + if (ship_types.has_identifier(identifier)) { Logger::error("Land unit ", identifier, " already exists as a naval unit!"); return false; } - bool ret = land_units.add_item({ identifier, unit_args, std::move(land_unit_args) }); + bool ret = regiment_types.add_item({ identifier, unit_args, std::move(regiment_type_args) }); if (ret) { - ret &= units.add_item(&land_units.get_items().back()); + ret &= unit_types.add_item(®iment_types.get_items().back()); } return ret; } -bool UnitManager::add_naval_unit( - std::string_view identifier, Unit::unit_args_t& unit_args, NavalUnit::naval_unit_args_t const& naval_unit_args +bool UnitTypeManager::add_ship_type( + std::string_view identifier, UnitType::unit_type_args_t& unit_args, ShipType::ship_type_args_t const& ship_type_args ) { if (!_check_shared_parameters(identifier, unit_args)) { return false; } - if (naval_unit_args.naval_icon <= 0) { - Logger::error("Invalid naval icon identifier - ", naval_unit_args.naval_icon, " (must be positive)"); + if (ship_type_args.naval_icon <= 0) { + Logger::error("Invalid naval icon identifier - ", ship_type_args.naval_icon, " (must be positive)"); return false; } - if (naval_unit_args.supply_consumption_score <= 0) { + if (ship_type_args.supply_consumption_score <= 0) { Logger::warning("Supply consumption score for ", identifier, " is not positive!"); } - if (land_units.has_identifier(identifier)) { + if (regiment_types.has_identifier(identifier)) { Logger::error("Naval unit ", identifier, " already exists as a land unit!"); return false; } - bool ret = naval_units.add_item({ identifier, unit_args, naval_unit_args }); + bool ret = ship_types.add_item({ identifier, unit_args, ship_type_args }); if (ret) { - ret &= units.add_item(&naval_units.get_items().back()); + ret &= unit_types.add_item(&ship_types.get_items().back()); } return ret; } -bool UnitManager::load_unit_file( +bool UnitTypeManager::load_unit_type_file( GoodManager const& good_manager, TerrainTypeManager const& terrain_type_manager, ModifierManager const& modifier_manager, ast::NodeCPtr root ) { @@ -153,7 +153,7 @@ bool UnitManager::load_unit_file( std::string_view key, ast::NodeCPtr value ) -> bool { - Unit::branch_t branch = INVALID_BRANCH; + UnitType::branch_t branch = INVALID_BRANCH; bool ret = expect_key("type", expect_branch_identifier(assign_variable_callback(branch)))(value); @@ -164,9 +164,9 @@ bool UnitManager::load_unit_file( return false; } - Unit::unit_args_t unit_args {}; + UnitType::unit_type_args_t unit_args {}; - static const string_map_t<Unit::unit_type_t> unit_type_map { + static const string_map_t<UnitType::unit_category_t> unit_type_map { { "infantry", INFANTRY }, { "cavalry", CAVALRY }, { "support", SUPPORT }, @@ -184,7 +184,7 @@ bool UnitManager::load_unit_file( "sprite", ONE_EXACTLY, expect_identifier(assign_variable_callback(unit_args.sprite)), "active", ZERO_OR_ONE, expect_bool(assign_variable_callback(unit_args.active)), "unit_type", ONE_EXACTLY, - expect_identifier(expect_mapped_string(unit_type_map, assign_variable_callback(unit_args.unit_type))), + expect_identifier(expect_mapped_string(unit_type_map, assign_variable_callback(unit_args.unit_category))), "floating_flag", ONE_EXACTLY, expect_bool(assign_variable_callback(unit_args.floating_flag)), "priority", ONE_EXACTLY, expect_uint(assign_variable_callback(unit_args.priority)), "max_strength", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(unit_args.max_strength)), @@ -214,64 +214,64 @@ bool UnitManager::load_unit_file( switch (branch) { case LAND: { - LandUnit::land_unit_args_t land_unit_args {}; + RegimentType::regiment_type_args_t regiment_type_args {}; bool is_restricted_to_primary_culture = false; bool is_restricted_to_accepted_cultures = false; ret &= add_key_map_entries(key_map, "primary_culture", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_restricted_to_primary_culture)), "accepted_culture", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_restricted_to_accepted_cultures)), - "sprite_override", ZERO_OR_ONE, expect_identifier(assign_variable_callback(land_unit_args.sprite_override)), - "sprite_mount", ZERO_OR_ONE, expect_identifier(assign_variable_callback(land_unit_args.sprite_mount)), + "sprite_override", ZERO_OR_ONE, expect_identifier(assign_variable_callback(regiment_type_args.sprite_override)), + "sprite_mount", ZERO_OR_ONE, expect_identifier(assign_variable_callback(regiment_type_args.sprite_mount)), "sprite_mount_attach_node", ZERO_OR_ONE, - expect_identifier(assign_variable_callback(land_unit_args.sprite_mount_attach_node)), - "reconnaissance", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_unit_args.reconnaissance)), - "attack", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_unit_args.attack)), - "defence", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_unit_args.defence)), - "discipline", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_unit_args.discipline)), - "support", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_unit_args.support)), - "maneuver", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_unit_args.maneuver)), - "siege", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(land_unit_args.siege)) + expect_identifier(assign_variable_callback(regiment_type_args.sprite_mount_attach_node)), + "reconnaissance", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(regiment_type_args.reconnaissance)), + "attack", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(regiment_type_args.attack)), + "defence", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(regiment_type_args.defence)), + "discipline", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(regiment_type_args.discipline)), + "support", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(regiment_type_args.support)), + "maneuver", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(regiment_type_args.maneuver)), + "siege", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(regiment_type_args.siege)) ); if (is_restricted_to_accepted_cultures) { - land_unit_args.allowed_cultures = LandUnit::allowed_cultures_t::ACCEPTED_CULTURES; + regiment_type_args.allowed_cultures = RegimentType::allowed_cultures_t::ACCEPTED_CULTURES; } else if (is_restricted_to_primary_culture) { - land_unit_args.allowed_cultures = LandUnit::allowed_cultures_t::PRIMARY_CULTURE; + regiment_type_args.allowed_cultures = RegimentType::allowed_cultures_t::PRIMARY_CULTURE; } else { - land_unit_args.allowed_cultures = LandUnit::allowed_cultures_t::ALL_CULTURES; + regiment_type_args.allowed_cultures = RegimentType::allowed_cultures_t::ALL_CULTURES; } ret &= expect_dictionary_key_map_and_default(key_map, add_terrain_modifier)(value); - ret &= add_land_unit(key, unit_args, land_unit_args); + ret &= add_regiment_type(key, unit_args, regiment_type_args); return ret; } case NAVAL: { - NavalUnit::naval_unit_args_t naval_unit_args {}; + ShipType::ship_type_args_t ship_type_args {}; ret &= add_key_map_entries(key_map, - "naval_icon", ONE_EXACTLY, expect_uint(assign_variable_callback(naval_unit_args.naval_icon)), - "sail", ZERO_OR_ONE, expect_bool(assign_variable_callback(naval_unit_args.sail)), - "transport", ZERO_OR_ONE, expect_bool(assign_variable_callback(naval_unit_args.transport)), - "capital", ZERO_OR_ONE, expect_bool(assign_variable_callback(naval_unit_args.capital)), - "colonial_points", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(naval_unit_args.colonial_points)), - "can_build_overseas", ZERO_OR_ONE, expect_bool(assign_variable_callback(naval_unit_args.build_overseas)), - "min_port_level", ONE_EXACTLY, expect_uint(assign_variable_callback(naval_unit_args.min_port_level)), - "limit_per_port", ONE_EXACTLY, expect_int(assign_variable_callback(naval_unit_args.limit_per_port)), + "naval_icon", ONE_EXACTLY, expect_uint(assign_variable_callback(ship_type_args.naval_icon)), + "sail", ZERO_OR_ONE, expect_bool(assign_variable_callback(ship_type_args.sail)), + "transport", ZERO_OR_ONE, expect_bool(assign_variable_callback(ship_type_args.transport)), + "capital", ZERO_OR_ONE, expect_bool(assign_variable_callback(ship_type_args.capital)), + "colonial_points", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(ship_type_args.colonial_points)), + "can_build_overseas", ZERO_OR_ONE, expect_bool(assign_variable_callback(ship_type_args.build_overseas)), + "min_port_level", ONE_EXACTLY, expect_uint(assign_variable_callback(ship_type_args.min_port_level)), + "limit_per_port", ONE_EXACTLY, expect_int(assign_variable_callback(ship_type_args.limit_per_port)), "supply_consumption_score", ZERO_OR_ONE, - expect_fixed_point(assign_variable_callback(naval_unit_args.supply_consumption_score)), - "hull", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(naval_unit_args.hull)), - "gun_power", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(naval_unit_args.gun_power)), - "fire_range", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(naval_unit_args.fire_range)), - "evasion", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(naval_unit_args.evasion)), - "torpedo_attack", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(naval_unit_args.torpedo_attack)) + expect_fixed_point(assign_variable_callback(ship_type_args.supply_consumption_score)), + "hull", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(ship_type_args.hull)), + "gun_power", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(ship_type_args.gun_power)), + "fire_range", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(ship_type_args.fire_range)), + "evasion", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(ship_type_args.evasion)), + "torpedo_attack", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(ship_type_args.torpedo_attack)) ); ret &= expect_dictionary_key_map_and_default(key_map, add_terrain_modifier)(value); - ret &= add_naval_unit(key, unit_args, naval_unit_args); + ret &= add_ship_type(key, unit_args, ship_type_args); return ret; } @@ -283,10 +283,10 @@ bool UnitManager::load_unit_file( })(root); } -bool UnitManager::generate_modifiers(ModifierManager& modifier_manager) const { +bool UnitTypeManager::generate_modifiers(ModifierManager& modifier_manager) const { bool ret = true; - const auto generate_stat_modifiers = [&modifier_manager, &ret](std::string_view identifier, Unit::branch_t branch) -> void { + const auto generate_stat_modifiers = [&modifier_manager, &ret](std::string_view identifier, UnitType::branch_t branch) -> void { const auto stat_modifier = [&modifier_manager, &ret, &identifier]( std::string_view suffix, bool is_positive_good, ModifierEffect::format_t format ) -> void { @@ -324,19 +324,19 @@ bool UnitManager::generate_modifiers(ModifierManager& modifier_manager) const { stat_modifier("torpedo_attack", true, RAW_DECIMAL); break; default: - /* Unreachable - units are only added via add_land_unit or add_naval_unit which set branch to LAND or NAVAL. */ + /* Unreachable - unit types are only added via add_regiment_type or add_ship_type which set branch to LAND or NAVAL. */ Logger::error("Invalid branch for unit ", identifier, ": ", static_cast<int>(branch)); } }; generate_stat_modifiers("army_base", LAND); - for (LandUnit const& land_unit : get_land_units()) { - generate_stat_modifiers(land_unit.get_identifier(), LAND); + for (RegimentType const& regiment_type : get_regiment_types()) { + generate_stat_modifiers(regiment_type.get_identifier(), LAND); } generate_stat_modifiers("navy_base", NAVAL); - for (NavalUnit const& naval_unit : get_naval_units()) { - generate_stat_modifiers(naval_unit.get_identifier(), NAVAL); + for (ShipType const& ship_type : get_ship_types()) { + generate_stat_modifiers(ship_type.get_identifier(), NAVAL); } return ret; diff --git a/src/openvic-simulation/military/Unit.hpp b/src/openvic-simulation/military/UnitType.hpp index d1ee3e3..201708e 100644 --- a/src/openvic-simulation/military/Unit.hpp +++ b/src/openvic-simulation/military/UnitType.hpp @@ -14,18 +14,18 @@ namespace OpenVic { struct TerrainType; struct TerrainTypeManager; - struct Unit : HasIdentifier { + struct UnitType : HasIdentifier { using icon_t = uint32_t; using terrain_modifiers_t = ordered_map<TerrainType const*, ModifierValue>; enum struct branch_t : uint8_t { INVALID_BRANCH, LAND, NAVAL }; - enum struct unit_type_t : uint8_t { - INVALID_UNIT_TYPE, INFANTRY, CAVALRY, SUPPORT, SPECIAL, BIG_SHIP, LIGHT_SHIP, TRANSPORT + enum struct unit_category_t : uint8_t { + INVALID_UNIT_CATEGORY, INFANTRY, CAVALRY, SUPPORT, SPECIAL, BIG_SHIP, LIGHT_SHIP, TRANSPORT }; - struct unit_args_t { + struct unit_type_args_t { icon_t icon = 0; - unit_type_t unit_type = unit_type_t::INVALID_UNIT_TYPE; + unit_category_t unit_category = unit_category_t::INVALID_UNIT_CATEGORY; // TODO defaults for move_sound and select_sound std::string_view sprite, move_sound, select_sound; bool active = true, floating_flag = false; @@ -36,8 +36,8 @@ namespace OpenVic { Good::good_map_t build_cost, supply_cost; terrain_modifiers_t terrain_modifiers; - unit_args_t() = default; - unit_args_t(unit_args_t&&) = default; + unit_type_args_t() = default; + unit_type_args_t(unit_type_args_t&&) = default; }; private: @@ -45,7 +45,7 @@ namespace OpenVic { const icon_t PROPERTY(icon); std::string PROPERTY(sprite); const bool PROPERTY_CUSTOM_PREFIX(active, is); - unit_type_t PROPERTY(unit_type); + unit_category_t PROPERTY(unit_category); const bool PROPERTY_CUSTOM_PREFIX(floating_flag, has); const uint32_t PROPERTY(priority); @@ -66,27 +66,27 @@ namespace OpenVic { protected: /* Non-const reference unit_args so variables can be moved from it. */ - Unit(std::string_view new_identifier, branch_t new_branch, unit_args_t& unit_args); + UnitType(std::string_view new_identifier, branch_t new_branch, unit_type_args_t& unit_args); public: - Unit(Unit&&) = default; + UnitType(UnitType&&) = default; }; - struct LandUnit : Unit { - friend struct UnitManager; + struct RegimentType : UnitType { + friend struct UnitTypeManager; enum struct allowed_cultures_t { ALL_CULTURES, ACCEPTED_CULTURES, PRIMARY_CULTURE }; - struct land_unit_args_t { + struct regiment_type_args_t { allowed_cultures_t allowed_cultures = allowed_cultures_t::ALL_CULTURES; std::string_view sprite_override, sprite_mount, sprite_mount_attach_node; // TODO - represent these as modifier effects, so that they can be combined with tech, inventions, - // leader bonuses, etc. and applied to unit instances all in one go (same for NavalUnits below) + // leader bonuses, etc. and applied to unit instances all in one go (same for ShipTypes below) fixed_point_t reconnaissance = 0, attack = 0, defence = 0, discipline = 0, support = 0, maneuver = 0, siege = 0; - land_unit_args_t() = default; - land_unit_args_t(land_unit_args_t&&) = default; + regiment_type_args_t() = default; + regiment_type_args_t(regiment_type_args_t&&) = default; }; private: @@ -102,25 +102,25 @@ namespace OpenVic { const fixed_point_t PROPERTY(maneuver); const fixed_point_t PROPERTY(siege); - LandUnit(std::string_view new_identifier, unit_args_t& unit_args, land_unit_args_t const& land_unit_args); + RegimentType(std::string_view new_identifier, unit_type_args_t& unit_args, regiment_type_args_t const& regiment_type_args); public: - LandUnit(LandUnit&&) = default; + RegimentType(RegimentType&&) = default; }; - struct NavalUnit : Unit { - friend struct UnitManager; + struct ShipType : UnitType { + friend struct UnitTypeManager; - struct naval_unit_args_t { - Unit::icon_t naval_icon = 0; + struct ship_type_args_t { + UnitType::icon_t naval_icon = 0; bool sail = false, transport = false, capital = false, build_overseas = false; uint32_t min_port_level = 0; int32_t limit_per_port = 0; fixed_point_t colonial_points = 0, supply_consumption_score = 0, hull = 0, gun_power = 0, fire_range = 0, evasion = 0, torpedo_attack = 0; - naval_unit_args_t() = default; - naval_unit_args_t(naval_unit_args_t&&) = default; + ship_type_args_t() = default; + ship_type_args_t(ship_type_args_t&&) = default; }; private: @@ -140,39 +140,39 @@ namespace OpenVic { const fixed_point_t PROPERTY(evasion); const fixed_point_t PROPERTY(torpedo_attack); - NavalUnit(std::string_view new_identifier, unit_args_t& unit_args, naval_unit_args_t const& naval_unit_args); + ShipType(std::string_view new_identifier, unit_type_args_t& unit_args, ship_type_args_t const& ship_type_args); public: - NavalUnit(NavalUnit&&) = default; + ShipType(ShipType&&) = default; }; - struct UnitManager { + struct UnitTypeManager { private: - IdentifierPointerRegistry<Unit> IDENTIFIER_REGISTRY(unit); - IdentifierRegistry<LandUnit> IDENTIFIER_REGISTRY(land_unit); - IdentifierRegistry<NavalUnit> IDENTIFIER_REGISTRY(naval_unit); + IdentifierPointerRegistry<UnitType> IDENTIFIER_REGISTRY(unit_type); + IdentifierRegistry<RegimentType> IDENTIFIER_REGISTRY(regiment_type); + IdentifierRegistry<ShipType> IDENTIFIER_REGISTRY(ship_type); public: - void reserve_all_units(size_t size); - void lock_all_units(); + void reserve_all_unit_types(size_t size); + void lock_all_unit_types(); - bool add_land_unit( - std::string_view identifier, Unit::unit_args_t& unit_args, LandUnit::land_unit_args_t const& land_unit_args + bool add_regiment_type( + std::string_view identifier, UnitType::unit_type_args_t& unit_args, RegimentType::regiment_type_args_t const& regiment_type_args ); - bool add_naval_unit( - std::string_view identifier, Unit::unit_args_t& unit_args, NavalUnit::naval_unit_args_t const& naval_unit_args + bool add_ship_type( + std::string_view identifier, UnitType::unit_type_args_t& unit_args, ShipType::ship_type_args_t const& ship_type_args ); - static NodeTools::Callback<std::string_view> auto expect_branch_str(NodeTools::Callback<Unit::branch_t> auto callback) { - using enum Unit::branch_t; - static const string_map_t<Unit::branch_t> branch_map { { "land", LAND }, { "naval", NAVAL }, { "sea", NAVAL } }; + static NodeTools::Callback<std::string_view> auto expect_branch_str(NodeTools::Callback<UnitType::branch_t> auto callback) { + using enum UnitType::branch_t; + static const string_map_t<UnitType::branch_t> branch_map { { "land", LAND }, { "naval", NAVAL }, { "sea", NAVAL } }; return NodeTools::expect_mapped_string(branch_map, callback); } - static NodeTools::NodeCallback auto expect_branch_identifier(NodeTools::Callback<Unit::branch_t> auto callback) { + static NodeTools::NodeCallback auto expect_branch_identifier(NodeTools::Callback<UnitType::branch_t> auto callback) { return NodeTools::expect_identifier(expect_branch_str(callback)); } - bool load_unit_file( + bool load_unit_type_file( GoodManager const& good_manager, TerrainTypeManager const& terrain_type_manager, ModifierManager const& modifier_manager, ast::NodeCPtr root ); diff --git a/src/openvic-simulation/pop/Pop.cpp b/src/openvic-simulation/pop/Pop.cpp index 1701321..21aede8 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/military/Unit.hpp" +#include "openvic-simulation/military/UnitType.hpp" #include "openvic-simulation/politics/Ideology.hpp" #include "openvic-simulation/politics/Issue.hpp" #include "openvic-simulation/politics/Rebel.hpp" @@ -436,13 +436,13 @@ bool PopManager::load_pop_type_file( return ret; } -bool PopManager::load_delayed_parse_pop_type_data(UnitManager const& unit_manager, IssueManager const& issue_manager) { +bool PopManager::load_delayed_parse_pop_type_data(UnitTypeManager const& unit_type_manager, IssueManager const& issue_manager) { bool ret = true; for (size_t index = 0; index < delayed_parse_nodes.size(); ++index) { const auto [rebel_units, equivalent, promote_to_node, issues_node] = delayed_parse_nodes[index]; PopType* pop_type = pop_types.get_item_by_index(index); - if (rebel_units != nullptr && !unit_manager.expect_unit_decimal_map( + if (rebel_units != nullptr && !unit_type_manager.expect_unit_type_decimal_map( move_variable_callback(pop_type->rebel_units) )(rebel_units)) { Logger::error("Errors parsing rebel unit distribution for pop type ", pop_type, "!"); diff --git a/src/openvic-simulation/pop/Pop.hpp b/src/openvic-simulation/pop/Pop.hpp index cdecf44..c4e369f 100644 --- a/src/openvic-simulation/pop/Pop.hpp +++ b/src/openvic-simulation/pop/Pop.hpp @@ -15,8 +15,8 @@ namespace OpenVic { struct PopManager; struct PopType; - struct Unit; - struct UnitManager; + struct UnitType; + struct UnitTypeManager; struct RebelType; struct RebelManager; struct Ideology; @@ -97,7 +97,7 @@ namespace OpenVic { }; using sprite_t = uint8_t; - using rebel_units_t = fixed_point_map_t<Unit const*>; + using rebel_units_t = fixed_point_map_t<UnitType const*>; using poptype_weight_map_t = ordered_map<PopType const*, ConditionalWeight>; using ideology_weight_map_t = ordered_map<Ideology const*, ConditionalWeight>; using issue_weight_map_t = ordered_map<Issue const*, ConditionalWeight>; @@ -223,7 +223,7 @@ namespace OpenVic { /* Using strata/stratas instead of stratum/strata to avoid confusion. */ IdentifierRegistry<Strata> IDENTIFIER_REGISTRY(strata); IdentifierRegistry<PopType> IDENTIFIER_REGISTRY(pop_type); - /* - rebel_units require Units which require on PopTypes (Unit->Map->Building->ProductionType->PopType). + /* - rebel_units require UnitTypes which require on PopTypes (UnitType->Map->Building->ProductionType->PopType). * - equivalent and promote_to can't be parsed until after all PopTypes are registered. * - issues require Issues to be loaded, which themselves depend on pop strata. * To get around these circular dependencies, the nodes for these variables are stored here and parsed after the @@ -296,7 +296,7 @@ namespace OpenVic { std::string_view filestem, GoodManager const& good_manager, IdeologyManager const& ideology_manager, ast::NodeCPtr root ); - bool load_delayed_parse_pop_type_data(UnitManager const& unit_manager, IssueManager const& issue_manager); + bool load_delayed_parse_pop_type_data(UnitTypeManager const& unit_type_manager, IssueManager const& issue_manager); bool load_pop_type_chances_file(ast::NodeCPtr root); diff --git a/src/openvic-simulation/research/Invention.cpp b/src/openvic-simulation/research/Invention.cpp index 792dcba..0f92632 100644 --- a/src/openvic-simulation/research/Invention.cpp +++ b/src/openvic-simulation/research/Invention.cpp @@ -2,7 +2,7 @@ #include "openvic-simulation/economy/BuildingType.hpp" #include "openvic-simulation/map/Crime.hpp" -#include "openvic-simulation/military/Unit.hpp" +#include "openvic-simulation/military/UnitType.hpp" using namespace OpenVic; using namespace OpenVic::NodeTools; @@ -40,11 +40,11 @@ bool InventionManager::add_invention( } bool InventionManager::load_inventions_file( - ModifierManager const& modifier_manager, UnitManager const& unit_manager, BuildingTypeManager const& building_type_manager, + ModifierManager const& modifier_manager, UnitTypeManager const& unit_type_manager, BuildingTypeManager const& building_type_manager, CrimeManager const& crime_manager, ast::NodeCPtr root ) { return expect_dictionary_reserve_length( - inventions, [this, &modifier_manager, &unit_manager, &building_type_manager, &crime_manager]( + inventions, [this, &modifier_manager, &unit_type_manager, &building_type_manager, &crime_manager]( std::string_view identifier, ast::NodeCPtr value) -> bool { ModifierValue loose_modifiers; ModifierValue modifiers; @@ -68,7 +68,7 @@ bool InventionManager::load_inventions_file( move_variable_callback(modifiers), "gas_attack", ZERO_OR_ONE, expect_bool(assign_variable_callback(unlock_gas_attack)), "gas_defence", ZERO_OR_ONE, expect_bool(assign_variable_callback(unlock_gas_defence)), - "activate_unit", ZERO_OR_MORE, unit_manager.expect_unit_identifier(set_callback_pointer(activated_units)), + "activate_unit", ZERO_OR_MORE, unit_type_manager.expect_unit_type_identifier(set_callback_pointer(activated_units)), "activate_building", ZERO_OR_MORE, building_type_manager.expect_building_type_identifier( set_callback_pointer(activated_buildings) ), diff --git a/src/openvic-simulation/research/Invention.hpp b/src/openvic-simulation/research/Invention.hpp index 2b8100d..43a4e10 100644 --- a/src/openvic-simulation/research/Invention.hpp +++ b/src/openvic-simulation/research/Invention.hpp @@ -6,18 +6,18 @@ #include "openvic-simulation/types/OrderedContainers.hpp" namespace OpenVic { - struct Unit; + struct UnitType; struct BuildingType; struct Crime; - struct UnitManager; + struct UnitTypeManager; struct BuildingTypeManager; struct CrimeManager; struct Invention : Modifier { friend struct InventionManager; //TODO implement limit and chance - using unit_set_t = ordered_set<Unit const*>; + using unit_set_t = ordered_set<UnitType const*>; using building_set_t = ordered_set<BuildingType const*>; using crime_set_t = ordered_set<Crime const*>; @@ -54,7 +54,7 @@ namespace OpenVic { ); bool load_inventions_file( - ModifierManager const& modifier_manager, UnitManager const& unit_manager, + ModifierManager const& modifier_manager, UnitTypeManager const& unit_type_manager, BuildingTypeManager const& building_type_manager, CrimeManager const& crime_manager, ast::NodeCPtr root ); // inventions/*.txt diff --git a/src/openvic-simulation/research/Technology.cpp b/src/openvic-simulation/research/Technology.cpp index 00b736c..027268e 100644 --- a/src/openvic-simulation/research/Technology.cpp +++ b/src/openvic-simulation/research/Technology.cpp @@ -144,10 +144,10 @@ bool TechnologyManager::load_technology_file_schools( } bool TechnologyManager::load_technologies_file( - ModifierManager const& modifier_manager, UnitManager const& unit_manager, BuildingTypeManager const& building_type_manager, + ModifierManager const& modifier_manager, UnitTypeManager const& unit_type_manager, BuildingTypeManager const& building_type_manager, ast::NodeCPtr root ) { - return expect_dictionary_reserve_length(technologies, [this, &modifier_manager, &unit_manager, &building_type_manager]( + return expect_dictionary_reserve_length(technologies, [this, &modifier_manager, &unit_type_manager, &building_type_manager]( std::string_view tech_key, ast::NodeCPtr tech_value ) -> bool { ModifierValue modifiers; @@ -167,7 +167,7 @@ bool TechnologyManager::load_technologies_file( "cost", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(cost)), "unciv_military", ZERO_OR_ONE, expect_bool(assign_variable_callback(unciv_military)), "unit", ZERO_OR_ONE, expect_uint(assign_variable_callback(unit)), - "activate_unit", ZERO_OR_MORE, unit_manager.expect_unit_identifier(set_callback_pointer(activated_units)), + "activate_unit", ZERO_OR_MORE, unit_type_manager.expect_unit_type_identifier(set_callback_pointer(activated_units)), "activate_building", ZERO_OR_MORE, building_type_manager.expect_building_type_identifier( set_callback_pointer(activated_buildings) ), diff --git a/src/openvic-simulation/research/Technology.hpp b/src/openvic-simulation/research/Technology.hpp index aa47301..c67ebc0 100644 --- a/src/openvic-simulation/research/Technology.hpp +++ b/src/openvic-simulation/research/Technology.hpp @@ -3,7 +3,7 @@ #include <cstdint> #include "openvic-simulation/economy/BuildingType.hpp" -#include "openvic-simulation/military/Unit.hpp" +#include "openvic-simulation/military/UnitType.hpp" #include "openvic-simulation/misc/Modifier.hpp" #include "openvic-simulation/scripts/ConditionalWeight.hpp" #include "openvic-simulation/types/Date.hpp" @@ -42,7 +42,7 @@ namespace OpenVic { struct Technology : Modifier { friend struct TechnologyManager; - using unit_set_t = ordered_set<Unit const*>; + using unit_set_t = ordered_set<UnitType const*>; using building_set_t = ordered_set<BuildingType const*>; private: @@ -100,7 +100,7 @@ namespace OpenVic { /* Loaded from "technologies/.txt" files named after technology folders. */ bool load_technologies_file( - ModifierManager const& modifier_manager, UnitManager const& unit_manager, + ModifierManager const& modifier_manager, UnitTypeManager const& unit_type_manager, BuildingTypeManager const& building_type_manager, ast::NodeCPtr root ); |