Merge pull request #145 from OpenVicProject/gui-loading

Added support for loading all gui files

Author: Hop311

src/openvic-simulation/dataloader/Dataloader.cpp

@@ -283,21 +283,34 @@ bool Dataloader::_load_interface_files(UIManager& ui_manager) const {
 	ui_manager.lock_sprites();
 	ui_manager.lock_fonts();
 
-	// Hard-coded example until the mechanism for requesting them from GDScript is fleshed out
+	/* Hard-coded GUI file names, might be replaced with a dynamic system but everything should still be loaded on startup. */
 	static const std::vector<std::string_view> gui_files {
-		"province_interface.gui", "topbar.gui"
+		/* Contains generic listbox scrollbar */
+		"core",
+
+		/* Over-map menus */
+		"province_interface", "topbar", "menubar", "outliner",
+
+		/* Nation management screens */
+		"country_production", "country_budget", "country_technology", "country_politics", "country_pops", "country_trade",
+		"country_diplomacy", "country_military"
 	};
 
+	static constexpr std::string_view gui_file_extension = ".gui";
+
 	ui_manager.reserve_more_scenes(gui_files.size());
 
 	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()
+			gui_file, parse_defines(lookup_file(
+				append_string_views(interface_directory, gui_file, gui_file_extension)
+			)).get_file_node()
 		)) {
 			Logger::error("Failed to load interface gui file: ", gui_file);
 			ret = false;
 		}
 	}
+
 	ui_manager.lock_scenes();
 
 	return ret;

src/openvic-simulation/dataloader/NodeTools.cpp

@@ -169,6 +169,14 @@ node_callback_t NodeTools::expect_date(callback_t<Date> callback) {
 	return expect_identifier(expect_date_str(callback));
 }
 
