diff options
Diffstat (limited to 'src/openvic')
26 files changed, 392 insertions, 409 deletions
diff --git a/src/openvic/GameManager.cpp b/src/openvic/GameManager.cpp index f9c9664..052b814 100644 --- a/src/openvic/GameManager.cpp +++ b/src/openvic/GameManager.cpp @@ -31,12 +31,12 @@ void GameManager::tick() { set_needs_update(); } -return_t GameManager::setup() { +bool GameManager::setup() { session_start = time(nullptr); clock.reset(); today = { 1836 }; good_manager.reset_to_defaults(); - return_t ret = map.setup(good_manager, building_manager, pop_manager); + bool ret = map.setup(good_manager, building_manager, pop_manager); set_needs_update(); return ret; } @@ -45,15 +45,18 @@ Date const& GameManager::get_today() const { return today; } -return_t GameManager::expand_building(Province::index_t province_index, const std::string_view building_type_identifier) { +bool GameManager::expand_building(Province::index_t province_index, const std::string_view building_type_identifier) { set_needs_update(); Province* province = map.get_province_by_index(province_index); - if (province == nullptr) return FAILURE; + if (province == nullptr) { + Logger::error("Invalid province index ", province_index, " while trying to expand building ", building_type_identifier); + return false; + } return province->expand_building(building_type_identifier); } -return_t GameManager::load_hardcoded_defines() { - return_t ret = SUCCESS; +bool GameManager::load_hardcoded_defines() { + bool ret = true; static constexpr colour_t LOW_ALPHA_VALUE = float_to_alpha_value(0.4f); static constexpr colour_t HIGH_ALPHA_VALUE = float_to_alpha_value(0.7f); @@ -114,8 +117,7 @@ return_t GameManager::load_hardcoded_defines() { } } }; for (mapmode_t const& mapmode : mapmodes) - if (map.add_mapmode(mapmode.first, mapmode.second) != SUCCESS) - ret = FAILURE; + ret &= map.add_mapmode(mapmode.first, mapmode.second); map.lock_mapmodes(); using building_type_t = std::tuple<std::string, Building::level_t, Timespan>; @@ -123,8 +125,7 @@ return_t GameManager::load_hardcoded_defines() { { "building_fort", 4, 8 }, { "building_naval_base", 6, 15 }, { "building_railroad", 5, 10 } }; for (building_type_t const& type : building_types) - if (building_manager.add_building_type(std::get<0>(type), std::get<1>(type), std::get<2>(type)) != SUCCESS) - ret = FAILURE; + ret &= building_manager.add_building_type(std::get<0>(type), std::get<1>(type), std::get<2>(type)); building_manager.lock_building_types(); return ret; diff --git a/src/openvic/GameManager.hpp b/src/openvic/GameManager.hpp index cffa75b..af2ec4f 100644 --- a/src/openvic/GameManager.hpp +++ b/src/openvic/GameManager.hpp @@ -27,14 +27,14 @@ namespace OpenVic { public: GameManager(state_updated_func_t state_updated_callback); - return_t setup(); + bool setup(); Date const& get_today() const; - return_t expand_building(Province::index_t province_index, const std::string_view building_type_identifier); + bool expand_building(Province::index_t province_index, const std::string_view building_type_identifier); /* Hardcoded data for defining things for which parsing from files has * not been implemented, currently mapmodes and building types. */ - return_t load_hardcoded_defines(); + bool load_hardcoded_defines(); }; } diff --git a/src/openvic/dataloader/Dataloader.cpp b/src/openvic/dataloader/Dataloader.cpp index 685d987..55994d3 100644 --- a/src/openvic/dataloader/Dataloader.cpp +++ b/src/openvic/dataloader/Dataloader.cpp @@ -11,12 +11,12 @@ using namespace OpenVic; using namespace OpenVic::NodeTools; using namespace ovdl; -return_t Dataloader::set_roots(std::vector<std::filesystem::path> new_roots) { +bool Dataloader::set_roots(std::vector<std::filesystem::path> new_roots) { if (!roots.empty()) { Logger::error("Overriding existing dataloader roots!"); roots.clear(); } - return_t ret = SUCCESS; + bool ret = true; for (std::reverse_iterator<std::vector<std::filesystem::path>::const_iterator> it = new_roots.crbegin(); it != new_roots.crend(); ++it) { if (std::find(roots.begin(), roots.end(), *it) == roots.end()) { if (std::filesystem::is_directory(*it)) { @@ -24,16 +24,16 @@ return_t Dataloader::set_roots(std::vector<std::filesystem::path> new_roots) { roots.push_back(*it); } else { Logger::error("Invalid dataloader root (must be an existing directory): ", *it); - ret = FAILURE; + ret = false; } } else { Logger::error("Duplicate dataloader root: ", *it); - ret = FAILURE; + ret = false; } } if (roots.empty()) { Logger::error("Dataloader has no roots after attempting to add ", new_roots.size()); - ret = FAILURE; + ret = false; } return ret; } @@ -81,15 +81,13 @@ std::vector<std::filesystem::path> Dataloader::lookup_files_in_dir(std::filesyst return ret; } -return_t Dataloader::apply_to_files_in_dir(std::filesystem::path const& path, - std::function<return_t(std::filesystem::path const&)> callback, +bool Dataloader::apply_to_files_in_dir(std::filesystem::path const& path, + std::function<bool(std::filesystem::path const&)> callback, std::filesystem::path const* extension) const { - return_t ret = SUCCESS; + bool ret = true; for (std::filesystem::path const& file : lookup_files_in_dir(path, extension)) { - if (callback(file) != SUCCESS) { - ret = FAILURE; - } + ret &= callback(file); } return ret; } @@ -140,21 +138,20 @@ static csv::Windows1252Parser _parse_csv(std::filesystem::path const& path) { return _run_ovdl_parser<csv::Windows1252Parser, &csv::Windows1252Parser::parse_csv>(path); } -return_t Dataloader::_load_pop_types(PopManager& pop_manager, std::filesystem::path const& pop_type_directory) const { - return_t ret = SUCCESS; - if (apply_to_files_in_dir(pop_type_directory, - [&pop_manager](std::filesystem::path const& file) -> return_t { +bool Dataloader::_load_pop_types(PopManager& pop_manager, std::filesystem::path const& pop_type_directory) const { + const bool ret = apply_to_files_in_dir(pop_type_directory, + [&pop_manager](std::filesystem::path const& file) -> bool { return pop_manager.load_pop_type_file(file, _parse_defines(file).get_file_node()); } - ) != SUCCESS) { + ); + if (!ret) { Logger::error("Failed to load pop types!"); - ret = FAILURE; } pop_manager.lock_pop_types(); return ret; } -return_t Dataloader::_load_map_dir(Map& map, std::filesystem::path const& map_directory) const { +bool Dataloader::_load_map_dir(Map& map, std::filesystem::path const& map_directory) const { static const std::filesystem::path defaults_filename = "default.map"; static const std::string default_definitions = "definition.csv"; static const std::string default_provinces = "provinces.bmp"; @@ -182,24 +179,24 @@ return_t Dataloader::_load_map_dir(Map& map, std::filesystem::path const& map_di APPLY_TO_MAP_PATHS(MAP_PATH_VAR) #undef MAP_PATH_VAR - return_t ret = expect_dictionary_keys( + bool ret = expect_dictionary_keys( "max_provinces", ONE_EXACTLY, expect_uint( - [&map](uint64_t val) -> return_t { + [&map](uint64_t val) -> bool { if (Province::NULL_INDEX < val && val <= Province::MAX_INDEX) { return map.set_max_provinces(val); } Logger::error("Invalid max province count ", val, " (out of valid range ", Province::NULL_INDEX, " < max_provinces <= ", Province::MAX_INDEX, ")"); - return FAILURE; + return false; } ), "sea_starts", ONE_EXACTLY, expect_list_reserve_length( water_province_identifiers, expect_identifier( - [&water_province_identifiers](std::string_view identifier) -> return_t { + [&water_province_identifiers](std::string_view identifier) -> bool { water_province_identifiers.push_back(identifier); - return SUCCESS; + return true; } ) ), @@ -217,25 +214,25 @@ return_t Dataloader::_load_map_dir(Map& map, std::filesystem::path const& map_di "border_cutoff", ZERO_OR_ONE, success_callback )(parser.get_file_node()); - if (ret != SUCCESS) { + if (!ret) { Logger::error("Failed to load map default file!"); } - if (map.load_province_definitions(_parse_csv(lookup_file(map_directory / definitions)).get_lines()) != SUCCESS) { + if (!map.load_province_definitions(_parse_csv(lookup_file(map_directory / definitions)).get_lines())) { Logger::error("Failed to load province definitions file!"); - ret = FAILURE; + ret = false; } - if (map.set_water_province_list(water_province_identifiers) != SUCCESS) { + if (!map.set_water_province_list(water_province_identifiers)) { Logger::error("Failed to set water provinces!"); - ret = FAILURE; + ret = false; } map.lock_water_provinces(); return ret; } -return_t Dataloader::load_defines(GameManager& game_manager) const { +bool Dataloader::load_defines(GameManager& game_manager) const { static const std::filesystem::path good_file = "common/goods.txt"; static const std::filesystem::path pop_type_directory = "poptypes"; static const std::filesystem::path graphical_culture_type_file = "common/graphicalculturetype.txt"; @@ -243,45 +240,45 @@ return_t Dataloader::load_defines(GameManager& game_manager) const { static const std::filesystem::path religion_file = "common/religion.txt"; static const std::filesystem::path map_directory = "map"; - return_t ret = SUCCESS; + bool ret = true; - if (game_manager.good_manager.load_good_file(_parse_defines(lookup_file(good_file)).get_file_node()) != SUCCESS) { + if (!game_manager.good_manager.load_good_file(_parse_defines(lookup_file(good_file)).get_file_node())) { Logger::error("Failed to load goods!"); - ret = FAILURE; + ret = false; } - if (_load_pop_types(game_manager.pop_manager, pop_type_directory) != SUCCESS) { + if (!_load_pop_types(game_manager.pop_manager, pop_type_directory)) { Logger::error("Failed to load pop types!"); - ret = FAILURE; + ret = false; } - if (game_manager.pop_manager.culture_manager.load_graphical_culture_type_file(_parse_defines(lookup_file(graphical_culture_type_file)).get_file_node()) != SUCCESS) { + if (!game_manager.pop_manager.culture_manager.load_graphical_culture_type_file(_parse_defines(lookup_file(graphical_culture_type_file)).get_file_node())) { Logger::error("Failed to load graphical culture types!"); - ret = FAILURE; + ret = false; } - if (game_manager.pop_manager.culture_manager.load_culture_file(_parse_defines(lookup_file(culture_file)).get_file_node()) != SUCCESS) { + if (!game_manager.pop_manager.culture_manager.load_culture_file(_parse_defines(lookup_file(culture_file)).get_file_node())) { Logger::error("Failed to load cultures!"); - ret = FAILURE; + ret = false; } - if (game_manager.pop_manager.religion_manager.load_religion_file(_parse_defines(lookup_file(religion_file)).get_file_node()) != SUCCESS) { + if (!game_manager.pop_manager.religion_manager.load_religion_file(_parse_defines(lookup_file(religion_file)).get_file_node())) { Logger::error("Failed to load religions!"); - ret = FAILURE; + ret = false; } - if (_load_map_dir(game_manager.map, map_directory) != SUCCESS) { + if (!_load_map_dir(game_manager.map, map_directory)) { Logger::error("Failed to load map!"); - ret = FAILURE; + ret = false; } return ret; } -return_t Dataloader::load_pop_history(GameManager& game_manager, std::filesystem::path const& path) const { +bool Dataloader::load_pop_history(GameManager& game_manager, std::filesystem::path const& path) const { return apply_to_files_in_dir(path, - [&game_manager](std::filesystem::path const& file) -> return_t { + [&game_manager](std::filesystem::path const& file) -> bool { return expect_dictionary( - [&game_manager](std::string_view province_key, ast::NodeCPtr province_node) -> return_t { + [&game_manager](std::string_view province_key, ast::NodeCPtr province_node) -> bool { Province* province = game_manager.map.get_province_by_identifier(province_key); if (province == nullptr) { Logger::error("Invalid province id: ", province_key); - return FAILURE; + return false; } return province->load_pop_list(game_manager.pop_manager, province_node); } diff --git a/src/openvic/dataloader/Dataloader.hpp b/src/openvic/dataloader/Dataloader.hpp index 9e5c24b..f723803 100644 --- a/src/openvic/dataloader/Dataloader.hpp +++ b/src/openvic/dataloader/Dataloader.hpp @@ -4,8 +4,6 @@ #include <functional> #include <vector> -#include "openvic/types/Return.hpp" - namespace OpenVic { struct GameManager; struct PopManager; @@ -14,24 +12,24 @@ namespace OpenVic { class Dataloader { std::vector<std::filesystem::path> roots; - return_t _load_pop_types(PopManager& pop_manager, std::filesystem::path const& pop_type_directory) const; - return_t _load_map_dir(Map& map, std::filesystem::path const& map_directory) const; + bool _load_pop_types(PopManager& pop_manager, std::filesystem::path const& pop_type_directory) const; + bool _load_map_dir(Map& map, std::filesystem::path const& map_directory) const; public: Dataloader() = default; /* In reverse-load order, so base defines first and final loaded mod last */ - return_t set_roots(std::vector<std::filesystem::path> new_roots); + bool set_roots(std::vector<std::filesystem::path> new_roots); std::filesystem::path lookup_file(std::filesystem::path const& path) const; static const std::filesystem::path TXT; std::vector<std::filesystem::path> lookup_files_in_dir(std::filesystem::path const& path, std::filesystem::path const* extension = &TXT) const; - return_t apply_to_files_in_dir(std::filesystem::path const& path, - std::function<return_t(std::filesystem::path const&)> callback, + bool apply_to_files_in_dir(std::filesystem::path const& path, + std::function<bool(std::filesystem::path const&)> callback, std::filesystem::path const* extension = &TXT) const; - return_t load_defines(GameManager& game_manager) const; - return_t load_pop_history(GameManager& game_manager, std::filesystem::path const& path) const; + bool load_defines(GameManager& game_manager) const; + bool load_pop_history(GameManager& game_manager, std::filesystem::path const& path) const; }; } diff --git a/src/openvic/dataloader/NodeTools.cpp b/src/openvic/dataloader/NodeTools.cpp index 6e5f7d0..499527f 100644 --- a/src/openvic/dataloader/NodeTools.cpp +++ b/src/openvic/dataloader/NodeTools.cpp @@ -6,8 +6,8 @@ using namespace OpenVic; using namespace OpenVic::NodeTools; template<typename T> -static node_callback_t _expect_type(std::function<return_t(T const&)> callback) { - return [callback](ast::NodeCPtr node) -> return_t { +static node_callback_t _expect_type(std::function<bool(T const&)> callback) { + return [callback](ast::NodeCPtr node) -> bool { if (node != nullptr) { T const* cast_node = node->cast_to<T>(); if (cast_node != nullptr) { @@ -17,28 +17,28 @@ static node_callback_t _expect_type(std::function<return_t(T const&)> callback) } else { Logger::error("Null node when expecting ", T::get_type_static()); } - return FAILURE; + return false; }; } template<typename T = ast::AbstractStringNode> requires(std::derived_from<T, ast::AbstractStringNode>) -static std::function<return_t(T const&)> abstract_string_node_callback(std::function<return_t(std::string_view)> callback) { - return [callback](T const& node) -> return_t { +static std::function<bool(T const&)> abstract_string_node_callback(std::function<bool(std::string_view)> callback) { + return [callback](T const& node) -> bool { return callback(node._name); }; } -node_callback_t NodeTools::expect_identifier(std::function<return_t(std::string_view)> callback) { +node_callback_t NodeTools::expect_identifier(std::function<bool(std::string_view)> callback) { return _expect_type<ast::IdentifierNode>(abstract_string_node_callback<ast::IdentifierNode>(callback)); } -node_callback_t NodeTools::expect_string(std::function<return_t(std::string_view)> callback) { +node_callback_t NodeTools::expect_string(std::function<bool(std::string_view)> callback) { return _expect_type<ast::StringNode>(abstract_string_node_callback<ast::StringNode>(callback)); } -node_callback_t NodeTools::expect_identifier_or_string(std::function<return_t(std::string_view)> callback) { - return [callback](ast::NodeCPtr node) -> return_t { +node_callback_t NodeTools::expect_identifier_or_string(std::function<bool(std::string_view)> callback) { + return [callback](ast::NodeCPtr node) -> bool { if (node != nullptr) { ast::AbstractStringNode const* cast_node = node->cast_to<ast::IdentifierNode>(); if (cast_node == nullptr) { @@ -51,109 +51,108 @@ node_callback_t NodeTools::expect_identifier_or_string(std::function<return_t(st } else { Logger::error("Null node when expecting ", ast::IdentifierNode::get_type_static(), " or ", ast::StringNode::get_type_static()); } - return FAILURE; + return false; }; } -node_callback_t NodeTools::expect_bool(std::function<return_t(bool)> callback) { +node_callback_t NodeTools::expect_bool(std::function<bool(bool)> callback) { return expect_identifier( - [callback](std::string_view identifier) -> return_t { + [callback](std::string_view identifier) -> bool { if (identifier == "yes") { return callback(true); } else if (identifier == "no") { return callback(false); } Logger::error("Invalid bool identifier text: ", identifier); - return FAILURE; + return false; } ); } -node_callback_t NodeTools::expect_int(std::function<return_t(int64_t)> callback) { +node_callback_t NodeTools::expect_int(std::function<bool(int64_t)> callback) { return expect_identifier( - [callback](std::string_view identifier) -> return_t { + [callback](std::string_view identifier) -> bool { bool successful = false; const int64_t val = StringUtils::string_to_int64(identifier, &successful, 10); if (successful) { return callback(val); } Logger::error("Invalid int identifier text: ", identifier); - return FAILURE; + return false; } ); } -node_callback_t NodeTools::expect_uint(std::function<return_t(uint64_t)> callback) { +node_callback_t NodeTools::expect_uint(std::function<bool(uint64_t)> callback) { return expect_identifier( - [callback](std::string_view identifier) -> return_t { + [callback](std::string_view identifier) -> bool { bool successful = false; const uint64_t val = StringUtils::string_to_uint64(identifier, &successful, 10); if (successful) { return callback(val); } Logger::error("Invalid uint identifier text: ", identifier); - return FAILURE; + return false; } ); } -node_callback_t NodeTools::expect_fixed_point(std::function<return_t(FP)> callback) { +node_callback_t NodeTools::expect_fixed_point(std::function<bool(FP)> callback) { return expect_identifier( - [callback](std::string_view identifier) -> return_t { + [callback](std::string_view identifier) -> bool { bool successful = false; const FP val = FP::parse(identifier.data(), identifier.length(), &successful); if (successful) { return callback(val); } Logger::error("Invalid fixed point identifier text: ", identifier); - return FAILURE; + return false; } ); } -node_callback_t NodeTools::expect_colour(std::function<return_t(colour_t)> callback) { - return [callback](ast::NodeCPtr node) -> return_t { +node_callback_t NodeTools::expect_colour(std::function<bool(colour_t)> callback) { + return [callback](ast::NodeCPtr node) -> bool { colour_t col = NULL_COLOUR; uint32_t components = 0; - return_t ret = expect_list_of_length(3, + bool ret = expect_list_of_length(3, expect_fixed_point( - [&col, &components](FP val) -> return_t { - return_t ret = SUCCESS; + [&col, &components](FP val) -> bool { + components++; + col <<= 8; if (val < 0 || val > 255) { Logger::error("Invalid colour component: ", val); - val = FP::_0(); - ret = FAILURE; + return false; + } else { + if (val <= 1) val *= 255; + col |= val.to_int32_t(); + return true; } - if (val <= 1) val *= 255; - col = (col << 8) | val.to_int32_t(); - components++; - return ret; } ) )(node); - if (components < 3) col <<= 8 * (3 - components); - if (callback(col) != SUCCESS) ret = FAILURE; + ret &= callback(col << 8 * (3 - components)); return ret; }; } -node_callback_t NodeTools::expect_date(std::function<return_t(Date)> callback) { +node_callback_t NodeTools::expect_date(std::function<bool(Date)> callback) { return expect_identifier( - [callback](std::string_view identifier) -> return_t { + [callback](std::string_view identifier) -> bool { bool successful = false; const Date date = Date::from_string(identifier, &successful); if (successful) { return callback(date); } Logger::error("Invalid date identifier text: ", identifier); - return FAILURE; + return false; } ); } node_callback_t NodeTools::expect_assign(key_value_callback_t callback) { return _expect_type<ast::AssignNode>( - [callback](ast::AssignNode const& assign_node) -> return_t { + [callback](ast::AssignNode const& assign_node) -> bool { return callback(assign_node._name, assign_node._initializer.get()); } ); @@ -161,18 +160,18 @@ node_callback_t NodeTools::expect_assign(key_value_callback_t callback) { node_callback_t NodeTools::expect_list_and_length(length_callback_t length_callback, node_callback_t callback) { return _expect_type<ast::AbstractListNode>( - [length_callback, callback](ast::AbstractListNode const& list_node) -> return_t { + [length_callback, callback](ast::AbstractListNode const& list_node) -> bool { std::vector<ast::NodeUPtr> const& list = list_node._statements; - return_t ret = SUCCESS; + bool ret = true; size_t size = length_callback(list.size()); if (size > list.size()) { Logger::error("Trying to read more values than the list contains: ", size, " > ", list.size()); size = list.size(); - ret = FAILURE; + ret = false; } std::for_each(list.begin(), list.begin() + size, [callback, &ret](ast::NodeUPtr const& sub_node) -> void { - if (callback(sub_node.get()) != SUCCESS) ret = FAILURE; + ret &= callback(sub_node.get()); } ); return ret; @@ -181,19 +180,19 @@ node_callback_t NodeTools::expect_list_and_length(length_callback_t length_callb } node_callback_t NodeTools::expect_list_of_length(size_t length, node_callback_t callback) { - return [length, callback](ast::NodeCPtr node) -> return_t { - return_t ret = SUCCESS; - if (expect_list_and_length( + return [length, callback](ast::NodeCPtr node) -> bool { + bool ret = true; + ret &= expect_list_and_length( [length, &ret](size_t size) -> size_t { if (size != length) { Logger::error("List length ", size, " does not match expected length ", length); - ret = FAILURE; + ret = false; if (length < size) return length; } return size; }, callback - )(node) != SUCCESS) ret = FAILURE; + )(node); return ret; }; } @@ -211,20 +210,20 @@ node_callback_t NodeTools::expect_dictionary(key_value_callback_t callback) { } node_callback_t NodeTools::_expect_dictionary_keys_and_length(length_callback_t length_callback, bool allow_other_keys, key_map_t&& key_map) { - return [length_callback, allow_other_keys, key_map = std::move(key_map)](ast::NodeCPtr node) mutable -> return_t { - return_t ret = expect_dictionary_and_length( + return [length_callback, allow_other_keys, key_map = std::move(key_map)](ast::NodeCPtr node) mutable -> bool { + bool ret = expect_dictionary_and_length( length_callback, - [&key_map, allow_other_keys](std::string_view key, ast::NodeCPtr value) -> return_t { + [&key_map, allow_other_keys](std::string_view key, ast::NodeCPtr value) -> bool { const key_map_t::iterator it = key_map.find(key); if (it == key_map.end()) { - if (allow_other_keys) return SUCCESS; + if (allow_other_keys) return true; Logger::error("Invalid dictionary key: ", key); - return FAILURE; + return false; } dictionary_entry_t& entry = it->second; if (++entry.count > 1 && !entry.can_repeat()) { Logger::error("Invalid repeat of dictionary key: ", key); - return FAILURE; + return false; } return entry.callback(value); } @@ -233,7 +232,7 @@ node_callback_t NodeTools::_expect_dictionary_keys_and_length(length_callback_t dictionary_entry_t const& entry = key_entry.second; if (entry.must_appear() && entry.count < 1) { Logger::error("Mandatory dictionary key not present: ", key_entry.first); - ret = FAILURE; + ret = false; } } return ret; @@ -244,13 +243,13 @@ node_callback_t NodeTools::name_list_callback(std::vector<std::string>& list) { return expect_list_reserve_length( list, expect_identifier_or_string( - [&list](std::string_view str) -> return_t { + [&list](std::string_view str) -> bool { if (!str.empty()) { list.push_back(std::string { str }); - return SUCCESS; + return true; } Logger::error("Empty identifier or string"); - return FAILURE; + return false; } ) ); diff --git a/src/openvic/dataloader/NodeTools.hpp b/src/openvic/dataloader/NodeTools.hpp index 6dbaa1c..daea8ce 100644 --- a/src/openvic/dataloader/NodeTools.hpp +++ b/src/openvic/dataloader/NodeTools.hpp @@ -4,7 +4,6 @@ #include "openvic/types/Colour.hpp" #include "openvic/types/Date.hpp" -#include "openvic/types/Return.hpp" #include "openvic/types/fixed_point/FP.hpp" #include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp> @@ -14,20 +13,20 @@ namespace OpenVic { namespace NodeTools { - using node_callback_t = std::function<return_t(ast::NodeCPtr)>; - constexpr return_t success_callback(ast::NodeCPtr) { return SUCCESS; } + using node_callback_t = std::function<bool(ast::NodeCPtr)>; + constexpr bool success_callback(ast::NodeCPtr) { return true; } - using key_value_callback_t = std::function<return_t(std::string_view, ast::NodeCPtr)>; + using key_value_callback_t = std::function<bool(std::string_view, ast::NodeCPtr)>; - node_callback_t expect_identifier(std::function<return_t(std::string_view)> callback); - node_callback_t expect_string(std::function<return_t(std::string_view)> callback); - node_callback_t expect_identifier_or_string(std::function<return_t(std::string_view)> callback); - node_callback_t expect_bool(std::function<return_t(bool)> callback); - node_callback_t expect_int(std::function<return_t(int64_t)> callback); - node_callback_t expect_uint(std::function<return_t(uint64_t)> callback); - node_callback_t expect_fixed_point(std::function<return_t(FP)> callback); - node_callback_t expect_colour(std::function<return_t(colour_t)> callback); - node_callback_t expect_date(std::function<return_t(Date)> callback); + node_callback_t expect_identifier(std::function<bool(std::string_view)> callback); + node_callback_t expect_string(std::function<bool(std::string_view)> callback); + node_callback_t expect_identifier_or_string(std::function<bool(std::string_view)> callback); + node_callback_t expect_bool(std::function<bool(bool)> callback); + node_callback_t expect_int(std::function<bool(int64_t)> callback); + node_callback_t expect_uint(std::function<bool(uint64_t)> callback); + node_callback_t expect_fixed_point(std::function<bool(FP)> callback); + node_callback_t expect_colour(std::function<bool(colour_t)> callback); + node_callback_t expect_date(std::function<bool(Date)> callback); node_callback_t expect_assign(key_value_callback_t callback); using length_callback_t = std::function<size_t(size_t)>; @@ -124,38 +123,38 @@ namespace OpenVic { node_callback_t name_list_callback(std::vector<std::string>& list); template<typename T> - std::function<return_t(T)> assign_variable_callback(T& var) { - return [&var](T val) -> return_t { + std::function<bool(T)> assign_variable_callback(T& var) { + return [&var](T val) -> bool { var = val; - return SUCCESS; + return true; }; } template<typename T> requires(std::integral<T>) - std::function<return_t(uint64_t)> assign_variable_callback_uint(const std::string_view name, T& var) { - return [&var, name](uint64_t val) -> return_t { + std::function<bool(uint64_t)> assign_variable_callback_uint(const std::string_view name, T& var) { + return [&var, name](uint64_t val) -> bool { if (val <= std::numeric_limits<T>::max()) { var = val; - return SUCCESS; + return true; } Logger::error("Invalid ", name, ": ", val, " (valid range: [0, ", static_cast<uint64_t>(std::numeric_limits<T>::max()), "])"); - return FAILURE; + return false; }; } template<typename T> requires(std::integral<T>) - std::function<return_t(int64_t)> assign_variable_callback_int(const std::string_view name, T& var) { - return [&var, name](int64_t val) -> return_t { + std::function<bool(int64_t)> assign_variable_callback_int(const std::string_view name, T& var) { + return [&var, name](int64_t val) -> bool { if (std::numeric_limits<T>::lowest() <= val && val <= std::numeric_limits<T>::max()) { var = val; - return SUCCESS; + return true; } Logger::error("Invalid ", name, ": ", val, " (valid range: [", static_cast<int64_t>(std::numeric_limits<T>::lowest()), ", ", static_cast<uint64_t>(std::numeric_limits<T>::max()), "])"); - return FAILURE; + return false; }; } } diff --git a/src/openvic/economy/Good.cpp b/src/openvic/economy/Good.cpp index 074bd5a..8ecaae0 100644 --- a/src/openvic/economy/Good.cpp +++ b/src/openvic/economy/Good.cpp @@ -58,10 +58,10 @@ void Good::reset_to_defaults() { GoodManager::GoodManager() : good_categories { "good categories" }, goods { "goods" } {} -return_t GoodManager::add_good_category(const std::string_view identifier) { +bool GoodManager::add_good_category(const std::string_view identifier) { if (identifier.empty()) { Logger::error("Invalid good category identifier - empty!"); - return FAILURE; + return false; } return good_categories.add_item({ identifier }); } @@ -82,23 +82,23 @@ std::vector<GoodCategory> const& GoodManager::get_good_categories() const { return good_categories.get_items(); } -return_t GoodManager::add_good(const std::string_view identifier, colour_t colour, GoodCategory const* category, +bool GoodManager::add_good(const std::string_view identifier, colour_t colour, GoodCategory const* category, Good::price_t base_price, bool available_from_start, bool tradeable, bool money, bool overseas_penalty) { if (identifier.empty()) { Logger::error("Invalid good identifier - empty!"); - return FAILURE; + return false; } if (colour > MAX_COLOUR_RGB) { Logger::error("Invalid good colour for ", identifier, ": ", colour_to_hex_string(colour)); - return FAILURE; + return false; } if (category == nullptr) { Logger::error("Invalid good category for ", identifier, ": null"); - return FAILURE; + return false; } if (base_price <= Good::NULL_PRICE) { Logger::error("Invalid base price for ", identifier, ": ", base_price); - return FAILURE; + return false; } return goods.add_item({ identifier, colour, *category, base_price, available_from_start, tradeable, money, overseas_penalty }); } @@ -128,36 +128,36 @@ void GoodManager::reset_to_defaults() { good.reset_to_defaults(); } -return_t GoodManager::load_good_file(ast::NodeCPtr root) { +bool GoodManager::load_good_file(ast::NodeCPtr root) { size_t total_expected_goods = 0; - return_t ret = expect_dictionary_reserve_length( + bool ret = expect_dictionary_reserve_length( good_categories, - [this, &total_expected_goods](std::string_view key, ast::NodeCPtr value) -> return_t { - return_t ret = expect_list_and_length( + [this, &total_expected_goods](std::string_view key, ast::NodeCPtr value) -> bool { + bool ret = expect_list_and_length( [&total_expected_goods](size_t size) -> size_t { total_expected_goods += size; return 0; }, success_callback )(value); - if (add_good_category(key) != SUCCESS) ret = FAILURE; + ret &= add_good_category(key); return ret; } )(root); lock_good_categories(); goods.reserve(goods.size() + total_expected_goods); - if (expect_dictionary( - [this](std::string_view good_category_key, ast::NodeCPtr good_category_value) -> return_t { + ret &= expect_dictionary( + [this](std::string_view good_category_key, ast::NodeCPtr good_category_value) -> bool { GoodCategory const* good_category = get_good_category_by_identifier(good_category_key); return expect_dictionary( - [this, good_category](std::string_view key, ast::NodeCPtr value) -> return_t { + [this, good_category](std::string_view key, ast::NodeCPtr value) -> bool { colour_t colour = NULL_COLOUR; Good::price_t base_price; bool available_from_start, tradeable = true; bool money, overseas_penalty = false; - return_t ret = expect_dictionary_keys( + bool ret = expect_dictionary_keys( "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), "cost", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(base_price)), "available_from_start", ZERO_OR_ONE, expect_bool(assign_variable_callback(available_from_start)), @@ -165,14 +165,12 @@ return_t GoodManager::load_good_file(ast::NodeCPtr root) { "money", ZERO_OR_ONE, expect_bool(assign_variable_callback(money)), "overseas_penalty", ZERO_OR_ONE, expect_bool(assign_variable_callback(overseas_penalty)) )(value); - if (add_good(key, colour, good_category, base_price, available_from_start, tradeable, money, overseas_penalty) != SUCCESS) - ret = FAILURE; + ret &= add_good(key, colour, good_category, base_price, available_from_start, tradeable, money, overseas_penalty); return ret; } )(good_category_value); } - )(root) != SUCCESS) - ret = FAILURE; + )(root); lock_goods(); return ret; } diff --git a/src/openvic/economy/Good.hpp b/src/openvic/economy/Good.hpp index 7a41419..f04c9b2 100644 --- a/src/openvic/economy/Good.hpp +++ b/src/openvic/economy/Good.hpp @@ -66,13 +66,13 @@ namespace OpenVic { public: GoodManager(); - return_t add_good_category(const std::string_view identifier); + bool add_good_category(const std::string_view identifier); void lock_good_categories(); GoodCategory const* get_good_category_by_identifier(const std::string_view identifier) const; size_t get_good_category_count() const; std::vector<GoodCategory> const& get_good_categories() const; - return_t add_good(const std::string_view identifier, colour_t colour, GoodCategory const* category, Good::price_t base_price, + bool add_good(const std::string_view identifier, colour_t colour, GoodCategory const* category, Good::price_t base_price, bool available_from_start, bool tradeable, bool money, bool overseas_penalty); void lock_goods(); Good const* get_good_by_index(size_t index) const; @@ -81,6 +81,6 @@ namespace OpenVic { std::vector<Good> const& get_goods() const; void reset_to_defaults(); - return_t load_good_file(ast::NodeCPtr root); + bool load_good_file(ast::NodeCPtr root); }; } diff --git a/src/openvic/map/Building.cpp b/src/openvic/map/Building.cpp index 00e0135..72bccc1 100644 --- a/src/openvic/map/Building.cpp +++ b/src/openvic/map/Building.cpp @@ -39,13 +39,13 @@ float Building::get_expansion_progress() const { return expansion_progress; } -return_t Building::expand() { +bool Building::expand() { if (expansion_state == ExpansionState::CanExpand) { expansion_state = ExpansionState::Preparing; expansion_progress = 0.0f; - return SUCCESS; + return true; } - return FAILURE; + return false; } /* REQUIREMENTS: @@ -94,18 +94,18 @@ Timespan BuildingType::get_build_time() const { BuildingManager::BuildingManager() : building_types { "building types" } {} -return_t BuildingManager::add_building_type(const std::string_view identifier, Building::level_t max_level, Timespan build_time) { +bool BuildingManager::add_building_type(const std::string_view identifier, Building::level_t max_level, Timespan build_time) { if (identifier.empty()) { Logger::error("Invalid building type identifier - empty!"); - return FAILURE; + return false; } if (max_level < 0) { Logger::error("Invalid building type max level for ", identifier, ": ", max_level); - return FAILURE; + return false; } if (build_time < 0) { Logger::error("Invalid building type build time for ", identifier, ": ", build_time); - return FAILURE; + return false; } return building_types.add_item({ identifier, max_level, build_time }); } @@ -118,18 +118,16 @@ BuildingType const* BuildingManager::get_building_type_by_identifier(const std:: return building_types.get_item_by_identifier(identifier); } -return_t BuildingManager::generate_province_buildings(Province& province) const { +bool BuildingManager::generate_province_buildings(Province& province) const { province.reset_buildings(); if (!building_types.is_locked()) { Logger::error("Cannot generate buildings until building types are locked!"); - return FAILURE; + return false; } - return_t ret = SUCCESS; + bool ret = true; if (!province.is_water()) { for (BuildingType const& type : building_types.get_items()) { - if (province.add_building({ type }) != SUCCESS) { - ret = FAILURE; - } + ret &= province.add_building({ type }); } } province.lock_buildings(); diff --git a/src/openvic/map/Building.hpp b/src/openvic/map/Building.hpp index 2ff9409..d1c0348 100644 --- a/src/openvic/map/Building.hpp +++ b/src/openvic/map/Building.hpp @@ -48,7 +48,7 @@ namespace OpenVic { Date const& get_end_date() const; float get_expansion_progress() const; - return_t expand(); + bool expand(); void update_state(Date const& today); void tick(Date const& today); }; @@ -78,9 +78,9 @@ namespace OpenVic { public: BuildingManager(); - return_t add_building_type(const std::string_view identifier, Building::level_t max_level, Timespan build_time); + bool add_building_type(const std::string_view identifier, Building::level_t max_level, Timespan build_time); void lock_building_types(); BuildingType const* get_building_type_by_identifier(const std::string_view identifier) const; - return_t generate_province_buildings(Province& province) const; + bool generate_province_buildings(Province& province) const; }; } diff --git a/src/openvic/map/Map.cpp b/src/openvic/map/Map.cpp index 439338b..6375691 100644 --- a/src/openvic/map/Map.cpp +++ b/src/openvic/map/Map.cpp @@ -30,24 +30,24 @@ Map::Map() : provinces { "provinces" }, regions { "regions" }, mapmodes { "mapmodes" } {} -return_t Map::add_province(const std::string_view identifier, colour_t colour) { +bool Map::add_province(const std::string_view identifier, colour_t colour) { if (provinces.size() >= max_provinces) { Logger::error("The map's province list is full - maximum number of provinces is ", max_provinces, " (this can be at most ", Province::MAX_INDEX, ")"); - return FAILURE; + return false; } if (identifier.empty()) { Logger::error("Invalid province identifier - empty!"); - return FAILURE; + return false; } if (colour == NULL_COLOUR || colour > MAX_COLOUR_RGB) { Logger::error("Invalid province colour for ", identifier, ": ", colour_to_hex_string(colour)); - return FAILURE; + return false; } Province new_province { identifier, colour, static_cast<Province::index_t>(provinces.size() + 1) }; const Province::index_t index = get_index_from_colour(colour); if (index != Province::NULL_INDEX) { Logger::error("Duplicate province colours: ", get_province_by_index(index)->to_string(), " and ", new_province.to_string()); - return FAILURE; + return false; } colour_index_map[new_province.get_colour()] = new_province.get_index(); return provinces.add_item(std::move(new_province)); @@ -57,35 +57,33 @@ void Map::lock_provinces() { provinces.lock(); } -return_t Map::set_water_province(const std::string_view identifier) { +bool Map::set_water_province(const std::string_view identifier) { if (water_provinces.is_locked()) { Logger::error("The map's water provinces have already been locked!"); - return FAILURE; + return false; } Province* province = get_province_by_identifier(identifier); if (province == nullptr) { Logger::error("Unrecognised water province identifier: ", identifier); - return FAILURE; + return false; } if (province->is_water()) { Logger::error("Province ", identifier, " is already a water province!"); - return FAILURE; + return false; } - if (water_provinces.add_province(province) != SUCCESS) { + if (!water_provinces.add_province(province)) { Logger::error("Failed to add province ", identifier, " to water province set!"); - return FAILURE; + return false; } province->water = true; - return SUCCESS; + return true; } -return_t Map::set_water_province_list(std::vector<std::string_view> const& list) { - return_t ret = SUCCESS; +bool Map::set_water_province_list(std::vector<std::string_view> const& list) { + bool ret = true; water_provinces.reserve(water_provinces.size() + list.size()); for (std::string_view const& identifier : list) { - if (set_water_province(identifier) != SUCCESS) { - ret = FAILURE; - } + ret &= set_water_province(identifier); } return ret; } @@ -95,19 +93,19 @@ void Map::lock_water_provinces() { Logger::info("Locked water provinces after registering ", water_provinces.size()); } -return_t Map::add_region(const std::string_view identifier, std::vector<std::string_view> const& province_identifiers) { +bool Map::add_region(const std::string_view identifier, std::vector<std::string_view> const& province_identifiers) { if (identifier.empty()) { Logger::error("Invalid region identifier - empty!"); - return FAILURE; + return false; } Region new_region { identifier }; - return_t ret = SUCCESS; + bool ret = true; for (const std::string_view province_identifier : province_identifiers) { Province* province = get_province_by_identifier(province_identifier); if (province != nullptr) { if (new_region.contains_province(province)) { Logger::error("Duplicate province identifier ", province_identifier, " in region ", identifier); - ret = FAILURE; + ret = false; } else { size_t other_region_index = reinterpret_cast<size_t>(province->get_region()); if (other_region_index != 0) { @@ -116,21 +114,21 @@ return_t Map::add_region(const std::string_view identifier, std::vector<std::str Logger::error("Cannot add province ", province_identifier, " to region ", identifier, " - it is already part of ", regions.get_item_by_index(other_region_index)->get_identifier()); else Logger::error("Cannot add province ", province_identifier, " to region ", identifier, " - it is already part of an unknown region with index ", other_region_index); - ret = FAILURE; - } else if (new_region.add_province(province) != SUCCESS) { + ret = false; + } else if (!new_region.add_province(province)) { Logger::error("Failed to add province ", province_identifier, " to region ", identifier); - ret = FAILURE; + ret = false; } } } else { Logger::error("Invalid province identifier ", province_identifier, " for region ", identifier); - ret = FAILURE; + ret = false; } } new_region.lock(); - if (!new_region.size()) { + if (new_region.empty()) { Logger::error("No valid provinces in list for ", identifier); - return FAILURE; + return false; } // Used to detect provinces listed in multiple regions, will @@ -138,7 +136,7 @@ return_t Map::add_region(const std::string_view identifier, std::vector<std::str Region* tmp_region_index = reinterpret_cast<Region*>(regions.size()); for (Province* province : new_region.get_provinces()) province->region = tmp_region_index; - if (regions.add_item(std::move(new_region)) != SUCCESS) ret = FAILURE; + ret &= regions.add_item(std::move(new_region)); return ret; } @@ -184,17 +182,17 @@ Province::index_t Map::get_province_index_at(size_t x, size_t y) const { return Province::NULL_INDEX; } -return_t Map::set_max_provinces(Province::index_t new_max_provinces) { +bool Map::set_max_provinces(Province::index_t new_max_provinces) { if (new_max_provinces <= Province::NULL_INDEX) { Logger::error("Trying to set max province count to an invalid value ", new_max_provinces, " (must be greater than ", Province::NULL_INDEX, ")"); - return FAILURE; + return false; } if (!provinces.empty() || provinces.is_locked()) { Logger::error("Trying to set max province count to ", new_max_provinces, " after provinces have already been added and/or locked"); - return FAILURE; + return false; } max_provinces = new_max_provinces; - return SUCCESS; + return true; } Province::index_t Map::get_max_provinces() const { @@ -239,34 +237,34 @@ static colour_t colour_at(uint8_t const* colour_data, int32_t idx) { return (colour_data[idx] << 16) | (colour_data[idx + 1] << 8) | colour_data[idx + 2]; } -return_t Map::generate_province_shape_image(size_t new_width, size_t new_height, uint8_t const* colour_data, +bool Map::generate_province_shape_image(size_t new_width, size_t new_height, uint8_t const* colour_data, uint8_t const* terrain_data, terrain_variant_map_t const& terrain_variant_map, bool detailed_errors) { if (!province_shape_image.empty()) { Logger::error("Province index image has already been generated!"); - return FAILURE; + return false; } if (!provinces.is_locked()) { Logger::error("Province index image cannot be generated until after provinces are locked!"); - return FAILURE; + return false; } if (new_width < 1 || new_height < 1) { Logger::error("Invalid province image dimensions: ", new_width, "x", new_height); - return FAILURE; + return false; } if (colour_data == nullptr) { Logger::error("Province colour data pointer is null!"); - return FAILURE; + return false; } if (terrain_data == nullptr) { Logger::error("Province terrain data pointer is null!"); - return FAILURE; + return false; } width = new_width; height = new_height; province_shape_image.resize(width * height); std::vector<bool> province_checklist(provinces.size()); - return_t ret = SUCCESS; + bool ret = true; std::unordered_set<colour_t> unrecognised_province_colours, unrecognised_terrain_colours; for (int32_t y = 0; y < height; ++y) { @@ -320,11 +318,11 @@ return_t Map::generate_province_shape_image(size_t new_width, size_t new_height, } if (!unrecognised_province_colours.empty()) { Logger::error("Province image contains ", unrecognised_province_colours.size(), " unrecognised province colours"); - ret = FAILURE; + ret = false; } if (!unrecognised_terrain_colours.empty()) { Logger::error("Terrain image contains ", unrecognised_terrain_colours.size(), " unrecognised terrain colours"); - ret = FAILURE; + ret = false; } size_t missing = 0; @@ -338,7 +336,7 @@ return_t Map::generate_province_shape_image(size_t new_width, size_t new_height, } if (missing > 0) { Logger::error("Province image is missing ", missing, " province colours"); - ret = FAILURE; + ret = false; } return ret; } @@ -355,14 +353,14 @@ std::vector<Map::shape_pixel_t> const& Map::get_province_shape_image() const { return province_shape_image; } -return_t Map::add_mapmode(const std::string_view identifier, Mapmode::colour_func_t colour_func) { +bool Map::add_mapmode(const std::string_view identifier, Mapmode::colour_func_t colour_func) { if (identifier.empty()) { Logger::error("Invalid mapmode identifier - empty!"); - return FAILURE; + return false; } if (colour_func == nullptr) { Logger::error("Mapmode colour function is null for identifier: ", identifier); - return FAILURE; + return false; } return mapmodes.add_item({ identifier, mapmodes.size(), colour_func }); } @@ -387,20 +385,20 @@ Mapmode const* Map::get_mapmode_by_identifier(const std::string_view identifier) return mapmodes.get_item_by_identifier(identifier); } -return_t Map::generate_mapmode_colours(Mapmode::index_t index, uint8_t* target) const { +bool Map::generate_mapmode_colours(Mapmode::index_t index, uint8_t* target) const { if (target == nullptr) { Logger::error("Mapmode colour target pointer is null!"); - return FAILURE; + return false; } - return_t ret = SUCCESS; + bool ret = true; Mapmode const* mapmode = mapmodes.get_item_by_index(index); if (mapmode == nullptr) { // Not an error if mapmodes haven't yet been loaded, // e.g. if we want to allocate the province colour // texture before mapmodes are loaded. - if (!(mapmodes.size() == 0 && index == 0)) { + if (!(mapmodes.empty() && index == 0)) { Logger::error("Invalid mapmode index: ", index); - ret = FAILURE; + ret = false; } mapmode = &Mapmode::ERROR_MAPMODE; } @@ -439,14 +437,14 @@ Pop::pop_size_t Map::get_total_map_population() const { return total_map_population; } -return_t Map::setup(GoodManager const& good_manager, BuildingManager const& building_manager, PopManager const& pop_manager) { - return_t ret = SUCCESS; +bool Map::setup(GoodManager const& good_manager, BuildingManager const& building_manager, PopManager const& pop_manager) { + bool ret = true; for (Province& province : provinces.get_items()) { province.clear_pops(); // Set all land provinces to have an RGO based on their index to test them if (!province.is_water() && good_manager.get_good_count() > 0) province.rgo = good_manager.get_good_by_index(province.get_index() % good_manager.get_good_count()); - if (building_manager.generate_province_buildings(province) != SUCCESS) ret = FAILURE; + ret &= building_manager.generate_province_buildings(province); } return ret; } @@ -465,18 +463,18 @@ void Map::tick(Date const& today) { using namespace ovdl::csv; -static return_t validate_province_definitions_header(LineObject const& header) { +static bool validate_province_definitions_header(LineObject const& header) { static const std::vector<std::string> standard_header { "province", "red", "green", "blue" }; for (size_t i = 0; i < standard_header.size(); ++i) { const std::string_view val = header.get_value_for(i); if (i == 0 && val.empty()) break; - if (val != standard_header[i]) return FAILURE; + if (val != standard_header[i]) return false; } - return SUCCESS; + return true; } -static return_t parse_province_colour(colour_t& colour, std::array<std::string_view, 3> components) { - return_t ret = SUCCESS; +static bool parse_province_colour(colour_t& colour, std::array<std::string_view, 3> components) { + bool ret = true; colour = NULL_COLOUR; for (std::string_view& c : components) { colour <<= 8; @@ -486,43 +484,43 @@ static return_t parse_province_colour(colour_t& colour, std::array<std::string_v if (successful && val <= 255) { colour |= val; } else { - ret = FAILURE; + ret = false; } } return ret; } -return_t Map::load_province_definitions(std::vector<LineObject> const& lines) { +bool Map::load_province_definitions(std::vector<LineObject> const& lines) { if (lines.empty()) { Logger::error("No header or entries in province definition file!"); - return FAILURE; + return false; } { LineObject const& header = lines.front(); - if (validate_province_definitions_header(header) != SUCCESS) { + if (!validate_province_definitions_header(header)) { Logger::error("Non-standard province definition file header - make sure this is not a province definition: ", header); } } if (lines.size() <= 1) { Logger::error("No entries in province definition file!"); - return FAILURE; + return false; } provinces.reserve(lines.size() - 1); - return_t ret = SUCCESS; + bool ret = true; std::for_each(lines.begin() + 1, lines.end(), [this, &ret](LineObject const& line) -> void { const std::string_view identifier = line.get_value_for(0); if (!identifier.empty()) { colour_t colour; - if (parse_province_colour(colour, { + if (!parse_province_colour(colour, { line.get_value_for(1), line.get_value_for(2), line.get_value_for(3) - }) != SUCCESS) { + })) { Logger::error("Error reading colour in province definition: ", line); - ret = FAILURE; + ret = false; } - if (add_province(identifier, colour) != SUCCESS) ret = FAILURE; + ret &= add_province(identifier, colour); } } ); diff --git a/src/openvic/map/Map.hpp b/src/openvic/map/Map.hpp index 0a2c7c6..4684226 100644 --- a/src/openvic/map/Map.hpp +++ b/src/openvic/map/Map.hpp @@ -65,12 +65,12 @@ namespace OpenVic { public: Map(); - return_t add_province(const std::string_view identifier, colour_t colour); + bool add_province(const std::string_view identifier, colour_t colour); void lock_provinces(); - return_t set_water_province(const std::string_view identifier); - return_t set_water_province_list(std::vector<std::string_view> const& list); + bool set_water_province(const std::string_view identifier); + bool set_water_province_list(std::vector<std::string_view> const& list); void lock_water_provinces(); - return_t add_region(const std::string_view identifier, std::vector<std::string_view> const& province_identifiers); + bool add_region(const std::string_view identifier, std::vector<std::string_view> const& province_identifiers); void lock_regions(); size_t get_province_count() const; @@ -80,7 +80,7 @@ namespace OpenVic { Province* get_province_by_identifier(const std::string_view identifier); Province const* get_province_by_identifier(const std::string_view identifier) const; Province::index_t get_province_index_at(size_t x, size_t y) const; - return_t set_max_provinces(Province::index_t new_max_provinces); + bool set_max_provinces(Province::index_t new_max_provinces); Province::index_t get_max_provinces() const; void set_selected_province(Province::index_t index); Province::index_t get_selected_province_index() const; @@ -91,22 +91,22 @@ namespace OpenVic { size_t get_region_count() const; std::vector<Region> const& get_regions() const; - return_t generate_province_shape_image(size_t new_width, size_t new_height, uint8_t const* colour_data, + bool generate_province_shape_image(size_t new_width, size_t new_height, uint8_t const* colour_data, uint8_t const* terrain_data, terrain_variant_map_t const& terrain_variant_map, bool detailed_errors); size_t get_width() const; size_t get_height() const; std::vector<shape_pixel_t> const& get_province_shape_image() const; - return_t add_mapmode(const std::string_view identifier, Mapmode::colour_func_t colour_func); + bool add_mapmode(const std::string_view identifier, Mapmode::colour_func_t colour_func); void lock_mapmodes(); size_t get_mapmode_count() const; std::vector<Mapmode> const& get_mapmodes() const; Mapmode const* get_mapmode_by_index(Mapmode::index_t index) const; Mapmode const* get_mapmode_by_identifier(const std::string_view identifier) const; static constexpr size_t MAPMODE_COLOUR_SIZE = 4; - return_t generate_mapmode_colours(Mapmode::index_t index, uint8_t* target) const; + bool generate_mapmode_colours(Mapmode::index_t index, uint8_t* target) const; - return_t setup(GoodManager const& good_manager, BuildingManager const& building_manager, PopManager const& pop_manager); + bool setup(GoodManager const& good_manager, BuildingManager const& building_manager, PopManager const& pop_manager); void update_highest_province_population(); Pop::pop_size_t get_highest_province_population() const; @@ -116,6 +116,6 @@ namespace OpenVic { void update_state(Date const& today); void tick(Date const& today); - return_t load_province_definitions(std::vector<ovdl::csv::LineObject> const& lines); + bool load_province_definitions(std::vector<ovdl::csv::LineObject> const& lines); }; } diff --git a/src/openvic/map/Province.cpp b/src/openvic/map/Province.cpp index 7d03604..cfdc263 100644 --- a/src/openvic/map/Province.cpp +++ b/src/openvic/map/Province.cpp @@ -30,7 +30,7 @@ Province::life_rating_t Province::get_life_rating() const { return life_rating; } -return_t Province::add_building(Building&& building) { +bool Province::add_building(Building&& building) { return buildings.add_item(std::move(building)); } @@ -54,9 +54,9 @@ std::vector<Building> const& Province::get_buildings() const { return buildings.get_items(); } -return_t Province::expand_building(const std::string_view building_type_identifier) { +bool Province::expand_building(const std::string_view building_type_identifier) { Building* building = buildings.get_item_by_identifier(building_type_identifier); - if (building == nullptr) return FAILURE; + if (building == nullptr) return false; return building->expand(); } @@ -70,22 +70,22 @@ std::string Province::to_string() const { return stream.str(); } -return_t Province::load_pop_list(PopManager const& pop_manager, ast::NodeCPtr root) { +bool Province::load_pop_list(PopManager const& pop_manager, ast::NodeCPtr root) { return expect_list_reserve_length( pops, - [this, &pop_manager](ast::NodeCPtr pop_node) -> return_t { + [this, &pop_manager](ast::NodeCPtr pop_node) -> bool { return pop_manager.load_pop_into_province(*this, pop_node); } )(root); } -return_t Province::add_pop(Pop&& pop) { +bool Province::add_pop(Pop&& pop) { if (!is_water()) { pops.push_back(std::move(pop)); - return SUCCESS; + return true; } else { Logger::error("Trying to add pop to water province ", get_identifier()); - return FAILURE; + return false; } } diff --git a/src/openvic/map/Province.hpp b/src/openvic/map/Province.hpp index 364bbf8..f64bca2 100644 --- a/src/openvic/map/Province.hpp +++ b/src/openvic/map/Province.hpp @@ -41,18 +41,18 @@ namespace OpenVic { Region* get_region() const; bool is_water() const; life_rating_t get_life_rating() const; - return_t add_building(Building&& building); + bool add_building(Building&& building); void lock_buildings(); void reset_buildings(); Building const* get_building_by_identifier(const std::string_view identifier) const; size_t get_building_count() const; std::vector<Building> const& get_buildings() const; - return_t expand_building(const std::string_view building_type_identifier); + bool expand_building(const std::string_view building_type_identifier); Good const* get_rgo() const; std::string to_string() const; - return_t load_pop_list(PopManager const& pop_manager, ast::NodeCPtr root); - return_t add_pop(Pop&& pop); + bool load_pop_list(PopManager const& pop_manager, ast::NodeCPtr root); + bool add_pop(Pop&& pop); void clear_pops(); size_t get_pop_count() const; std::vector<Pop> const& get_pops() const; diff --git a/src/openvic/map/Region.cpp b/src/openvic/map/Region.cpp index 6372e15..33092c5 100644 --- a/src/openvic/map/Region.cpp +++ b/src/openvic/map/Region.cpp @@ -2,21 +2,21 @@ using namespace OpenVic; -return_t ProvinceSet::add_province(Province* province) { +bool ProvinceSet::add_province(Province* province) { if (locked) { Logger::error("Cannot add province to province set - locked!"); - return FAILURE; + return false; } if (province == nullptr) { Logger::error("Cannot add province to province set - null province!"); - return FAILURE; + return false; } if (contains_province(province)) { Logger::error("Cannot add province ", province->get_identifier(), " to province set - already in the set!"); - return FAILURE; + return false; } provinces.push_back(province); - return SUCCESS; + return true; } void ProvinceSet::lock(bool log) { @@ -37,6 +37,10 @@ void ProvinceSet::reset() { locked = false; } +bool ProvinceSet::empty() const { + return provinces.empty(); +} + size_t ProvinceSet::size() const { return provinces.size(); } diff --git a/src/openvic/map/Region.hpp b/src/openvic/map/Region.hpp index e67edaa..a3640ca 100644 --- a/src/openvic/map/Region.hpp +++ b/src/openvic/map/Region.hpp @@ -10,10 +10,11 @@ namespace OpenVic { bool locked = false; public: - return_t add_province(Province* province); + bool add_province(Province* province); void lock(bool log = false); bool is_locked() const; void reset(); + bool empty() const; size_t size() const; void reserve(size_t size); bool contains_province(Province const* province) const; diff --git a/src/openvic/pop/Culture.cpp b/src/openvic/pop/Culture.cpp index 2670f00..d86d608 100644 --- a/src/openvic/pop/Culture.cpp +++ b/src/openvic/pop/Culture.cpp @@ -50,10 +50,10 @@ CultureManager::CultureManager() culture_groups { "culture groups" }, cultures { "cultures" } {} -return_t CultureManager::add_graphical_culture_type(const std::string_view identifier) { +bool CultureManager::add_graphical_culture_type(const std::string_view identifier) { if (identifier.empty()) { Logger::error("Invalid culture group identifier - empty!"); - return FAILURE; + return false; } return graphical_culture_types.add_item({ identifier }); } @@ -74,22 +74,22 @@ std::vector<GraphicalCultureType> const& CultureManager::get_graphical_culture_t return graphical_culture_types.get_items(); } -return_t CultureManager::add_culture_group(const std::string_view identifier, const std::string_view leader, GraphicalCultureType const* graphical_culture_type, bool is_overseas) { +bool CultureManager::add_culture_group(const std::string_view identifier, const std::string_view leader, GraphicalCultureType const* graphical_culture_type, bool is_overseas) { if (!graphical_culture_types.is_locked()) { Logger::error("Cannot register culture groups until graphical culture types are locked!"); - return FAILURE; + return false; } if (identifier.empty()) { Logger::error("Invalid culture group identifier - empty!"); - return FAILURE; + return false; } if (leader.empty()) { Logger::error("Invalid culture group leader - empty!"); - return FAILURE; + return false; } if (graphical_culture_type == nullptr) { Logger::error("Null graphical culture type for ", identifier); - return FAILURE; + return false; } return culture_groups.add_item({ identifier, leader, *graphical_culture_type, is_overseas }); } @@ -110,22 +110,22 @@ std::vector<CultureGroup> const& CultureManager::get_culture_groups() const { return culture_groups.get_items(); } -return_t CultureManager::add_culture(const std::string_view identifier, colour_t colour, CultureGroup const* group, std::vector<std::string> const& first_names, std::vector<std::string> const& last_names) { +bool CultureManager::add_culture(const std::string_view identifier, colour_t colour, CultureGroup const* group, std::vector<std::string> const& first_names, std::vector<std::string> const& last_names) { if (!culture_groups.is_locked()) { Logger::error("Cannot register cultures until culture groups are locked!"); - return FAILURE; + return false; } if (identifier.empty()) { Logger::error("Invalid culture identifier - empty!"); - return FAILURE; + return false; } if (group == nullptr) { Logger::error("Null culture group for ", identifier); - return FAILURE; + return false; } if (colour > MAX_COLOUR_RGB) { Logger::error("Invalid culture colour for ", identifier, ": ", colour_to_hex_string(colour)); - return FAILURE; + return false; } return cultures.add_item({ identifier, colour, *group, first_names, last_names }); } @@ -146,8 +146,8 @@ std::vector<Culture> const& CultureManager::get_cultures() const { return cultures.get_items(); } -return_t CultureManager::load_graphical_culture_type_file(ast::NodeCPtr root) { - const return_t ret = expect_list_reserve_length( +bool CultureManager::load_graphical_culture_type_file(ast::NodeCPtr root) { + const bool ret = expect_list_reserve_length( graphical_culture_types, expect_identifier( std::bind(&CultureManager::add_graphical_culture_type, this, std::placeholders::_1) @@ -157,10 +157,10 @@ return_t CultureManager::load_graphical_culture_type_file(ast::NodeCPtr root) { return ret; } -return_t CultureManager::load_culture_file(ast::NodeCPtr root) { +bool CultureManager::load_culture_file(ast::NodeCPtr root) { if (!graphical_culture_types.is_locked()) { Logger::error("Cannot load culture groups until graphical culture types are locked!"); - return FAILURE; + return false; } static const std::string default_unit_graphical_culture_type_identifier = "Generic"; @@ -170,14 +170,14 @@ return_t CultureManager::load_culture_file(ast::NodeCPtr root) { } size_t total_expected_cultures = 0; - return_t ret = expect_dictionary_reserve_length( + bool ret = expect_dictionary_reserve_length( culture_groups, - [this, default_unit_graphical_culture_type, &total_expected_cultures](std::string_view key, ast::NodeCPtr value) -> return_t { + [this, default_unit_graphical_culture_type, &total_expected_cultures](std::string_view key, ast::NodeCPtr value) -> bool { std::string_view leader; GraphicalCultureType const* unit_graphical_culture_type = default_unit_graphical_culture_type; bool is_overseas = true; - return_t ret = expect_dictionary_keys_and_length( + bool ret = expect_dictionary_keys_and_length( [&total_expected_cultures](size_t size) -> size_t { total_expected_cultures += size; return size; @@ -186,48 +186,48 @@ return_t CultureManager::load_culture_file(ast::NodeCPtr root) { "leader", ONE_EXACTLY, expect_identifier(assign_variable_callback(leader)), "unit", ZERO_OR_ONE, expect_identifier( - [this, &unit_graphical_culture_type](std::string_view identifier) -> return_t { + [this, &unit_graphical_culture_type](std::string_view identifier) -> bool { unit_graphical_culture_type = get_graphical_culture_type_by_identifier(identifier); - if (unit_graphical_culture_type != nullptr) return SUCCESS; + if (unit_graphical_culture_type != nullptr) return true; Logger::error("Invalid unit graphical culture type: ", identifier); - return FAILURE; + return false; } ), "union", ZERO_OR_ONE, success_callback, "is_overseas", ZERO_OR_ONE, expect_bool(assign_variable_callback(is_overseas)) )(value); - if (add_culture_group(key, leader, unit_graphical_culture_type, is_overseas) != SUCCESS) ret = FAILURE; + ret &= add_culture_group(key, leader, unit_graphical_culture_type, is_overseas); return ret; } )(root); lock_culture_groups(); cultures.reserve(cultures.size() + total_expected_cultures); - if (expect_dictionary( - [this](std::string_view culture_group_key, ast::NodeCPtr culture_group_value) -> return_t { + ret &= expect_dictionary( + [this](std::string_view culture_group_key, ast::NodeCPtr culture_group_value) -> bool { CultureGroup const* culture_group = get_culture_group_by_identifier(culture_group_key); return expect_dictionary( - [this, culture_group](std::string_view key, ast::NodeCPtr value) -> return_t { - if (key == "leader" || key == "unit" || key == "union" || key == "is_overseas") return SUCCESS; + [this, culture_group](std::string_view key, ast::NodeCPtr value) -> bool { + if (key == "leader" || key == "unit" || key == "union" || key == "is_overseas") return true; colour_t colour = NULL_COLOUR; std::vector<std::string> first_names, last_names; - return_t ret = expect_dictionary_keys( + bool ret = expect_dictionary_keys( "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), "first_names", ONE_EXACTLY, name_list_callback(first_names), "last_names", ONE_EXACTLY, name_list_callback(last_names), "radicalism", ZERO_OR_ONE, success_callback, "primary", ZERO_OR_ONE, success_callback )(value); - if (add_culture(key, colour, culture_group, first_names, last_names) != SUCCESS) ret = FAILURE; + ret &= add_culture(key, colour, culture_group, first_names, last_names); return ret; } )(culture_group_value); } - )(root) != SUCCESS) ret = FAILURE; + )(root); lock_cultures(); return ret; } diff --git a/src/openvic/pop/Culture.hpp b/src/openvic/pop/Culture.hpp index 6028fea..cc6c2a6 100644 --- a/src/openvic/pop/Culture.hpp +++ b/src/openvic/pop/Culture.hpp @@ -65,25 +65,25 @@ namespace OpenVic { public: CultureManager(); - return_t add_graphical_culture_type(const std::string_view identifier); + bool add_graphical_culture_type(const std::string_view identifier); void lock_graphical_culture_types(); GraphicalCultureType const* get_graphical_culture_type_by_identifier(const std::string_view identifier) const; size_t get_graphical_culture_type_count() const; std::vector<GraphicalCultureType> const& get_graphical_culture_types() const; - return_t add_culture_group(const std::string_view identifier, const std::string_view leader, GraphicalCultureType const* new_graphical_culture_type, bool is_overseas); + bool add_culture_group(const std::string_view identifier, const std::string_view leader, GraphicalCultureType const* new_graphical_culture_type, bool is_overseas); void lock_culture_groups(); CultureGroup const* get_culture_group_by_identifier(const std::string_view identifier) const; size_t get_culture_group_count() const; std::vector<CultureGroup> const& get_culture_groups() const; - return_t add_culture(const std::string_view identifier, colour_t colour, CultureGroup const* group, std::vector<std::string> const& first_names, std::vector<std::string> const& last_names); + bool add_culture(const std::string_view identifier, colour_t colour, CultureGroup const* group, std::vector<std::string> const& first_names, std::vector<std::string> const& last_names); void lock_cultures(); Culture const* get_culture_by_identifier(const std::string_view identifier) const; size_t get_culture_count() const; std::vector<Culture> const& get_cultures() const; - return_t load_graphical_culture_type_file(ast::NodeCPtr root); - return_t load_culture_file(ast::NodeCPtr root); + bool load_graphical_culture_type_file(ast::NodeCPtr root); + bool load_culture_file(ast::NodeCPtr root); }; } diff --git a/src/openvic/pop/Pop.cpp b/src/openvic/pop/Pop.cpp index 4c188f1..fbe8708 100644 --- a/src/openvic/pop/Pop.cpp +++ b/src/openvic/pop/Pop.cpp @@ -101,27 +101,27 @@ bool PopType::get_is_slave() const { PopManager::PopManager() : pop_types { "pop types" } {} -return_t PopManager::add_pop_type(const std::string_view identifier, colour_t colour, PopType::strata_t strata, PopType::sprite_t sprite, +bool PopManager::add_pop_type(const std::string_view identifier, colour_t colour, PopType::strata_t strata, PopType::sprite_t sprite, Pop::pop_size_t max_size, Pop::pop_size_t merge_max_size, bool state_capital_only, bool demote_migrant, bool is_artisan, bool is_slave) { if (identifier.empty()) { Logger::error("Invalid pop type identifier - empty!"); - return FAILURE; + return false; } if (colour > MAX_COLOUR_RGB) { Logger::error("Invalid pop type colour for ", identifier, ": ", colour_to_hex_string(colour)); - return FAILURE; + return false; } if (sprite <= 0) { Logger::error("Invalid pop type sprite index for ", identifier, ": ", sprite); - return FAILURE; + return false; } if (max_size <= 0) { Logger::error("Invalid pop type max size for ", identifier, ": ", max_size); - return FAILURE; + return false; } if (merge_max_size <= 0) { Logger::error("Invalid pop type merge max size for ", identifier, ": ", merge_max_size); - return FAILURE; + return false; } return pop_types.add_item({ identifier, colour, strata, sprite, max_size, merge_max_size, state_capital_only, demote_migrant, is_artisan, is_slave }); } @@ -142,40 +142,40 @@ std::vector<PopType> const& PopManager::get_pop_types() const { return pop_types.get_items(); } -return_t PopManager::load_pop_type_file(std::filesystem::path const& path, ast::NodeCPtr root) { +bool PopManager::load_pop_type_file(std::filesystem::path const& path, ast::NodeCPtr root) { // TODO - pop type loading if (pop_types.empty()) return add_pop_type("test_pop_type", 0xFF0000, PopType::strata_t::POOR, 1, 1, 1, false, false, false, false); - return SUCCESS; + return true; } -return_t PopManager::load_pop_into_province(Province& province, ast::NodeCPtr root) const { +bool PopManager::load_pop_into_province(Province& province, ast::NodeCPtr root) const { static PopType const* type = get_pop_type_by_identifier("test_pop_type"); Culture const* culture = nullptr; Religion const* religion = nullptr; Pop::pop_size_t size = 0; - return_t ret = expect_assign( - [this, &culture, &religion, &size](std::string_view, ast::NodeCPtr pop_node) -> return_t { + bool ret = expect_assign( + [this, &culture, &religion, &size](std::string_view, ast::NodeCPtr pop_node) -> bool { return expect_dictionary_keys( "culture", ONE_EXACTLY, expect_identifier( - [&culture, this](std::string_view identifier) -> return_t { + [&culture, this](std::string_view identifier) -> bool { culture = culture_manager.get_culture_by_identifier(identifier); - if (culture != nullptr) return SUCCESS; + if (culture != nullptr) return true; Logger::error("Invalid pop culture: ", identifier); - return FAILURE; + return false; } ), "religion", ONE_EXACTLY, expect_identifier( - [&religion, this](std::string_view identifier) -> return_t { + [&religion, this](std::string_view identifier) -> bool { religion = religion_manager.get_religion_by_identifier(identifier); - if (religion != nullptr) return SUCCESS; + if (religion != nullptr) return true; Logger::error("Invalid pop religion: ", identifier); - return FAILURE; + return false; } ), "size", ONE_EXACTLY, expect_uint(assign_variable_callback_uint("pop size", size)), @@ -186,10 +186,10 @@ return_t PopManager::load_pop_into_province(Province& province, ast::NodeCPtr ro )(root); if (type != nullptr && culture != nullptr && religion != nullptr && size > 0) { - if (province.add_pop({ *type, *culture, *religion, size }) != SUCCESS) ret = FAILURE; + ret &= province.add_pop({ *type, *culture, *religion, size }); } else { Logger::error("Some pop arguments are invalid: type = ", type, ", culture = ", culture, ", religion = ", religion, ", size = ", size); - ret = FAILURE; + ret = false; } return ret; } diff --git a/src/openvic/pop/Pop.hpp b/src/openvic/pop/Pop.hpp index eab7c20..f4694f0 100644 --- a/src/openvic/pop/Pop.hpp +++ b/src/openvic/pop/Pop.hpp @@ -90,7 +90,7 @@ namespace OpenVic { PopManager(); - return_t add_pop_type(const std::string_view identifier, colour_t new_colour, PopType::strata_t strata, PopType::sprite_t sprite, + bool add_pop_type(const std::string_view identifier, colour_t new_colour, PopType::strata_t strata, PopType::sprite_t sprite, Pop::pop_size_t max_size, Pop::pop_size_t merge_max_size, bool state_capital_only, bool demote_migrant, bool is_artisan, bool is_slave); void lock_pop_types(); @@ -98,7 +98,7 @@ namespace OpenVic { size_t get_pop_type_count() const; std::vector<PopType> const& get_pop_types() const; - return_t load_pop_type_file(std::filesystem::path const& path, ast::NodeCPtr root); - return_t load_pop_into_province(Province& province, ast::NodeCPtr root) const; + bool load_pop_type_file(std::filesystem::path const& path, ast::NodeCPtr root); + bool load_pop_into_province(Province& province, ast::NodeCPtr root) const; }; } diff --git a/src/openvic/pop/Religion.cpp b/src/openvic/pop/Religion.cpp index 58b73e5..f7c657a 100644 --- a/src/openvic/pop/Religion.cpp +++ b/src/openvic/pop/Religion.cpp @@ -32,10 +32,10 @@ ReligionManager::ReligionManager() : religion_groups { "religion groups" }, religions { "religions" } {} -return_t ReligionManager::add_religion_group(const std::string_view identifier) { +bool ReligionManager::add_religion_group(const std::string_view identifier) { if (identifier.empty()) { Logger::error("Invalid religion group identifier - empty!"); - return FAILURE; + return false; } return religion_groups.add_item({ identifier }); } @@ -56,26 +56,26 @@ std::vector<ReligionGroup> const& ReligionManager::get_religion_groups() const { return religion_groups.get_items(); } -return_t ReligionManager::add_religion(const std::string_view identifier, colour_t colour, ReligionGroup const* group, Religion::icon_t icon, bool pagan) { +bool ReligionManager::add_religion(const std::string_view identifier, colour_t colour, ReligionGroup const* group, Religion::icon_t icon, bool pagan) { if (!religion_groups.is_locked()) { Logger::error("Cannot register religions until religion groups are locked!"); - return FAILURE; + return false; } if (identifier.empty()) { Logger::error("Invalid religion identifier - empty!"); - return FAILURE; + return false; } if (group == nullptr) { Logger::error("Null religion group for ", identifier); - return FAILURE; + return false; } if (colour > MAX_COLOUR_RGB) { Logger::error("Invalid religion colour for ", identifier, ": ", colour_to_hex_string(colour)); - return FAILURE; + return false; } if (icon <= 0) { Logger::error("Invalid religion icon for ", identifier, ": ", icon); - return FAILURE; + return false; } return religions.add_item({ identifier, colour, *group, icon, pagan }); } @@ -96,47 +96,47 @@ std::vector<Religion> const& ReligionManager::get_religions() const { return religions.get_items(); } -return_t ReligionManager::load_religion_file(ast::NodeCPtr root) { +bool ReligionManager::load_religion_file(ast::NodeCPtr root) { size_t total_expected_religions = 0; - return_t ret = expect_dictionary_reserve_length( + bool ret = expect_dictionary_reserve_length( religion_groups, - [this, &total_expected_religions](std::string_view key, ast::NodeCPtr value) -> return_t { - return_t ret = expect_list_and_length( + [this, &total_expected_religions](std::string_view key, ast::NodeCPtr value) -> bool { + bool ret = expect_list_and_length( [&total_expected_religions](size_t size) -> size_t { total_expected_religions += size; return 0; }, success_callback )(value); - if (add_religion_group(key) != SUCCESS) ret = FAILURE; + ret &= add_religion_group(key); return ret; } )(root); lock_religion_groups(); religions.reserve(religions.size() + total_expected_religions); - if (expect_dictionary( - [this](std::string_view religion_group_key, ast::NodeCPtr religion_group_value) -> return_t { + ret &= expect_dictionary( + [this](std::string_view religion_group_key, ast::NodeCPtr religion_group_value) -> bool { ReligionGroup const* religion_group = get_religion_group_by_identifier(religion_group_key); return expect_dictionary( - [this, religion_group](std::string_view key, ast::NodeCPtr value) -> return_t { + [this, religion_group](std::string_view key, ast::NodeCPtr value) -> bool { colour_t colour = NULL_COLOUR; Religion::icon_t icon = 0; bool pagan = false; - return_t ret = expect_dictionary_keys( + bool ret = expect_dictionary_keys( "icon", ONE_EXACTLY, expect_uint(assign_variable_callback_uint("religion icon", icon)), "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), "pagan", ZERO_OR_ONE, expect_bool(assign_variable_callback(pagan)) )(value); - if (add_religion(key, colour, religion_group, icon, pagan) != SUCCESS) ret = FAILURE; + ret &= add_religion(key, colour, religion_group, icon, pagan); return ret; } )(religion_group_value); } - )(root) != SUCCESS) ret = FAILURE; + )(root); lock_religions(); return ret; } diff --git a/src/openvic/pop/Religion.hpp b/src/openvic/pop/Religion.hpp index 12db36c..f04b035 100644 --- a/src/openvic/pop/Religion.hpp +++ b/src/openvic/pop/Religion.hpp @@ -45,18 +45,18 @@ namespace OpenVic { public: ReligionManager(); - return_t add_religion_group(const std::string_view identifier); + bool add_religion_group(const std::string_view identifier); void lock_religion_groups(); ReligionGroup const* get_religion_group_by_identifier(const std::string_view identifier) const; size_t get_religion_group_count() const; std::vector<ReligionGroup> const& get_religion_groups() const; - return_t add_religion(const std::string_view identifier, colour_t colour, ReligionGroup const* group, Religion::icon_t icon, bool pagan); + bool add_religion(const std::string_view identifier, colour_t colour, ReligionGroup const* group, Religion::icon_t icon, bool pagan); void lock_religions(); Religion const* get_religion_by_identifier(const std::string_view identifier) const; size_t get_religion_count() const; std::vector<Religion> const& get_religions() const; - return_t load_religion_file(ast::NodeCPtr root); + bool load_religion_file(ast::NodeCPtr root); }; } diff --git a/src/openvic/types/IdentifierRegistry.hpp b/src/openvic/types/IdentifierRegistry.hpp index 54b466e..502b74b 100644 --- a/src/openvic/types/IdentifierRegistry.hpp +++ b/src/openvic/types/IdentifierRegistry.hpp @@ -4,7 +4,6 @@ #include <vector> #include "openvic/types/Colour.hpp" -#include "openvic/types/Return.hpp" #include "openvic/utility/Logger.hpp" namespace OpenVic { @@ -84,19 +83,19 @@ namespace OpenVic { public: IdentifierRegistry(const std::string_view new_name) : name { new_name } {} - return_t add_item(T&& item) { + bool add_item(T&& item) { if (locked) { Logger::error("Cannot add item to the ", name, " registry - locked!"); - return FAILURE; + return false; } T const* old_item = get_item_by_identifier(item.get_identifier()); if (old_item != nullptr) { Logger::error("Cannot add item to the ", name, " registry - an item with the identifier \"", item.get_identifier(), "\" already exists!"); - return FAILURE; + return false; } identifier_index_map[item.get_identifier()] = items.size(); items.push_back(std::move(item)); - return SUCCESS; + return true; } void lock(bool log = true) { if (locked) { diff --git a/src/openvic/types/Return.hpp b/src/openvic/types/Return.hpp deleted file mode 100644 index 04c3734..0000000 --- a/src/openvic/types/Return.hpp +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -namespace OpenVic { - using return_t = bool; - - // This mirrors godot::Error, where `OK = 0` and `FAILED = 1`. - constexpr return_t SUCCESS = false, FAILURE = true; -} diff --git a/src/openvic/utility/BMP.cpp b/src/openvic/utility/BMP.cpp index 6859411..0ea0f30 100644 --- a/src/openvic/utility/BMP.cpp +++ b/src/openvic/utility/BMP.cpp @@ -11,57 +11,58 @@ BMP::~BMP() { close(); } -return_t BMP::open(char const* filepath) { +bool BMP::open(char const* filepath) { reset(); errno = 0; file = fopen(filepath, "rb"); if (file == nullptr || errno != 0) { Logger::error("Failed to open BMP file \"", filepath, "\" (errno = ", errno, ")"); file = nullptr; - return FAILURE; + return false; } - return SUCCESS; + return true; } -return_t BMP::read_header() { +bool BMP::read_header() { if (header_validated) { Logger::error("BMP header already validated!"); - return FAILURE; + return false; } if (file == nullptr) { Logger::error("Cannot read BMP header before opening a file"); - return FAILURE; + return false; } if (fseek(file, 0, SEEK_SET) != 0) { Logger::error("Failed to move to the beginning of the BMP file!"); - return FAILURE; + return false; } if (fread(&header, sizeof(header), 1, file) != 1) { Logger::error("Failed to read BMP header!"); - return FAILURE; + return false; } - return_t ret = SUCCESS; + + header_validated = true; // Validate constants static constexpr uint16_t BMP_SIGNATURE = 0x4d42; if (header.signature != BMP_SIGNATURE) { Logger::error("Invalid BMP signature: ", header.signature, " (must be ", BMP_SIGNATURE, ")"); - ret = FAILURE; + header_validated = false; } static constexpr uint32_t DIB_HEADER_SIZE = 40; if (header.dib_header_size != DIB_HEADER_SIZE) { Logger::error("Invalid BMP DIB header size: ", header.dib_header_size, " (must be ", DIB_HEADER_SIZE, ")"); - ret = FAILURE; + header_validated = false; } static constexpr uint16_t NUM_PLANES = 1; if (header.num_planes != NUM_PLANES) { Logger::error("Invalid BMP plane count: ", header.num_planes, " (must be ", NUM_PLANES, ")"); - ret = FAILURE; + header_validated = false; } static constexpr uint16_t COMPRESSION = 0; // Only support uncompressed BMPs if (header.compression != COMPRESSION) { Logger::error("Invalid BMP compression method: ", header.compression, " (must be ", COMPRESSION, ")"); - ret = FAILURE; + header_validated = false; } // Validate sizes and dimensions @@ -69,17 +70,17 @@ return_t BMP::read_header() { if (header.file_size != header.offset + header.image_size_bytes) { Logger::error("Invalid BMP memory sizes: file size = ", header.file_size, " != ", header.offset + header.image_size_bytes, " = ", header.offset, " + ", header.image_size_bytes, " = image data offset + image data size"); - ret = FAILURE; + header_validated = false; } // TODO - support negative widths (i.e. horizontal flip) if (header.width_px <= 0) { Logger::error("Invalid BMP width: ", header.width_px, " (must be positive)"); - ret = FAILURE; + header_validated = false; } // TODO - support negative heights (i.e. vertical flip) if (header.height_px <= 0) { Logger::error("Invalid BMP height: ", header.height_px, " (must be positive)"); - ret = FAILURE; + header_validated = false; } // TODO - validate x_resolution_ppm // TODO - validate y_resolution_ppm @@ -90,14 +91,14 @@ return_t BMP::read_header() { static const std::set<uint16_t> BITS_PER_PIXEL { VALID_BITS_PER_PIXEL }; if (!BITS_PER_PIXEL.contains(header.bits_per_pixel)) { Logger::error("Invalid BMP bits per pixel: ", header.bits_per_pixel, " (must be one of " STR(VALID_BITS_PER_PIXEL) ")"); - ret = FAILURE; + header_validated = false; } #undef VALID_BITS_PER_PIXEL #undef STR static constexpr uint16_t PALETTE_BITS_PER_PIXEL_LIMIT = 8; if (header.num_colours != 0 && header.bits_per_pixel > PALETTE_BITS_PER_PIXEL_LIMIT) { Logger::error("Invalid BMP palette size: ", header.num_colours, " (should be 0 as bits per pixel is ", header.bits_per_pixel, " > 8)"); - ret = FAILURE; + header_validated = false; } // TODO - validate important_colours @@ -109,37 +110,36 @@ return_t BMP::read_header() { const uint32_t expected_offset = palette_size * PALETTE_COLOUR_SIZE + sizeof(header); if (header.offset != expected_offset) { Logger::error("Invalid BMP image data offset: ", header.offset, " (should be ", expected_offset, ")"); - ret = FAILURE; + header_validated = false; } - header_validated = ret == SUCCESS; - return ret; + return header_validated; } -return_t BMP::read_palette() { +bool BMP::read_palette() { if (file == nullptr) { Logger::error("Cannot read BMP palette before opening a file"); - return FAILURE; + return false; } if (!header_validated) { Logger::error("Cannot read palette before BMP header is validated!"); - return FAILURE; + return false; } if (palette_size == 0) { Logger::error("Cannot read BMP palette - header indicates this file doesn't have one"); - return FAILURE; + return false; } if (fseek(file, sizeof(header), SEEK_SET) != 0) { Logger::error("Failed to move to the palette in the BMP file!"); - return FAILURE; + return false; } palette.resize(palette_size); if (fread(palette.data(), palette_size * PALETTE_COLOUR_SIZE, 1, file) != 1) { Logger::error("Failed to read BMP header!"); palette.clear(); - return FAILURE; + return false; } - return SUCCESS; + return true; } void BMP::close() { diff --git a/src/openvic/utility/BMP.hpp b/src/openvic/utility/BMP.hpp index 50b333b..7ed36a5 100644 --- a/src/openvic/utility/BMP.hpp +++ b/src/openvic/utility/BMP.hpp @@ -4,7 +4,6 @@ #include <vector> #include "openvic/types/Colour.hpp" -#include "openvic/types/Return.hpp" namespace OpenVic { class BMP { @@ -41,9 +40,9 @@ namespace OpenVic { BMP() = default; ~BMP(); - return_t open(char const* filepath); - return_t read_header(); - return_t read_palette(); + bool open(char const* filepath); + bool read_header(); + bool read_palette(); void close(); void reset(); |