diff options
Diffstat (limited to 'src')
19 files changed, 1122 insertions, 225 deletions
diff --git a/src/openvic-simulation/GameManager.hpp b/src/openvic-simulation/GameManager.hpp index 9ee3442..6be2938 100644 --- a/src/openvic-simulation/GameManager.hpp +++ b/src/openvic-simulation/GameManager.hpp @@ -5,6 +5,7 @@ #include "openvic-simulation/country/Country.hpp" #include "openvic-simulation/economy/EconomyManager.hpp" #include "openvic-simulation/history/HistoryManager.hpp" +#include "openvic-simulation/interface/UI.hpp" #include "openvic-simulation/map/Map.hpp" #include "openvic-simulation/military/MilitaryManager.hpp" #include "openvic-simulation/misc/Define.hpp" @@ -24,6 +25,7 @@ namespace OpenVic { HistoryManager history_manager; PopManager pop_manager; CountryManager country_manager; + UIManager ui_manager; GameAdvancementHook clock; time_t session_start; /* SS-54, as well as allowing time-tracking */ @@ -47,6 +49,7 @@ namespace OpenVic { REF_GETTERS(history_manager) REF_GETTERS(pop_manager) REF_GETTERS(country_manager) + REF_GETTERS(ui_manager) REF_GETTERS(clock) bool setup(); diff --git a/src/openvic-simulation/dataloader/Dataloader.cpp b/src/openvic-simulation/dataloader/Dataloader.cpp index aefb6fc..011b524 100644 --- a/src/openvic-simulation/dataloader/Dataloader.cpp +++ b/src/openvic-simulation/dataloader/Dataloader.cpp @@ -36,8 +36,13 @@ using namespace ovdl; using StringUtils::append_string_views; -#define FILESYSTEM_CASE_INSENSITIVE (defined(_WIN32) || (defined(__APPLE__) && defined(__MACH__))) -#define FILESYSTEM_NEEDS_FORWARD_SLASHES (!defined(_WIN32)) +#if defined(_WIN32) || (defined(__APPLE__) && defined(__MACH__)) +#define FILESYSTEM_CASE_INSENSITIVE +#endif + +#if !defined(_WIN32) +#define FILESYSTEM_NEEDS_FORWARD_SLASHES +#endif static constexpr bool path_equals_case_insensitive(std::string_view lhs, std::string_view rhs) { constexpr auto ichar_equals = [](unsigned char l, unsigned char r) { @@ -48,7 +53,7 @@ static constexpr bool path_equals_case_insensitive(std::string_view lhs, std::st // Windows and Mac by default act like case insensitive filesystems static constexpr bool path_equals(std::string_view lhs, std::string_view rhs) { -#if FILESYSTEM_CASE_INSENSITIVE +#if defined(FILESYSTEM_CASE_INSENSITIVE) return path_equals_case_insensitive(lhs, rhs); #else return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); @@ -369,7 +374,7 @@ bool Dataloader::set_roots(path_vector_t const& new_roots) { } fs::path Dataloader::lookup_file(std::string_view path, bool print_error) const { -#if FILESYSTEM_NEEDS_FORWARD_SLASHES +#if defined(FILESYSTEM_NEEDS_FORWARD_SLASHES) /* Back-slashes need to be converted into forward-slashes */ const std::string forward_slash_path { StringUtils::make_forward_slash_path(StringUtils::remove_leading_slashes(path)) }; path = forward_slash_path; @@ -377,7 +382,7 @@ fs::path Dataloader::lookup_file(std::string_view path, bool print_error) const const fs::path filepath { path }; -#if FILESYSTEM_CASE_INSENSITIVE +#if defined(FILESYSTEM_CASE_INSENSITIVE) /* Case-insensitive filesystem */ for (fs::path const& root : roots) { const fs::path composed = root / filepath; @@ -411,34 +416,62 @@ fs::path Dataloader::lookup_file(std::string_view path, bool print_error) const return {}; } -template<typename _DirIterator, std::predicate<fs::path const&, fs::path const&> _Equiv> -Dataloader::path_vector_t Dataloader::_lookup_files_in_dir(std::string_view path, fs::path const& extension) const { -#if FILESYSTEM_NEEDS_FORWARD_SLASHES +fs::path Dataloader::lookup_image_file_or_dds(std::string_view path) const { + fs::path ret = lookup_file(path, false); + if (ret.empty()) { + // TODO - change search order so root order takes priority over extension replacement order + ret = lookup_file(append_string_views(StringUtils::remove_extension(path), ".dds"), false); + if (!ret.empty()) { + return ret; + } + Logger::error("Image lookup for ", path, " failed!"); + } + return ret; +} + +template<typename _DirIterator, typename _UniqueKey> +requires requires (_UniqueKey const& unique_key, std::string_view path) { + { unique_key(path) } -> std::convertible_to<std::string_view>; +} +Dataloader::path_vector_t Dataloader::_lookup_files_in_dir( + std::string_view path, fs::path const& extension, _UniqueKey const& unique_key +) const { +#if defined(FILESYSTEM_NEEDS_FORWARD_SLASHES) /* Back-slashes need to be converted into forward-slashes */ const std::string forward_slash_path { StringUtils::make_forward_slash_path(StringUtils::remove_leading_slashes(path)) }; path = forward_slash_path; #endif - const fs::path filepath { path }; - static constexpr _Equiv Equiv {}; + const fs::path dirpath { path }; path_vector_t ret; - size_t start_of_current_root_entries; + struct file_entry_t { + fs::path file; + fs::path const* root; + }; + string_map_t<file_entry_t> found_files; for (fs::path const& root : roots) { - start_of_current_root_entries = ret.size(); - const fs::path composed = root / filepath; + const size_t root_len = root.string().size(); + const fs::path composed = root / dirpath; std::error_code ec; for (fs::directory_entry const& entry : _DirIterator { composed, ec }) { if (entry.is_regular_file()) { - const fs::path file = entry; - if ((extension.empty() || file.extension() == extension) && !Equiv(file, {})) { - size_t index = 0; - for (; index < ret.size() && !Equiv(file, ret[index]); ++index) {} - if (index >= ret.size()) { - ret.push_back(file); - } else if (start_of_current_root_entries <= index) { - Logger::warning( - "Files in the same directory with conflicting names: ", ret[index], " (accepted) and ", file, - " (rejected)" - ); + fs::path file = entry; + if ((extension.empty() || file.extension() == extension)) { + const std::string full_path = file.string(); + std::string_view relative_path = full_path; + relative_path.remove_prefix(root_len); + relative_path = StringUtils::remove_leading_slashes(relative_path); + const std::string_view key = unique_key(relative_path); + if (!key.empty()) { + const typename decltype(found_files)::const_iterator it = found_files.find(key); + if (it == found_files.end()) { + found_files.emplace(key, file_entry_t { file, &root }); + ret.emplace_back(std::move(file)); + } else if (it->second.root == &root) { + Logger::warning( + "Files in the same directory with conflicting keys: ", it->first, " - ", it->second.file, + " (accepted) and ", key, " - ", file, " (rejected)" + ); + } } } } @@ -447,38 +480,28 @@ Dataloader::path_vector_t Dataloader::_lookup_files_in_dir(std::string_view path return ret; } -struct EquivFilename { - bool operator()(fs::path const& lhs, fs::path const& rhs) const { - return lhs.filename() == rhs.filename(); - } -}; - Dataloader::path_vector_t Dataloader::lookup_files_in_dir(std::string_view path, fs::path const& extension) const { - return _lookup_files_in_dir<fs::directory_iterator, EquivFilename>(path, extension); + return _lookup_files_in_dir<fs::directory_iterator>(path, extension, std::identity {}); } Dataloader::path_vector_t Dataloader::lookup_files_in_dir_recursive(std::string_view path, fs::path const& extension) const { - return _lookup_files_in_dir<fs::recursive_directory_iterator, EquivFilename>(path, extension); + return _lookup_files_in_dir<fs::recursive_directory_iterator>(path, extension, std::identity {}); } -struct EquivBasicIdentifierPrefix { - bool operator()(fs::path const& lhs, fs::path const& rhs) const { - const std::string lhs_str = lhs.stem().string(); - const std::string rhs_str = rhs.stem().string(); - return extract_basic_identifier_prefix(lhs_str) == extract_basic_identifier_prefix(rhs_str); - } +static std::string_view _extract_basic_identifier_prefix_from_path(std::string_view path) { + return extract_basic_identifier_prefix(StringUtils::get_filename(path)); }; Dataloader::path_vector_t Dataloader::lookup_basic_indentifier_prefixed_files_in_dir( std::string_view path, fs::path const& extension ) const { - return _lookup_files_in_dir<fs::directory_iterator, EquivBasicIdentifierPrefix>(path, extension); + return _lookup_files_in_dir<fs::directory_iterator>(path, extension, _extract_basic_identifier_prefix_from_path); } Dataloader::path_vector_t Dataloader::lookup_basic_indentifier_prefixed_files_in_dir_recursive( std::string_view path, fs::path const& extension ) const { - return _lookup_files_in_dir<fs::recursive_directory_iterator, EquivBasicIdentifierPrefix>(path, extension); + return _lookup_files_in_dir<fs::recursive_directory_iterator>(path, extension, _extract_basic_identifier_prefix_from_path); } bool Dataloader::apply_to_files(path_vector_t const& files, callback_t<fs::path const&> callback) const { @@ -555,6 +578,36 @@ csv::Windows1252Parser Dataloader::parse_csv(fs::path const& path) { return _run_ovdl_parser<csv::Windows1252Parser, &_csv_parse>(path); } +bool Dataloader::_load_interface_files(UIManager& ui_manager) const { + static constexpr std::string_view interface_directory = "interface/"; + + bool ret = apply_to_files( + lookup_files_in_dir(interface_directory, ".gfx"), + [&ui_manager](fs::path const& file) -> bool { + return ui_manager.load_gfx_file(parse_defines(file).get_file_node()); + } + ); + ui_manager.lock_sprites(); + ui_manager.lock_fonts(); + + // Hard-coded example until the mechanism for requesting them from GDScript is fleshed out + static const std::vector<std::string_view> gui_files { + "province_interface.gui", "topbar.gui" + }; + for (std::string_view const& gui_file : gui_files) { + if (!ui_manager.load_gui_file( + gui_file, + parse_defines(lookup_file(append_string_views(interface_directory, gui_file))).get_file_node() + )) { + Logger::error("Failed to load interface gui file: ", gui_file); + ret = false; + } + } + ui_manager.lock_scenes(); + + return ret; +} + bool Dataloader::_load_pop_types( PopManager& pop_manager, UnitManager const& unit_manager, GoodManager const& good_manager ) const { @@ -798,6 +851,10 @@ bool Dataloader::load_defines(GameManager& game_manager) const { bool ret = true; + if (!_load_interface_files(game_manager.get_ui_manager())) { + Logger::error("Failed to load interface files!"); + ret = false; + } if (!game_manager.get_modifier_manager().setup_modifier_effects()) { Logger::error("Failed to set up modifier effects!"); ret = false; @@ -889,7 +946,9 @@ bool Dataloader::load_defines(GameManager& game_manager) const { Logger::error("Failed to load leader traits!"); ret = false; } - if (!game_manager.get_military_manager().get_wargoal_manager().load_wargoal_file(parse_defines(lookup_file(cb_types_file)).get_file_node())) { + if (!game_manager.get_military_manager().get_wargoal_manager().load_wargoal_file( + parse_defines(lookup_file(cb_types_file)).get_file_node() + )) { Logger::error("Failed to load wargoals!"); ret = false; } diff --git a/src/openvic-simulation/dataloader/Dataloader.hpp b/src/openvic-simulation/dataloader/Dataloader.hpp index 2123469..5039582 100644 --- a/src/openvic-simulation/dataloader/Dataloader.hpp +++ b/src/openvic-simulation/dataloader/Dataloader.hpp @@ -12,6 +12,7 @@ namespace OpenVic { namespace fs = std::filesystem; struct GameManager; + class UIManager; struct PopManager; struct UnitManager; struct GoodManager; @@ -23,16 +24,22 @@ namespace OpenVic { private: path_vector_t roots; + bool _load_interface_files(UIManager& ui_manager) const; bool _load_pop_types(PopManager& pop_manager, UnitManager const& unit_manager, GoodManager const& good_manager) const; bool _load_units(UnitManager& unit_manager, GoodManager const& good_manager) const; bool _load_map_dir(GameManager& game_manager) const; bool _load_history(GameManager& game_manager, bool unused_history_file_warnings) const; - /* _DirIterator is fs::directory_iterator or fs::recursive_directory_iterator. - * _Equiv is an equivalence relation with respect to which every found file shall be unique. - * If a file is equivalent to the empty path then it is not included. */ - template<typename _DirIterator, std::predicate<fs::path const&, fs::path const&> _Equiv> - path_vector_t _lookup_files_in_dir(std::string_view path, fs::path const& extension) const; + /* _DirIterator is fs::directory_iterator or fs::recursive_directory_iterator. _UniqueKey is the type of a callable + * which converts a string_view filepath with root removed into a string_view unique key. Any path whose key is empty + * or matches an earlier found path's key is discarded, ensuring each looked up path's key is non-empty and unique. */ + template<typename _DirIterator, typename _UniqueKey> + requires requires (_UniqueKey const& unique_key, std::string_view path) { + { unique_key(path) } -> std::convertible_to<std::string_view>; + } + path_vector_t _lookup_files_in_dir( + std::string_view path, fs::path const& extension, _UniqueKey const& unique_key + ) const; public: static ovdl::v2script::Parser parse_defines(fs::path const& path); @@ -70,6 +77,8 @@ namespace OpenVic { * DAT-24 */ fs::path lookup_file(std::string_view path, bool print_error = true) const; + /* Checks alternate file endings, e.g. if "*.tga" doesn't exist then try "*.dds" */ + fs::path lookup_image_file_or_dds(std::string_view path) const; path_vector_t lookup_files_in_dir(std::string_view path, fs::path const& extension) const; path_vector_t lookup_files_in_dir_recursive(std::string_view path, fs::path const& extension) const; path_vector_t lookup_basic_indentifier_prefixed_files_in_dir(std::string_view path, fs::path const& extension) const; diff --git a/src/openvic-simulation/dataloader/NodeTools.cpp b/src/openvic-simulation/dataloader/NodeTools.cpp index 27d0f95..c412f33 100644 --- a/src/openvic-simulation/dataloader/NodeTools.cpp +++ b/src/openvic-simulation/dataloader/NodeTools.cpp @@ -76,10 +76,10 @@ node_callback_t NodeTools::expect_int_bool(callback_t<bool> callback) { return expect_identifier(expect_mapped_string(bool_map, callback)); } -node_callback_t NodeTools::expect_int64(callback_t<int64_t> callback) { - return expect_identifier([callback](std::string_view identifier) -> bool { +node_callback_t NodeTools::expect_int64(callback_t<int64_t> callback, int base) { + return expect_identifier([callback, base](std::string_view identifier) -> bool { bool successful = false; - const int64_t val = StringUtils::string_to_int64(identifier, &successful, 10); + const int64_t val = StringUtils::string_to_int64(identifier, &successful, base); if (successful) { return callback(val); } @@ -88,10 +88,10 @@ node_callback_t NodeTools::expect_int64(callback_t<int64_t> callback) { }); } -node_callback_t NodeTools::expect_uint64(callback_t<uint64_t> callback) { - return expect_identifier([callback](std::string_view identifier) -> bool { +node_callback_t NodeTools::expect_uint64(callback_t<uint64_t> callback, int base) { + return expect_identifier([callback, base](std::string_view identifier) -> bool { bool successful = false; - const uint64_t val = StringUtils::string_to_uint64(identifier, &successful, 10); + const uint64_t val = StringUtils::string_to_uint64(identifier, &successful, base); if (successful) { return callback(val); } @@ -141,6 +141,10 @@ node_callback_t NodeTools::expect_colour(callback_t<colour_t> callback) { }; } +node_callback_t NodeTools::expect_colour_hex(callback_t<colour_t> callback) { + return expect_uint(callback, 16); +} + callback_t<std::string_view> NodeTools::expect_date_str(callback_t<Date> callback) { return [callback](std::string_view identifier) -> bool { bool successful = false; @@ -188,8 +192,12 @@ NodeCallback auto _expect_vec2(Callback<vec2_t<T>> auto callback) { }; } +static node_callback_t _expect_int(callback_t<ivec2_t::type> callback) { + return expect_int(callback); +} + node_callback_t NodeTools::expect_ivec2(callback_t<ivec2_t> callback) { - return _expect_vec2<int32_t, expect_int>(callback); + return _expect_vec2<ivec2_t::type, _expect_int>(callback); } node_callback_t NodeTools::expect_fvec2(callback_t<fvec2_t> callback) { diff --git a/src/openvic-simulation/dataloader/NodeTools.hpp b/src/openvic-simulation/dataloader/NodeTools.hpp index a23fb4f..1ca6cf0 100644 --- a/src/openvic-simulation/dataloader/NodeTools.hpp +++ b/src/openvic-simulation/dataloader/NodeTools.hpp @@ -73,11 +73,11 @@ namespace OpenVic { node_callback_t expect_bool(callback_t<bool> callback); node_callback_t expect_int_bool(callback_t<bool> callback); - node_callback_t expect_int64(callback_t<int64_t> callback); - node_callback_t expect_uint64(callback_t<uint64_t> callback); + node_callback_t expect_int64(callback_t<int64_t> callback, int base = 10); + node_callback_t expect_uint64(callback_t<uint64_t> callback, int base = 10); template<std::signed_integral T> - NodeCallback auto expect_int(callback_t<T> callback) { + NodeCallback auto expect_int(callback_t<T> callback, int base = 10) { return expect_int64([callback](int64_t val) -> bool { if (static_cast<int64_t>(std::numeric_limits<T>::lowest()) <= val && val <= static_cast<int64_t>(std::numeric_limits<T>::max())) { @@ -88,11 +88,11 @@ namespace OpenVic { static_cast<int64_t>(std::numeric_limits<T>::max()), "])" ); return false; - }); + }, base); } template<std::integral T> - NodeCallback auto expect_uint(callback_t<T> callback) { + NodeCallback auto expect_uint(callback_t<T> callback, int base = 10) { return expect_uint64([callback](uint64_t val) -> bool { if (val <= static_cast<uint64_t>(std::numeric_limits<T>::max())) { return callback(val); @@ -101,12 +101,13 @@ namespace OpenVic { "Invalid uint: ", val, " (valid range: [0, ", static_cast<uint64_t>(std::numeric_limits<T>::max()), "])" ); return false; - }); + }, base); } callback_t<std::string_view> expect_fixed_point_str(callback_t<fixed_point_t> callback); node_callback_t expect_fixed_point(callback_t<fixed_point_t> callback); node_callback_t expect_colour(callback_t<colour_t> callback); + node_callback_t expect_colour_hex(callback_t<colour_t> callback); callback_t<std::string_view> expect_date_str(callback_t<Date> callback); node_callback_t expect_date(callback_t<Date> callback); diff --git a/src/openvic-simulation/history/DiplomaticHistory.cpp b/src/openvic-simulation/history/DiplomaticHistory.cpp index 6f9d73e..5cbafe7 100644 --- a/src/openvic-simulation/history/DiplomaticHistory.cpp +++ b/src/openvic-simulation/history/DiplomaticHistory.cpp @@ -164,7 +164,7 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(GameManager& game_man "start_date", ONE_EXACTLY, expect_identifier_or_string(expect_date_str(assign_variable_callback(start))), "end_date", ONE_EXACTLY, expect_identifier_or_string(expect_date_str(assign_variable_callback(end))) )(node); - + alliances.push_back({ first, second, start, end }); return ret; }, diff --git a/src/openvic-simulation/history/DiplomaticHistory.hpp b/src/openvic-simulation/history/DiplomaticHistory.hpp index 85e2654..64529c2 100644 --- a/src/openvic-simulation/history/DiplomaticHistory.hpp +++ b/src/openvic-simulation/history/DiplomaticHistory.hpp @@ -46,7 +46,7 @@ namespace OpenVic { std::optional<Date> exited; war_participant_t(Country const* new_country, Date new_joined, std::optional<Date> new_exited); - + public: Country const* get_country() const; Date get_date_joined() const; @@ -105,7 +105,7 @@ namespace OpenVic { public: Country const* get_overlord() const; Country const* get_subject() const; - const type_t get_subject_type() const; + const type_t get_subject_type() const; }; struct DiplomaticHistoryManager { diff --git a/src/openvic-simulation/interface/GFX.cpp b/src/openvic-simulation/interface/GFX.cpp new file mode 100644 index 0000000..f4e2074 --- /dev/null +++ b/src/openvic-simulation/interface/GFX.cpp @@ -0,0 +1,99 @@ +#include "GFX.hpp" + +using namespace OpenVic; +using namespace OpenVic::GFX; +using namespace OpenVic::NodeTools; + +Font::Font(std::string_view new_identifier, colour_t new_colour, std::string_view new_fontname) + : HasIdentifierAndColour { new_identifier, new_colour, false, true }, fontname { new_fontname } {} + +node_callback_t Sprite::expect_sprite(callback_t<std::unique_ptr<Sprite>&&> callback) { + return expect_dictionary_keys( + "spriteType", ZERO_OR_MORE, _expect_instance<Sprite, TextureSprite>(callback), + "progressbartype", ZERO_OR_MORE, _expect_instance<Sprite, ProgressBar>(callback), + "PieChartType", ZERO_OR_MORE, _expect_instance<Sprite, PieChart>(callback), + "LineChartType", ZERO_OR_MORE, _expect_instance<Sprite, LineChart>(callback), + "textSpriteType", ZERO_OR_MORE, _expect_instance<Sprite, TextureSprite>(callback), + "maskedShieldType", ZERO_OR_MORE, _expect_instance<Sprite, MaskedFlag>(callback), + // TODO - add the rest of the sprite types + "corneredTileSpriteType", ZERO_OR_MORE, success_callback, + "tileSpriteType", ZERO_OR_MORE, success_callback, + "BarChartType", ZERO_OR_MORE, success_callback, + "scrollingSprite", ZERO_OR_MORE, success_callback + ); +} + +TextureSprite::TextureSprite() : texture_file {}, no_of_frames { NO_FRAMES } {} + +bool TextureSprite::_fill_key_map(key_map_t& key_map) { + bool ret = Sprite::_fill_key_map(key_map); + ret &= add_key_map_entries(key_map, + "texturefile", ZERO_OR_ONE, expect_string(assign_variable_callback_string(texture_file)), + "textureFile", ZERO_OR_ONE, expect_string(assign_variable_callback_string(texture_file)), + "noOfFrames", ZERO_OR_ONE, expect_uint(assign_variable_callback(no_of_frames)), + + "norefcount", ZERO_OR_ONE, success_callback, + "effectFile", ZERO_OR_ONE, success_callback, + "allwaystransparent", ZERO_OR_ONE, success_callback, + "transparencecheck", ZERO_OR_ONE, success_callback, + "loadType", ZERO_OR_ONE, success_callback, + "clicksound", ZERO_OR_ONE, success_callback + ); + return ret; +} + +ProgressBar::ProgressBar() +: back_colour {}, back_texture_file {}, + progress_colour {}, progress_texture_file {}, + size {} {} + +bool ProgressBar::_fill_key_map(key_map_t& key_map) { + bool ret = Sprite::_fill_key_map(key_map); + ret &= add_key_map_entries(key_map, + "color", ONE_EXACTLY, expect_colour(assign_variable_callback(back_colour)), + "colortwo", ONE_EXACTLY, expect_colour(assign_variable_callback(progress_colour)), + "textureFile1", ZERO_OR_ONE, expect_string(assign_variable_callback_string(back_texture_file)), + "textureFile2", ZERO_OR_ONE, expect_string(assign_variable_callback_string(progress_texture_file)), + "size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)), + + "effectFile", ONE_EXACTLY, success_callback, + "allwaystransparent", ZERO_OR_ONE, success_callback, + "loadType", ZERO_OR_ONE, success_callback, + "horizontal", ZERO_OR_ONE, success_callback + ); + return ret; +} + +PieChart::PieChart() : size {} {} + +bool PieChart::_fill_key_map(key_map_t& key_map) { + bool ret = Sprite::_fill_key_map(key_map); + ret &= add_key_map_entries(key_map, "size", ONE_EXACTLY, expect_uint(assign_variable_callback(size))); + return ret; +} + +LineChart::LineChart() : size {}, linewidth {} {} + +bool LineChart::_fill_key_map(key_map_t& key_map) { + bool ret = Sprite::_fill_key_map(key_map); + ret &= add_key_map_entries(key_map, + "size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)), + "linewidth", ONE_EXACTLY, expect_uint(assign_variable_callback(linewidth)), + "allwaystransparent", ZERO_OR_ONE, success_callback + ); + return ret; +} + +MaskedFlag::MaskedFlag() : texture_file {}, mask_file {} {} + +bool MaskedFlag::_fill_key_map(key_map_t& key_map) { + bool ret = Sprite::_fill_key_map(key_map); + ret &= add_key_map_entries(key_map, + "textureFile1", ONE_EXACTLY, expect_string(assign_variable_callback_string(texture_file)), + "textureFile2", ONE_EXACTLY, expect_string(assign_variable_callback_string(mask_file)), + "effectFile", ONE_EXACTLY, success_callback, + "allwaystransparent", ZERO_OR_ONE, success_callback, + "flipv", ZERO_OR_ONE, success_callback + ); + return ret; +} diff --git a/src/openvic-simulation/interface/GFX.hpp b/src/openvic-simulation/interface/GFX.hpp new file mode 100644 index 0000000..2422e24 --- /dev/null +++ b/src/openvic-simulation/interface/GFX.hpp @@ -0,0 +1,138 @@ +#pragma once + +#include "openvic-simulation/interface/LoadBase.hpp" + +namespace OpenVic { + class UIManager; +} + +namespace OpenVic::GFX { + + struct Font : HasIdentifierAndColour { + friend class OpenVic::UIManager; + + private: + const std::string PROPERTY(fontname); + + // TODO - colorcodes, effect + + Font(std::string_view new_identifier, colour_t new_colour, std::string_view new_fontname); + + public: + Font(Font&&) = default; + }; + + using frame_t = int32_t; /* Keep this as int32_t to simplify interfacing with Godot */ + static constexpr frame_t NO_FRAMES = 0; + + class Sprite : public Named<> { + protected: + Sprite() = default; + + public: + Sprite(Sprite&&) = default; + virtual ~Sprite() = default; + + OV_DETAIL_GET_BASE_TYPE(Sprite) + OV_DETAIL_GET_TYPE + + static NodeTools::node_callback_t expect_sprite(NodeTools::callback_t<std::unique_ptr<Sprite>&&> callback); + }; + + class TextureSprite final : public Sprite { + friend std::unique_ptr<TextureSprite> std::make_unique<TextureSprite>(); + + std::string PROPERTY(texture_file); + frame_t PROPERTY(no_of_frames); + + // TODO - norefcount, effectFile, allwaystransparent + + protected: + TextureSprite(); + + bool _fill_key_map(NodeTools::key_map_t& key_map) override; + + public: + TextureSprite(TextureSprite&&) = default; + virtual ~TextureSprite() = default; + + OV_DETAIL_GET_TYPE + }; + + class ProgressBar final : public Sprite { + friend std::unique_ptr<ProgressBar> std::make_unique<ProgressBar>(); + + colour_t PROPERTY(back_colour); + std::string PROPERTY(back_texture_file); + colour_t PROPERTY(progress_colour); + std::string PROPERTY(progress_texture_file); + ivec2_t PROPERTY(size); + + // TODO - effectFile + + protected: + ProgressBar(); + + bool _fill_key_map(NodeTools::key_map_t& key_map) override; + + public: + ProgressBar(ProgressBar&&) = default; + virtual ~ProgressBar() = default; + + OV_DETAIL_GET_TYPE + }; + + class PieChart final : public Sprite { + friend std::unique_ptr<PieChart> std::make_unique<PieChart>(); + + uint32_t PROPERTY(size); + + protected: + PieChart(); + + bool _fill_key_map(NodeTools::key_map_t& key_map) override; + + public: + PieChart(PieChart&&) = default; + virtual ~PieChart() = default; + + OV_DETAIL_GET_TYPE + }; + + class LineChart final : public Sprite { + friend std::unique_ptr<LineChart> std::make_unique<LineChart>(); + + ivec2_t PROPERTY(size); + uint32_t PROPERTY(linewidth); + + protected: + LineChart(); + + bool _fill_key_map(NodeTools::key_map_t& key_map) override; + + public: + LineChart(LineChart&&) = default; + virtual ~LineChart() = default; + + OV_DETAIL_GET_TYPE + }; + + + class MaskedFlag final : public Sprite { + friend std::unique_ptr<MaskedFlag> std::make_unique<MaskedFlag>(); + + std::string PROPERTY(texture_file) + std::string PROPERTY(mask_file); + + protected: + MaskedFlag(); + + bool _fill_key_map(NodeTools::key_map_t& key_map) override; + + public: + MaskedFlag(MaskedFlag&&) = default; + virtual ~MaskedFlag() = default; + + OV_DETAIL_GET_TYPE + }; +} diff --git a/src/openvic-simulation/interface/GUI.cpp b/src/openvic-simulation/interface/GUI.cpp new file mode 100644 index 0000000..aeec136 --- /dev/null +++ b/src/openvic-simulation/interface/GUI.cpp @@ -0,0 +1,182 @@ +#include "GUI.hpp" + +#include "openvic-simulation/interface/UI.hpp" + +using namespace OpenVic; +using namespace OpenVic::GUI; +using namespace OpenVic::NodeTools; + +Element::Element() : position {}, orientation { orientation_t::UPPER_LEFT } {} + +bool Element::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = Named::_fill_key_map(key_map, ui_manager); + using enum orientation_t; + static const string_map_t<orientation_t> orientation_map = { + { "UPPER_LEFT", UPPER_LEFT }, { "LOWER_LEFT", LOWER_LEFT }, + { "LOWER_RIGHT", LOWER_RIGHT }, { "UPPER_RIGHT", UPPER_RIGHT }, + { "CENTER", CENTER } + }; + ret &= add_key_map_entries(key_map, + "position", ONE_EXACTLY, expect_ivec2(assign_variable_callback(position)), + "orientation", ZERO_OR_ONE, expect_string(expect_mapped_string(orientation_map, assign_variable_callback(orientation))), + "Orientation", ZERO_OR_ONE, expect_string(expect_mapped_string(orientation_map, assign_variable_callback(orientation))) + ); + return ret; +} + +bool Element::_fill_elements_key_map( + NodeTools::key_map_t& key_map, callback_t<std::unique_ptr<Element>&&> callback, UIManager const& ui_manager +) { + bool ret = true; + ret &= add_key_map_entries(key_map, + "iconType", ZERO_OR_MORE, _expect_instance<Element, Icon>(callback, ui_manager), + "guiButtonType", ZERO_OR_MORE, _expect_instance<Element, Button>(callback, ui_manager), + "checkboxType", ZERO_OR_MORE, _expect_instance<Element, Checkbox>(callback, ui_manager), + "textBoxType", ZERO_OR_MORE, _expect_instance<Element, Text>(callback, ui_manager), + "instantTextBoxType", ZERO_OR_MORE, _expect_instance<Element, Text>(callback, ui_manager), + "OverlappingElementsBoxType", ZERO_OR_MORE, _expect_instance<Element, OverlappingElementsBox>(callback, ui_manager), + "listboxType", ZERO_OR_MORE, _expect_instance<Element, ListBox>(callback, ui_manager), + "windowType", ZERO_OR_MORE, _expect_instance<Element, Window>(callback, ui_manager), + "positionType", ZERO_OR_MORE, success_callback // TODO - load this as a marker for placing sub-scenes + ); + return ret; +} + +Scene::Scene() : elements { "scene elements" } {} + +bool Scene::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + return Element::_fill_elements_key_map(key_map, [this](std::unique_ptr<Element>&& element) -> bool { + return elements.add_item(std::move(element)); + }, ui_manager); +} + +node_callback_t Scene::expect_scene( + std::string_view scene_name, callback_t<std::unique_ptr<Scene>&&> callback, UIManager const& ui_manager +) { + return _expect_instance<Scene, Scene>([scene_name, callback](std::unique_ptr<Scene>&& scene) -> bool { + scene->_set_name(scene_name); + return callback(std::move(scene)); + }, ui_manager); +} + +Window::Window() : elements { "window elements" }, size {}, moveable { false }, fullscreen { false } {} + +bool Window::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = Element::_fill_elements_key_map(key_map, [this](std::unique_ptr<Element>&& element) -> bool { + return elements.add_item(std::move(element)); + }, ui_manager); + ret &= Element::_fill_key_map(key_map, ui_manager); + ret &= add_key_map_entries(key_map, + "backGround", ZERO_OR_ONE, success_callback, // TODO - load as potential panel texture (almost always empty) + "size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)), + "moveable", ONE_EXACTLY, expect_int_bool(assign_variable_callback(moveable)), + "dontRender", ZERO_OR_ONE, success_callback, // always empty string? + "horizontalBorder", ZERO_OR_ONE, success_callback, + "verticalBorder", ZERO_OR_ONE, success_callback, + "fullScreen", ZERO_OR_ONE, expect_bool(assign_variable_callback(fullscreen)) + ); + return ret; +} + +Icon::Icon() : sprite { nullptr }, frame { GFX::NO_FRAMES } {} + +bool Icon::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = Element::_fill_key_map(key_map, ui_manager); + ret &= add_key_map_entries(key_map, + "spriteType", ONE_EXACTLY, expect_string(ui_manager.expect_sprite_str(assign_variable_callback_pointer(sprite))), + "frame", ZERO_OR_ONE, expect_uint(assign_variable_callback(frame)) + ); + return ret; +} + +BaseButton::BaseButton() : sprite { nullptr } {} + +bool BaseButton::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = Element::_fill_key_map(key_map, ui_manager); + // look up sprite registry for texture sprite with name... + ret &= add_key_map_entries(key_map, + "quadTextureSprite", ONE_EXACTLY, + expect_string(ui_manager.expect_sprite_str(assign_variable_callback_pointer(sprite)), true), + "shortcut", ZERO_OR_ONE, success_callback // TODO - load and use shortcuts (how to integrate with custom keybinds?) + ); + return ret; +} + +Button::Button() : text {}, font { nullptr} {} + +bool Button::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = BaseButton::_fill_key_map(key_map, ui_manager); + ret &= add_key_map_entries(key_map, + "buttonText", ZERO_OR_ONE, expect_string(assign_variable_callback_string(text), true), + "buttonFont", ZERO_OR_ONE, expect_string(ui_manager.expect_font_str(assign_variable_callback_pointer(font))), + "clicksound", ZERO_OR_ONE, success_callback, + /* These are always empty in the base defines */ + "tooltip", ZERO_OR_ONE, success_callback, + "tooltipText", ZERO_OR_ONE, success_callback, + "delayedTooltipText", ZERO_OR_ONE, success_callback + ); + return ret; +} + +bool Checkbox::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = BaseButton::_fill_key_map(key_map, ui_manager); + return ret; +} + +AlignedElement::AlignedElement() : format { format_t::left } {} + +bool AlignedElement::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = Element::_fill_key_map(key_map, ui_manager); + using enum format_t; + static const string_map_t<format_t> format_map = { + { "left", left }, { "right", right }, { "centre", centre }, { "center", centre } + }; + ret &= add_key_map_entries(key_map, + "format", ZERO_OR_ONE, expect_identifier(expect_mapped_string(format_map, assign_variable_callback(format)) + )); + return ret; +} + +Text::Text() : text {}, font { nullptr } {} + +bool Text::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = AlignedElement::_fill_key_map(key_map, ui_manager); + ret &= add_key_map_entries(key_map, + "text", ZERO_OR_ONE, expect_string(assign_variable_callback_string(text), true), + "font", ONE_EXACTLY, expect_string(ui_manager.expect_font_str(assign_variable_callback_pointer(font))), + "maxWidth", ONE_EXACTLY, expect_uint(assign_variable_callback(max_size.x)), + "maxHeight", ONE_EXACTLY, expect_uint(assign_variable_callback(max_size.y)), + + "borderSize", ZERO_OR_ONE, success_callback, + "fixedsize", ZERO_OR_ONE, success_callback, + + // Add warning about redundant key? + "textureFile", ZERO_OR_ONE, success_callback + ); + return ret; +} + +OverlappingElementsBox::OverlappingElementsBox() : size {} {} + +bool OverlappingElementsBox::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = AlignedElement::_fill_key_map(key_map, ui_manager); + ret &= add_key_map_entries(key_map, + "size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)), + "spacing", ONE_EXACTLY, success_callback + ); + return ret; +} + +ListBox::ListBox() : size {} {} + +bool ListBox::_fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) { + bool ret = Element::_fill_key_map(key_map, ui_manager); + ret &= add_key_map_entries(key_map, + "backGround", ZERO_OR_ONE, success_callback, + "size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)), + "spacing", ZERO_OR_ONE, success_callback, + "scrollbartype", ZERO_OR_ONE, success_callback, // TODO - implement modable listbox scrollbars + "borderSize", ZERO_OR_ONE, success_callback + ); + return ret; +} diff --git a/src/openvic-simulation/interface/GUI.hpp b/src/openvic-simulation/interface/GUI.hpp new file mode 100644 index 0000000..1a76ca0 --- /dev/null +++ b/src/openvic-simulation/interface/GUI.hpp @@ -0,0 +1,235 @@ +#pragma once + +#include "openvic-simulation/interface/GFX.hpp" + +namespace OpenVic { + class UIManager; +} +namespace OpenVic::GUI { + class Scene; + + class Element : public Named<UIManager const&> { + friend class Scene; + + public: + enum class orientation_t { + UPPER_LEFT, LOWER_LEFT, LOWER_RIGHT, UPPER_RIGHT, CENTER + }; + + private: + ivec2_t PROPERTY(position); + orientation_t PROPERTY(orientation); + + protected: + Element(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + static bool _fill_elements_key_map( + NodeTools::key_map_t& key_map, NodeTools::callback_t<std::unique_ptr<Element>&&> callback, + UIManager const& ui_manager + ); + + public: + Element(Element&&) = default; + virtual ~Element() = default; + + OV_DETAIL_GET_BASE_TYPE(Element) + OV_DETAIL_GET_TYPE + }; + + class Scene : public Named<UIManager const&> { + friend std::unique_ptr<Scene> std::make_unique<Scene>(); + + NamedInstanceRegistry<Element, UIManager const&> elements; + + protected: + Scene(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + Scene(Scene&&) = default; + virtual ~Scene() = default; + + OV_DETAIL_GET_TYPE + + static NodeTools::node_callback_t expect_scene( + std::string_view scene_name, NodeTools::callback_t<std::unique_ptr<Scene>&&> callback, UIManager const& ui_manager + ); + + IDENTIFIER_REGISTRY_ACCESSORS(element) + }; + + class Window final : public Element { + friend std::unique_ptr<Window> std::make_unique<Window>(); + + NamedInstanceRegistry<Element, UIManager const&> elements; + + ivec2_t PROPERTY(size); + bool PROPERTY(moveable); + bool PROPERTY(fullscreen); + // TODO - background, dontRender, horizontalBorder, verticalBorder + + protected: + Window(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + Window(Window&&) = default; + virtual ~Window() = default; + + OV_DETAIL_GET_TYPE + + IDENTIFIER_REGISTRY_ACCESSORS(element) + }; + + class Icon final : public Element { + friend std::unique_ptr<Icon> std::make_unique<Icon>(); + + GFX::Sprite const* PROPERTY(sprite); + GFX::frame_t PROPERTY(frame); + + protected: + Icon(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + Icon(Icon&&) = default; + virtual ~Icon() = default; + + OV_DETAIL_GET_TYPE + }; + + class BaseButton : public Element { + GFX::Sprite const* PROPERTY(sprite); + // TODO - shortcut + + protected: + BaseButton(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + BaseButton(BaseButton&&) = default; + virtual ~BaseButton() = default; + + OV_DETAIL_GET_TYPE + }; + + class Button final : public BaseButton { + friend std::unique_ptr<Button> std::make_unique<Button>(); + + std::string PROPERTY(text); + GFX::Font const* PROPERTY(font); + + // TODO - clicksound + + protected: + Button() ; + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + Button(Button&&) = default; + virtual ~Button() = default; + + OV_DETAIL_GET_TYPE + }; + + class Checkbox final : public BaseButton { + friend std::unique_ptr<Checkbox> std::make_unique<Checkbox>(); + + protected: + Checkbox() = default; + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + Checkbox(Checkbox&&) = default; + virtual ~Checkbox() = default; + + OV_DETAIL_GET_TYPE + }; + + class AlignedElement : public Element { + public: + enum class format_t { + left, centre, right + }; + + private: + format_t PROPERTY(format); + + protected: + AlignedElement(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + AlignedElement(AlignedElement&&) = default; + virtual ~AlignedElement() = default; + + OV_DETAIL_GET_TYPE + }; + + class Text final : public AlignedElement { + friend std::unique_ptr<Text> std::make_unique<Text>(); + + std::string PROPERTY(text); + GFX::Font const* PROPERTY(font); + ivec2_t PROPERTY(max_size); // maxWidth, maxHeight + + // TODO - borderSize, fixedsize, textureFile + + protected: + Text(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + Text(Text&&) = default; + virtual ~Text() = default; + + OV_DETAIL_GET_TYPE + }; + + class OverlappingElementsBox final : public AlignedElement { + friend std::unique_ptr<OverlappingElementsBox> std::make_unique<OverlappingElementsBox>(); + + ivec2_t PROPERTY(size); + + // TODO - spacing + + protected: + OverlappingElementsBox(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + OverlappingElementsBox(OverlappingElementsBox&&) = default; + virtual ~OverlappingElementsBox() = default; + + OV_DETAIL_GET_TYPE + }; + + class ListBox final : public Element { + friend std::unique_ptr<ListBox> std::make_unique<ListBox>(); + + ivec2_t PROPERTY(size); + + // TODO - backGround, spacing, scrollbartype, borderSize + + protected: + ListBox(); + + bool _fill_key_map(NodeTools::key_map_t& key_map, UIManager const& ui_manager) override; + + public: + ListBox(ListBox&&) = default; + virtual ~ListBox() = default; + + OV_DETAIL_GET_TYPE + }; +} diff --git a/src/openvic-simulation/interface/LoadBase.hpp b/src/openvic-simulation/interface/LoadBase.hpp new file mode 100644 index 0000000..3ee7c83 --- /dev/null +++ b/src/openvic-simulation/interface/LoadBase.hpp @@ -0,0 +1,82 @@ +#pragma once + +#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/utility/Getters.hpp" + +namespace OpenVic { + + template<typename... _Context> + class LoadBase { + protected: + LoadBase() = default; + + virtual bool _fill_key_map(NodeTools::key_map_t&, _Context...) = 0; + + public: + LoadBase(LoadBase&&) = default; + virtual ~LoadBase() = default; + + bool load(ast::NodeCPtr node, _Context... context) { + NodeTools::key_map_t key_map; + bool ret = _fill_key_map(key_map, context...); + ret &= NodeTools::expect_dictionary_key_map(std::move(key_map))(node); + return ret; + } + + template<std::derived_from<LoadBase<_Context...>> T, std::derived_from<T> U> + static NodeTools::node_callback_t _expect_instance( + NodeTools::callback_t<std::unique_ptr<T>&&> callback, _Context... context + ) { + return [callback, &context...](ast::NodeCPtr node) -> bool { + std::unique_ptr<T> instance { std::make_unique<U>() }; + bool ret = instance->load(node, context...); + ret &= callback(std::move(instance)); + return ret; + }; + } + + OV_DETAIL_GET_TYPE_BASE_CLASS(LoadBase) + }; + + template<typename... _Context> + class Named : public LoadBase<_Context...> { + std::string PROPERTY(name); + + protected: + Named() = default; + + virtual bool _fill_key_map(NodeTools::key_map_t& key_map, _Context...) override { + using namespace OpenVic::NodeTools; + return add_key_map_entries(key_map, "name", ONE_EXACTLY, expect_string(assign_variable_callback_string(name))); + } + + void _set_name(std::string_view new_name) { + if (!name.empty()) { + Logger::warning("Overriding scene name ", name, " with ", new_name); + } + name = new_name; + } + + public: + Named(Named&&) = default; + virtual ~Named() = default; + + OV_DETAIL_GET_TYPE + }; + + template<typename T, typename... _Context> + requires std::derived_from<T, Named<_Context...>> + struct _get_name { + constexpr std::string_view operator()(T const* item) const { + return item->get_name(); + } + }; + + template<typename T, typename... _Context> + requires std::derived_from<T, Named<_Context...>> + using NamedRegistry = ValueRegistry<T, _get_name<T, _Context...>>; + + template<typename T, typename... _Context> + requires std::derived_from<T, Named<_Context...>> + using NamedInstanceRegistry = InstanceRegistry<T, _get_name<T, _Context...>>; +} diff --git a/src/openvic-simulation/interface/UI.cpp b/src/openvic-simulation/interface/UI.cpp new file mode 100644 index 0000000..4653e5b --- /dev/null +++ b/src/openvic-simulation/interface/UI.cpp @@ -0,0 +1,92 @@ +#include "UI.hpp" + +using namespace OpenVic; +using namespace OpenVic::NodeTools; +using namespace OpenVic::GFX; +using namespace OpenVic::GUI; + +UIManager::UIManager() : sprites { "sprites" }, scenes { "scenes" }, fonts { "fonts" } {} + +bool UIManager::add_font(std::string_view identifier, colour_t colour, std::string_view fontname) { + if (identifier.empty()) { + Logger::error("Invalid font identifier - empty!"); + return false; + } + if (fontname.empty()) { + Logger::error("Invalid culture colour for ", identifier, ": ", colour_to_hex_string(colour)); + return false; + } + return fonts.add_item({ identifier, colour, fontname }, duplicate_warning_callback); +} + +bool UIManager::_load_font(ast::NodeCPtr node) { + std::string_view identifier, fontname; + colour_t colour = NULL_COLOUR; + bool ret = expect_dictionary_keys( + "name", ONE_EXACTLY, expect_string(assign_variable_callback(identifier)), + "fontname", ONE_EXACTLY, expect_string(assign_variable_callback(fontname)), + "color", ONE_EXACTLY, expect_colour_hex(assign_variable_callback(colour)), + "colorcodes", ZERO_OR_ONE, success_callback, + "effect", ZERO_OR_ONE, success_callback + )(node); + ret &= add_font(identifier, colour, fontname); + return ret; +} + +bool UIManager::load_gfx_file(ast::NodeCPtr root) { + return expect_dictionary_keys( + "spriteTypes", ZERO_OR_ONE, Sprite::expect_sprite( + [this](std::unique_ptr<Sprite>&& sprite) -> bool { + /* TODO - more checks on duplicates (the false here reduces them from + * errors to warnings). The repeats in vanilla are identical (simple + * texture sprites with the same name referring to the same asset), + * maybe check if duplicates are equal? (this would require some kind + * of duplicate handling callback for `add_item`) + * + * It's also possible that some of the vanilla duplicates are intentional, + * after all I'm assuming all GFX files are loaded into a global registry + * rather than each GUI file using only the contnts of a few specific, + * maybe even hardcoded GFX files. This can't, however, explain all of the + * vanilla duplicates, as GFX_frontend_tab_button is repeated in the same + * file, albeit in a section marked "OLD STUFF BELOW..". + * + * Vanilla Duplicates: + * - GFX_bp_open_manager and GFX_bp_toggle_visible + * - simple texture sprites appearing identically in menubar.gfx and battleplansinterface.gfx + * - GFX_frontend_tab_button + * - texture sprite appearing twice identically in the same file (temp_frontend.gfx), + * both below a comment saying "OLD STUFF BELOW.." + */ + return sprites.add_item(std::move(sprite), duplicate_warning_callback); + } + ), + "bitmapfonts", ZERO_OR_ONE, expect_dictionary( + [this](std::string_view key, ast::NodeCPtr node) -> bool { + if (key != "bitmapfont") { + Logger::error("Invalid bitmapfonts key: ", key); + return false; + } + return _load_font(node); + } + ), + "objectTypes", ZERO_OR_ONE, success_callback, + "lightTypes", ZERO_OR_ONE, success_callback, + "fonts", ZERO_OR_ONE, success_callback + )(root); +} + +bool UIManager::load_gui_file(std::string_view scene_name, ast::NodeCPtr root) { + if (!sprites_are_locked()) { + Logger::error("Cannot load GUI files until GFX files (i.e. Sprites) are locked!"); + return false; + } + return expect_dictionary_keys( + "guiTypes", ZERO_OR_ONE, Scene::expect_scene( + scene_name, + [this](std::unique_ptr<Scene>&& scene) -> bool { + return scenes.add_item(std::move(scene)); + }, + *this + ) + )(root); +} diff --git a/src/openvic-simulation/interface/UI.hpp b/src/openvic-simulation/interface/UI.hpp new file mode 100644 index 0000000..045766b --- /dev/null +++ b/src/openvic-simulation/interface/UI.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include "openvic-simulation/interface/GUI.hpp" + +namespace OpenVic { + + class UIManager { + + NamedInstanceRegistry<GFX::Sprite> sprites; + NamedInstanceRegistry<GUI::Scene, UIManager const&> scenes; + IdentifierRegistry<GFX::Font> fonts; + + bool _load_font(ast::NodeCPtr node); + + public: + UIManager(); + + IDENTIFIER_REGISTRY_ACCESSORS(sprite) + IDENTIFIER_REGISTRY_ACCESSORS(scene) + IDENTIFIER_REGISTRY_ACCESSORS(font) + + bool add_font(std::string_view identifier, colour_t colour, std::string_view fontname); + + bool load_gfx_file(ast::NodeCPtr root); + bool load_gui_file(std::string_view scene_name, ast::NodeCPtr root); + }; +} diff --git a/src/openvic-simulation/map/TerrainType.cpp b/src/openvic-simulation/map/TerrainType.cpp index 796089e..f138cb2 100644 --- a/src/openvic-simulation/map/TerrainType.cpp +++ b/src/openvic-simulation/map/TerrainType.cpp @@ -43,7 +43,9 @@ bool TerrainTypeMapping::get_has_texture() const { TerrainTypeManager::TerrainTypeManager() : terrain_types { "terrain types" }, terrain_type_mappings { "terrain type mappings" } {} -bool TerrainTypeManager::add_terrain_type(std::string_view identifier, colour_t colour, ModifierValue&& values, bool is_water) { +bool TerrainTypeManager::add_terrain_type( + std::string_view identifier, colour_t colour, ModifierValue&& values, bool is_water +) { if (identifier.empty()) { Logger::error("Invalid terrain type identifier - empty!"); return false; diff --git a/src/openvic-simulation/military/Wargoal.cpp b/src/openvic-simulation/military/Wargoal.cpp index 8bc4446..b493f22 100644 --- a/src/openvic-simulation/military/Wargoal.cpp +++ b/src/openvic-simulation/military/Wargoal.cpp @@ -33,54 +33,6 @@ WargoalType::WargoalType( modifiers { std::move(new_modifiers) }, peace_options { new_peace_options } {} -std::string_view WargoalType::get_sprite() const { - return sprite; -} - -std::string_view WargoalType::get_war_name() const { - return war_name; -} - -const Timespan WargoalType::get_available_length() const { - return available_length; -} - -const Timespan WargoalType::get_truce_length() const { - return truce_length; -} - -const bool WargoalType::is_triggered_only() const { - return triggered_only; -} - -const bool WargoalType::is_civil_war() const { - return civil_war; -} - -const bool WargoalType::is_constructing() const { - return constructing; -} - -const bool WargoalType::is_crisis() const { - return crisis; -} - -const bool WargoalType::is_great_war() const { - return great_war; -} - -const bool WargoalType::is_mutual() const { - return mutual; -} - -WargoalType::peace_modifiers_t const& WargoalType::get_modifiers() const { - return modifiers; -} - -const peace_options_t WargoalType::get_peace_options() const { - return peace_options; -} - WargoalTypeManager::WargoalTypeManager() : wargoal_types { "wargoal types" } {} const std::vector<WargoalType const*>& WargoalTypeManager::get_peace_priority_list() const { @@ -106,7 +58,7 @@ bool WargoalTypeManager::add_wargoal_type( Logger::error("Invalid wargoal identifier - empty!"); return false; } - + if (sprite.empty()) { Logger::error("Invalid sprite for wargoal ", identifier, " - empty!"); return false; @@ -117,72 +69,47 @@ bool WargoalTypeManager::add_wargoal_type( return false; } - return wargoal_types.add_item({ identifier, sprite, war_name, available_length, truce_length, triggered_only, civil_war, constructing, crisis, great_war, mutual, std::move(modifiers), peace_options }); + return wargoal_types.add_item({ + identifier, sprite, war_name, available_length, truce_length, triggered_only, civil_war, constructing, crisis, + great_war, mutual, std::move(modifiers), peace_options + }); } bool WargoalTypeManager::load_wargoal_file(ast::NodeCPtr root) { bool ret = expect_dictionary( [this](std::string_view identifier, ast::NodeCPtr value) -> bool { if (identifier == "peace_order") return true; - + std::string_view sprite, war_name; Timespan available, truce; - bool triggered_only = false, civil_war = false, constructing = false, crisis = false, great_war = false, mutual = false; - peace_options_t peace_options; + bool triggered_only = false, civil_war = false, constructing = true, crisis = true, great_war = false, + mutual = false; + peace_options_t peace_options {}; WargoalType::peace_modifiers_t modifiers; bool ret = expect_dictionary_keys_and_default( [&modifiers, &identifier](std::string_view key, ast::NodeCPtr value) -> bool { - fixed_point_t modifier; - expect_fixed_point(assign_variable_callback(modifier))(value); - - if (key == "badboy_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::BADBOY_FACTOR] += modifier; - return true; - } - if (key == "prestige_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::PRESTIGE_FACTOR] += modifier; - return true; - } - if (key == "peace_cost_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::PEACE_COST_FACTOR] += modifier; - return true; - } - if (key == "penalty_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::PENALTY_FACTOR] += modifier; - return true; - } - if (key == "break_truce_prestige_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::BREAK_TRUCE_PRESTIGE_FACTOR] += modifier; - return true; - } - if (key == "break_truce_infamy_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::BREAK_TRUCE_INFAMY_FACTOR] += modifier; - return true; - } - if (key == "break_truce_militancy_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::BREAK_TRUCE_MILITANCY_FACTOR] += modifier; - return true; - } - if (key == "good_relation_prestige_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::GOOD_RELATION_PRESTIGE_FACTOR] += modifier; - return true; - } - if (key == "good_relation_infamy_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::GOOD_RELATION_INFAMY_FACTOR] += modifier; - return true; - } - if (key == "good_relation_militancy_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::GOOD_RELATION_MILITANCY_FACTOR] += modifier; - return true; - } - if (key == "tws_battle_factor") { - modifiers[WargoalType::PEACE_MODIFIERS::WAR_SCORE_BATTLE_FACTOR] += modifier; - return true; - } - if (key == "construction_speed") { - modifiers[WargoalType::PEACE_MODIFIERS::CONSTRUCTION_SPEED] += modifier; - return true; + using enum WargoalType::PEACE_MODIFIERS; + static const string_map_t<WargoalType::PEACE_MODIFIERS> peace_modifier_map { + { "badboy_factor", BADBOY_FACTOR }, + { "prestige_factor", PRESTIGE_FACTOR }, + { "peace_cost_factor", PEACE_COST_FACTOR }, + { "penalty_factor", PENALTY_FACTOR }, + { "break_truce_prestige_factor", BREAK_TRUCE_PRESTIGE_FACTOR }, + { "break_truce_infamy_factor", BREAK_TRUCE_INFAMY_FACTOR }, + { "break_truce_militancy_factor", BREAK_TRUCE_MILITANCY_FACTOR }, + { "good_relation_prestige_factor", GOOD_RELATION_PRESTIGE_FACTOR }, + { "good_relation_infamy_factor", GOOD_RELATION_INFAMY_FACTOR }, + { "good_relation_militancy_factor", GOOD_RELATION_MILITANCY_FACTOR }, + { "tws_battle_factor", WAR_SCORE_BATTLE_FACTOR }, + { "construction_speed", CONSTRUCTION_SPEED } + }; + const decltype(peace_modifier_map)::const_iterator it = peace_modifier_map.find(key); + if (it != peace_modifier_map.end()) { + return expect_fixed_point([&modifiers, peace_modifier = it->second](fixed_point_t val) -> bool { + modifiers[peace_modifier] = val; + return true; + })(value); } Logger::error("Modifier ", key, " in wargoal ", identifier, " is invalid."); @@ -284,24 +211,30 @@ bool WargoalTypeManager::load_wargoal_file(ast::NodeCPtr root) { "always", ZERO_OR_ONE, success_callback // usage unknown / quirk )(value); - add_wargoal_type(identifier, sprite, war_name, available, truce, triggered_only, civil_war, constructing, crisis, great_war, mutual, std::move(modifiers), peace_options); + add_wargoal_type( + identifier, sprite, war_name, available, truce, triggered_only, civil_war, constructing, crisis, great_war, + mutual, std::move(modifiers), peace_options + ); return ret; } )(root); /* load order in which CBs are prioritised by AI */ - ret &= expect_dictionary_keys_and_default( - key_value_success_callback, - "peace_order", ONE_EXACTLY, expect_list([this](ast::NodeCPtr value) -> bool { - WargoalType const* wargoal; - bool ret = expect_wargoal_type_identifier(assign_variable_callback_pointer(wargoal))(value); - if (ret) { - peace_priorities.push_back(wargoal); - } else { - Logger::warning("Attempted to add invalid wargoal type to AI peace order!"); - } - return true; - }) + ret &= expect_key( + "peace_order", + expect_list( + expect_wargoal_type_identifier( + [this](WargoalType const& wargoal) -> bool { + if (std::find(peace_priorities.begin(), peace_priorities.end(), &wargoal) == peace_priorities.end()) { + peace_priorities.push_back(&wargoal); + } else { + Logger::warning("Wargoal ", wargoal.get_identifier(), " is already in the peace priority list!"); + } + return true; + }, + true // warn instead of error + ) + ) )(root); lock_wargoal_types(); diff --git a/src/openvic-simulation/military/Wargoal.hpp b/src/openvic-simulation/military/Wargoal.hpp index dbb8d67..3700347 100644 --- a/src/openvic-simulation/military/Wargoal.hpp +++ b/src/openvic-simulation/military/Wargoal.hpp @@ -1,8 +1,9 @@ #pragma once -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/EnumBitfield.hpp" #include "openvic-simulation/Modifier.hpp" +#include "openvic-simulation/types/EnumBitfield.hpp" +#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/utility/Getters.hpp" namespace OpenVic { struct WargoalTypeManager; @@ -46,22 +47,22 @@ namespace OpenVic { WAR_SCORE_BATTLE_FACTOR, CONSTRUCTION_SPEED }; - using peace_modifiers_t = std::map<PEACE_MODIFIERS, fixed_point_t>; - + using peace_modifiers_t = decimal_map_t<PEACE_MODIFIERS>; + private: - const std::string sprite; - const std::string war_name; - const Timespan available_length; - const Timespan truce_length; - const bool triggered_only; // only able to be added via effects (or within the code) - const bool civil_war; - const bool constructing; // can be added to existing wars or justified - const bool crisis; // able to be added to crises - const bool great_war; // automatically add to great wars - const bool mutual; // attacked and defender share wargoal - const peace_modifiers_t modifiers; - const peace_options_t peace_options; - + const std::string PROPERTY(sprite); + const std::string PROPERTY(war_name); + const Timespan PROPERTY(available_length); + const Timespan PROPERTY(truce_length); + const bool PROPERTY(triggered_only); // only able to be added via effects (or within the code) + const bool PROPERTY(civil_war); + const bool PROPERTY(constructing); // can be added to existing wars or justified + const bool PROPERTY(crisis); // able to be added to crises + const bool PROPERTY(great_war); // automatically add to great wars + const bool PROPERTY(mutual); // attacked and defender share wargoal + const peace_modifiers_t PROPERTY(modifiers); + const peace_options_t PROPERTY(peace_options); + // TODO: can_use, prerequisites, on_add, on_po_accepted WargoalType( @@ -82,25 +83,12 @@ namespace OpenVic { public: WargoalType(WargoalType&&) = default; - - std::string_view get_sprite() const; - std::string_view get_war_name() const; - const Timespan get_available_length() const; - const Timespan get_truce_length() const; - const bool is_triggered_only() const; - const bool is_civil_war() const; - const bool is_constructing() const; - const bool is_crisis() const; - const bool is_great_war() const; - const bool is_mutual() const; - peace_modifiers_t const& get_modifiers() const; - const peace_options_t get_peace_options() const; }; struct WargoalTypeManager { private: IdentifierRegistry<WargoalType> wargoal_types; - std::vector<WargoalType const*> peace_priorities; + std::vector<WargoalType const*> PROPERTY(peace_priorities); public: WargoalTypeManager(); diff --git a/src/openvic-simulation/types/IdentifierRegistry.hpp b/src/openvic-simulation/types/IdentifierRegistry.hpp index 1121956..662815e 100644 --- a/src/openvic-simulation/types/IdentifierRegistry.hpp +++ b/src/openvic-simulation/types/IdentifierRegistry.hpp @@ -214,24 +214,31 @@ namespace OpenVic { value_type CONST* get_item_by_index(size_t index) CONST { \ return index < items.size() ? &items[index] : nullptr; \ } \ - NodeTools::callback_t<std::string_view> expect_item_str(NodeTools::callback_t<value_type CONST&> callback) CONST { \ - return [this, callback](std::string_view identifier) -> bool { \ + NodeTools::callback_t<std::string_view> expect_item_str( \ + NodeTools::callback_t<value_type CONST&> callback, bool warn \ + ) CONST { \ + return [this, callback, warn](std::string_view identifier) -> bool { \ value_type CONST* item = get_item_by_identifier(identifier); \ if (item != nullptr) { \ return callback(*item); \ } \ - Logger::error("Invalid ", name, ": ", identifier); \ - return false; \ + if (!warn) { \ + Logger::error("Invalid ", name, ": ", identifier); \ + return false; \ + } else { \ + Logger::warning("Invalid ", name, ": ", identifier); \ + return true; \ + } \ }; \ } \ - NodeTools::node_callback_t expect_item_identifier(NodeTools::callback_t<value_type CONST&> callback) CONST { \ - return NodeTools::expect_identifier(expect_item_str(callback)); \ + NodeTools::node_callback_t expect_item_identifier(NodeTools::callback_t<value_type CONST&> callback, bool warn) CONST { \ + return NodeTools::expect_identifier(expect_item_str(callback, warn)); \ } \ NodeTools::node_callback_t expect_item_dictionary( \ NodeTools::callback_t<value_type CONST&, ast::NodeCPtr> callback \ ) CONST { \ return NodeTools::expect_dictionary([this, callback](std::string_view key, ast::NodeCPtr value) -> bool { \ - return expect_item_str(std::bind(callback, std::placeholders::_1, value))(key); \ + return expect_item_str(std::bind(callback, std::placeholders::_1, value), false)(key); \ }); \ } @@ -348,14 +355,14 @@ namespace OpenVic { return plural.get_item_identifiers(); \ } \ NodeTools::callback_t<std::string_view> expect_##singular##_str( \ - NodeTools::callback_t<decltype(plural)::value_type const&> callback \ + NodeTools::callback_t<decltype(plural)::value_type const&> callback, bool warn = false \ ) const { \ - return plural.expect_item_str(callback); \ + return plural.expect_item_str(callback, warn); \ } \ NodeTools::node_callback_t expect_##singular##_identifier( \ - NodeTools::callback_t<decltype(plural)::value_type const&> callback \ + NodeTools::callback_t<decltype(plural)::value_type const&> callback, bool warn = false \ ) const { \ - return plural.expect_item_identifier(callback); \ + return plural.expect_item_identifier(callback, warn); \ } \ NodeTools::node_callback_t expect_##singular##_dictionary( \ NodeTools::callback_t<decltype(plural)::value_type const&, ast::NodeCPtr> callback \ @@ -373,14 +380,14 @@ namespace OpenVic { return plural.get_item_by_identifier(identifier); \ } \ NodeTools::callback_t<std::string_view> expect_##singular##_str( \ - NodeTools::callback_t<decltype(plural)::value_type&> callback \ + NodeTools::callback_t<decltype(plural)::value_type&> callback, bool warn = false \ ) { \ - return plural.expect_item_str(callback); \ + return plural.expect_item_str(callback, warn); \ } \ NodeTools::node_callback_t expect_##singular##_identifier( \ - NodeTools::callback_t<decltype(plural)::value_type&> callback \ + NodeTools::callback_t<decltype(plural)::value_type&> callback, bool warn = false \ ) { \ - return plural.expect_item_identifier(callback); \ + return plural.expect_item_identifier(callback, warn); \ } \ NodeTools::node_callback_t expect_##singular##_dictionary( \ NodeTools::callback_t<decltype(plural)::value_type&, ast::NodeCPtr> callback \ diff --git a/src/openvic-simulation/utility/Getters.hpp b/src/openvic-simulation/utility/Getters.hpp index e34a970..53763ea 100644 --- a/src/openvic-simulation/utility/Getters.hpp +++ b/src/openvic-simulation/utility/Getters.hpp @@ -4,6 +4,38 @@ #include <string> #include <string_view> +#include <openvic-dataloader/detail/SelfType.hpp> +#include <openvic-dataloader/detail/TypeName.hpp> + +#define OV_DETAIL_GET_TYPE_BASE_CLASS(CLASS) \ + static constexpr std::string_view get_type_static() { return ::ovdl::detail::type_name<CLASS>(); } \ + constexpr virtual std::string_view get_type() const = 0; \ + static constexpr std::string_view get_base_type_static() { return ::ovdl::detail::type_name<CLASS>(); } \ + constexpr virtual std::string_view get_base_type() const { return get_base_type_static(); } \ + template<typename T> constexpr bool is_type() const { \ + return get_type().compare(::ovdl::detail::type_name<T>()) == 0; } \ + template<typename T> constexpr bool is_derived_from() const { \ + return is_type<T>() || get_base_type().compare(::ovdl::detail::type_name<T>()) == 0; } \ + template<typename T> constexpr T* cast_to() { \ + if (is_derived_from<T>() || is_type<CLASS>()) return (static_cast<T*>(this)); \ + return nullptr; } \ + template<typename T> constexpr const T* const cast_to() const { \ + if (is_derived_from<T>() || is_type<CLASS>()) return (static_cast<const T*>(this)); \ + return nullptr; } + +#define OV_DETAIL_GET_TYPE \ + struct _self_type_tag {}; \ + constexpr auto _self_type_helper()->decltype(::ovdl::detail::Writer<_self_type_tag, decltype(this)> {}); \ + using type = ::ovdl::detail::Read<_self_type_tag>; \ + static constexpr std::string_view get_type_static() { return ::ovdl::detail::type_name<type>(); } \ + constexpr std::string_view get_type() const override { \ + return ::ovdl::detail::type_name<std::decay_t<decltype(*this)>>(); } + +#define OV_DETAIL_GET_BASE_TYPE(CLASS) \ + static constexpr std::string_view get_base_type_static() { return ::ovdl::detail::type_name<CLASS>(); } \ + constexpr std::string_view get_base_type() const override { \ + return ::ovdl::detail::type_name<std::decay_t<decltype(*this)>>(); } + #define REF_GETTERS(var) \ constexpr decltype(var)& get_##var() { \ return var; \ |