+node_callback_t NodeTools::expect_date_string(callback_t<Date> callback) {
+	return expect_string(expect_date_str(callback));
+}
+
+node_callback_t NodeTools::expect_date_identifier_or_string(callback_t<Date> callback) {
+	return expect_identifier_or_string(expect_date_str(callback));
+}
+
 node_callback_t NodeTools::expect_years(callback_t<Timespan> callback) {
 	return expect_uint<Timespan::day_t>([callback](Timespan::day_t val) -> bool {
 		return callback(Timespan::from_years(val));

src/openvic-simulation/dataloader/NodeTools.hpp

@@ -119,6 +119,8 @@ namespace OpenVic {
 
 		callback_t<std::string_view> expect_date_str(callback_t<Date> callback);
 		node_callback_t expect_date(callback_t<Date> callback);
+		node_callback_t expect_date_string(callback_t<Date> callback);
+		node_callback_t expect_date_identifier_or_string(callback_t<Date> callback);
 		node_callback_t expect_years(callback_t<Timespan> callback);
 		node_callback_t expect_months(callback_t<Timespan> callback);
 		node_callback_t expect_days(callback_t<Timespan> callback);
@@ -371,15 +373,15 @@ namespace OpenVic {
 
 		template<typename T, StringMapCase Case>
 		Callback<std::string_view> auto expect_mapped_string(
-			template_string_map_t<T, Case> const& map, Callback<T> auto callback
+			template_string_map_t<T, Case> const& map, Callback<T> auto callback, bool warn = false
 		) {
-			return [&map, callback](std::string_view string) -> bool {
+			return [&map, callback, warn](std::string_view string) -> bool {
 				const typename template_string_map_t<T, Case>::const_iterator it = map.find(string);
 				if (it != map.end()) {
 					return callback(it->second);
 				}
-				Logger::error("String not found in map: ", string);
-				return false;
+				Logger::warn_or_error(warn, "String not found in map: ", string);
+				return warn;
 			};
 		}
 
@@ -470,24 +472,14 @@ namespace OpenVic {
 			};
 		}
 
-		template<typename... Args>
-		bool warn_or_error(bool warn, Args&&... args) {
-			if (warn) {
-				Logger::warning(std::forward<Args>(args)...);
-				return true;
-			} else {
-				Logger::error(std::forward<Args>(args)...);
-				return false;
-			}
-		}
-
 		template<typename T, typename U, typename... SetArgs>
 		Callback<T> auto set_callback(tsl::ordered_set<U, SetArgs...>& set, bool warn = false) {
 			return [&set, warn](T val) -> bool {
 				if (set.emplace(std::move(val)).second) {
 					return true;
 				}
-				return warn_or_error(warn, "Duplicate set entry: \"", val, "\"");
+				Logger::warn_or_error(warn, "Duplicate set entry: \"", val, "\"");
+				return warn;
 			};
 		}
 
@@ -497,7 +489,8 @@ namespace OpenVic {
 				if (set.emplace(&val).second) {
 					return true;
 				}
-				return warn_or_error(warn, "Duplicate set entry: \"", &val, "\"");
+				Logger::warn_or_error(warn, "Duplicate set entry: \"", &val, "\"");
+				return warn;
 			};
 		}
 
@@ -509,7 +502,8 @@ namespace OpenVic {
 				if (map.emplace(key, std::move(value)).second) {
 					return true;
 				}
-				return warn_or_error(warn, "Duplicate map entry with key: \"", key, "\"");
+				Logger::warn_or_error(warn, "Duplicate map entry with key: \"", key, "\"");
+				return warn;
 			};
 		}
 	}

src/openvic-simulation/history/DiplomaticHistory.cpp

@@ -32,20 +32,20 @@ AllianceHistory::AllianceHistory(
 	Country const* new_first,
 	Country const* new_second,
 	const Period new_period
-) : first { new_first }, second { new_second }, period {new_period} {}
+) : first { new_first }, second { new_second }, period { new_period } {}
 
 ReparationsHistory::ReparationsHistory(
 	Country const* new_receiver,
 	Country const* new_sender,
 	const Period new_period
-) : receiver { new_receiver }, sender { new_sender }, period {new_period} {}
+) : receiver { new_receiver }, sender { new_sender }, period { new_period } {}
 
 SubjectHistory::SubjectHistory(
 	Country const* new_overlord,
 	Country const* new_subject,
 	const type_t new_type,
 	const Period new_period
-) : overlord { new_overlord }, subject { new_subject }, type { new_type }, period {new_period} {}
+) : overlord { new_overlord }, subject { new_subject }, type { new_type }, period { new_period } {}
 
 void DiplomaticHistoryManager::reserve_more_wars(size_t size) {
 	if (locked) {
@@ -115,10 +115,10 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const&
 			std::optional<Date> end {};
 
 			bool ret = expect_dictionary_keys(
-				"first", ONE_EXACTLY, expect_identifier_or_string(country_manager.expect_country_str(assign_variable_callback_pointer(first))),
-				"second", ONE_EXACTLY, expect_identifier_or_string(country_manager.expect_country_str(assign_variable_callback_pointer(second))),
-				"start_date", ONE_EXACTLY, expect_identifier_or_string(expect_date_str(assign_variable_callback(start))),
-				"end_date", ZERO_OR_ONE, expect_identifier_or_string(expect_date_str(assign_variable_callback(end)))
+				"first", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(first)),
+				"second", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(second)),
+				"start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)),
+				"end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end))
 			)(node);
 
 			alliances.push_back({ first, second, { start, end } });
@@ -131,10 +131,10 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const&
 			std::optional<Date> end {};
 
 			bool ret = expect_dictionary_keys(
-				"first", ONE_EXACTLY, expect_identifier_or_string(country_manager.expect_country_str(assign_variable_callback_pointer(overlord))),
-				"second", ONE_EXACTLY, expect_identifier_or_string(country_manager.expect_country_str(assign_variable_callback_pointer(subject))),
-				"start_date", ONE_EXACTLY, expect_identifier_or_string(expect_date_str(assign_variable_callback(start))),
-				"end_date", ZERO_OR_ONE, expect_identifier_or_string(expect_date_str(assign_variable_callback(end)))
+				"first", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(overlord)),
+				"second", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(subject)),
+				"start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)),
+				"end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end))
 			)(node);
 
 			subjects.push_back({ overlord, subject, SubjectHistory::type_t::VASSAL, { start, end } });
@@ -147,10 +147,10 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const&
 			std::optional<Date> end {};
 
 			bool ret = expect_dictionary_keys(
-				"first", ONE_EXACTLY, country_manager.expect_country_identifier(assign_variable_callback_pointer(overlord)),
-				"second", ONE_EXACTLY, country_manager.expect_country_identifier(assign_variable_callback_pointer(subject)),
-				"start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start)),
-				"end_date", ZERO_OR_ONE, expect_date(assign_variable_callback(end))
+				"first", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(overlord)),
+				"second", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(subject)),
+				"start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)),
+				"end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end))
 			)(node);
 
 			subjects.push_back({ overlord, subject, SubjectHistory::type_t::UNION, { start, end } });
@@ -163,10 +163,10 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const&
 			std::optional<Date> end {};
 
 			bool ret = expect_dictionary_keys(
-				"first", ONE_EXACTLY, country_manager.expect_country_identifier(assign_variable_callback_pointer(overlord)),
-				"second", ONE_EXACTLY, country_manager.expect_country_identifier(assign_variable_callback_pointer(subject)),
-				"start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start)),
-				"end_date", ZERO_OR_ONE, expect_date(assign_variable_callback(end))
+				"first", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(overlord)),
+				"second", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(subject)),
+				"start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)),
+				"end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end))
 			)(node);
 
 			subjects.push_back({ overlord, subject, SubjectHistory::type_t::SUBSTATE, { start, end } });
@@ -179,10 +179,10 @@ bool DiplomaticHistoryManager::load_diplomacy_history_file(CountryManager const&
 			std::optional<Date> end {};
 
 			bool ret = expect_dictionary_keys(
-				"first", ONE_EXACTLY, country_manager.expect_country_identifier(assign_variable_callback_pointer(receiver)),
-				"second", ONE_EXACTLY, country_manager.expect_country_identifier(assign_variable_callback_pointer(sender)),
-				"start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start)),
-				"end_date", ZERO_OR_ONE, expect_date(assign_variable_callback(end))
+				"first", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(receiver)),
+				"second", ONE_EXACTLY, country_manager.expect_country_identifier_or_string(assign_variable_callback_pointer(sender)),
+				"start_date", ONE_EXACTLY, expect_date_identifier_or_string(assign_variable_callback(start)),
+				"end_date", ZERO_OR_ONE, expect_date_identifier_or_string(assign_variable_callback(end))
 			)(node);
 
 			reparations.push_back({ receiver, sender, { start, end } });

src/openvic-simulation/history/Period.cpp

@@ -5,7 +5,7 @@ using namespace OpenVic;
 Period::Period(
 	const Date new_start_date,
 	const std::optional<Date> new_end_date
-) : start_date {new_start_date}, end_date {new_end_date} {}
+) : start_date { new_start_date }, end_date { new_end_date } {}
 
 bool Period::is_date_in_period(const Date date) const {
 	return start_date <= date && (!end_date.has_value() || end_date.value() >= date);

src/openvic-simulation/interface/GFX.cpp

@@ -4,8 +4,11 @@ using namespace OpenVic;
 using namespace OpenVic::GFX;
 using namespace OpenVic::NodeTools;
 
-Font::Font(std::string_view new_identifier, colour_argb_t new_colour, std::string_view new_fontname)
-	: HasIdentifierAndAlphaColour { new_identifier, new_colour, false }, fontname { new_fontname } {}
+Font::Font(
+	std::string_view new_identifier, colour_argb_t new_colour, std::string_view new_fontname, std::string_view new_charset,
+	uint32_t new_height
+) : HasIdentifierAndAlphaColour { new_identifier, new_colour, false }, fontname { new_fontname }, charset { new_charset },
+	height { new_height } {}
 
 node_callback_t Sprite::expect_sprites(length_callback_t length_callback, callback_t<std::unique_ptr<Sprite>&&> callback) {
 	return expect_dictionary_keys_and_length(
@@ -17,8 +20,9 @@ node_callback_t Sprite::expect_sprites(length_callback_t length_callback, callba
 		"textSpriteType", ZERO_OR_MORE, _expect_instance<Sprite, TextureSprite>(callback),
 		"maskedShieldType", ZERO_OR_MORE, _expect_instance<Sprite, MaskedFlag>(callback),
 		"tileSpriteType", ZERO_OR_MORE, _expect_instance<Sprite, TileTextureSprite>(callback),
-		// TODO - add the rest of the sprite types
-		"corneredTileSpriteType", ZERO_OR_MORE, success_callback,
+		"corneredTileSpriteType", ZERO_OR_MORE, _expect_instance<Sprite, CorneredTileTextureSprite>(callback),
+
+		/* Each only has one vanilla instance which isn't used anywhere. */
 		"BarChartType", ZERO_OR_MORE, success_callback,
 		"scrollingSprite", ZERO_OR_MORE, success_callback
 	);
@@ -47,16 +51,31 @@ TileTextureSprite::TileTextureSprite() : texture_file {}, size {} {}
 bool TileTextureSprite::_fill_key_map(case_insensitive_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)),
-		"size", ZERO_OR_ONE, expect_ivec2(assign_variable_callback(size)),
+		"texturefile", ONE_EXACTLY, expect_string(assign_variable_callback_string(texture_file)),
+		"size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)),
 
 		"norefcount", ZERO_OR_ONE, success_callback,
 		"loadType", ZERO_OR_ONE, success_callback
 	);
 	return ret;
 }
 
-ProgressBar::ProgressBar() : back_colour {}, progress_colour {} {}
+CorneredTileTextureSprite::CorneredTileTextureSprite() : texture_file {}, size {}, border_size {} {}
+
+bool CorneredTileTextureSprite::_fill_key_map(case_insensitive_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)),
+		"size", ONE_EXACTLY, expect_ivec2(assign_variable_callback(size)),
+		"borderSize", ONE_EXACTLY, expect_ivec2(assign_variable_callback(border_size)),
+
+		"allwaystransparent", ZERO_OR_ONE, success_callback,
+		"loadType", 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(case_insensitive_key_map_t& key_map) {
 	bool ret = Sprite::_fill_key_map(key_map);
@@ -90,6 +109,7 @@ bool LineChart::_fill_key_map(case_insensitive_key_map_t& 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;
@@ -102,6 +122,7 @@ bool MaskedFlag::_fill_key_map(case_insensitive_key_map_t& key_map) {
 	ret &= add_key_map_entries(key_map,
 		"textureFile1", ONE_EXACTLY, expect_string(assign_variable_callback_string(overlay_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

src/openvic-simulation/interface/GFX.hpp

@@ -12,11 +12,16 @@ namespace OpenVic::GFX {
 		friend class OpenVic::UIManager;
 
 	private:
-		const std::string PROPERTY(fontname);
+		std::string PROPERTY(fontname);
+		std::string PROPERTY(charset);
+		uint32_t PROPERTY(height);
 
 		// TODO - colorcodes, effect
 
-		Font(std::string_view new_identifier, colour_argb_t new_colour, std::string_view new_fontname);
+		Font(
+			std::string_view new_identifier, colour_argb_t new_colour, std::string_view new_fontname,
+			std::string_view new_charset, uint32_t new_height
+		);
 
 	public:
 		Font(Font&&) = default;
@@ -79,6 +84,25 @@ namespace OpenVic::GFX {
 		OV_DETAIL_GET_TYPE
 	};
 
+	class CorneredTileTextureSprite final : public Sprite {
+		friend std::unique_ptr<CorneredTileTextureSprite> std::make_unique<CorneredTileTextureSprite>();
+
+		std::string PROPERTY(texture_file);
+		ivec2_t PROPERTY(size);
+		ivec2_t PROPERTY(border_size);
+
+	protected:
+		CorneredTileTextureSprite();
+
+		bool _fill_key_map(NodeTools::case_insensitive_key_map_t& key_map) override;
+
+	public:
+		CorneredTileTextureSprite(CorneredTileTextureSprite&&) = default;
+		virtual ~CorneredTileTextureSprite() = default;
+
+		OV_DETAIL_GET_TYPE
+	};
+
 	class ProgressBar final : public Sprite {
 		friend std::unique_ptr<ProgressBar> std::make_unique<ProgressBar>();