Type safe manual merge

Author: wvpm

extension/src/openvic-extension/classes/GUILabel.cpp

@@ -1,19 +1,23 @@
 #include "GUILabel.hpp"
 
+#include <optional>
+
 #include <godot_cpp/classes/font_file.hpp>
 #include <godot_cpp/classes/style_box_texture.hpp>
 #include <godot_cpp/core/error_macros.hpp>
 #include <godot_cpp/variant/node_path.hpp>
 #include <godot_cpp/variant/string_name.hpp>
 #include <godot_cpp/variant/utility_functions.hpp>
 
+#include <openvic-simulation/types/TypedIndices.hpp>
+#include <openvic-simulation/types/TextFormat.hpp>
+
 #include "openvic-extension/classes/GUINode.hpp"
 #include "openvic-extension/core/Convert.hpp"
 #include "openvic-extension/singletons/AssetManager.hpp"
 #include "openvic-extension/singletons/GameSingleton.hpp"
 #include "openvic-extension/core/Bind.hpp"
 #include "openvic-extension/utility/Utilities.hpp"
-#include "openvic-simulation/types/TextFormat.hpp"
 
 using namespace OpenVic;
 using namespace godot;
@@ -690,7 +694,7 @@ void GUILabel::separate_currency_segments(
 GUILabel::flag_segment_t GUILabel::make_flag_segment(String const& identifier) {
 	GameSingleton& game_singleton = *GameSingleton::get_singleton();
 
-	int32_t country_index = -1;
+	std::optional<country_index_t> country_index = std::nullopt;
 	StringName flag_type;
 
 	InstanceManager* instance_manager = game_singleton.get_instance_manager();
@@ -721,14 +725,14 @@ GUILabel::flag_segment_t GUILabel::make_flag_segment(String const& identifier) {
 	}
 
 	// If no country with the given identifier can be found, fallback to country index 0 (usually REB) and empty flag type
-	if (country_index < 0) {
+	if (!country_index.has_value()) {
 		UtilityFunctions::push_warning(
 			"Failed to find country with identifier \"", identifier, "\" for GUILabel flag segment, falling back to index 0"
 		);
-		country_index = 0;
+		country_index = country_index_t(0);
 	}
 
-	const Rect2 flag_image_rect = game_singleton.get_flag_sheet_rect(country_index, flag_type);
+	const Rect2 flag_image_rect = game_singleton.get_flag_sheet_rect(country_index.value(), flag_type);
 	ERR_FAIL_COND_V(!flag_image_rect.has_area(), {});
 
 	flag_segment_t flag_segment;

extension/src/openvic-extension/components/budget/StrataTaxBudget.cpp

@@ -1,6 +1,7 @@
 #include "StrataTaxBudget.hpp"
 
 #include <godot_cpp/variant/string.hpp>
+#include <type_safe/strong_typedef.hpp>
 
 #include <openvic-simulation/country/CountryInstance.hpp>
 #include "openvic-simulation/modifier/ModifierEffectCache.hpp"
@@ -23,8 +24,8 @@ StrataTaxBudget::StrataTaxBudget(
 		parent,
 		generate_slider_tooltip_localisation_key(new_strata),
 		BALANCE,
-		Utilities::format("./country_budget/tax_%d_slider", static_cast<uint64_t>(new_strata.index)),
-		Utilities::format("./country_budget/tax_%d_inc", static_cast<uint64_t>(new_strata.index))
+		Utilities::format("./country_budget/tax_%d_slider", static_cast<uint64_t>(type_safe::get(new_strata.index))),
+		Utilities::format("./country_budget/tax_%d_inc", static_cast<uint64_t>(type_safe::get(new_strata.index)))
 	),
 	BudgetIncomeComponent(generate_summary_localisation_key(new_strata), 1),
 	strata{new_strata},
@@ -37,7 +38,7 @@ StrataTaxBudget::StrataTaxBudget(
 
 	GUILabel::set_text_and_tooltip(
 		parent,
-		Utilities::format("./country_budget/tax_%d_desc", static_cast<uint64_t>(new_strata.index)),
+		Utilities::format("./country_budget/tax_%d_desc", static_cast<uint64_t>(type_safe::get(new_strata.index))),
 		generate_slider_tooltip_localisation_key(new_strata),
 		Utilities::format(
 			"TAX_%s_DESC",

extension/src/openvic-extension/singletons/GameSingleton.cpp

@@ -1,13 +1,18 @@
 #include "GameSingleton.hpp"
 
+#include <cstdint>
 #include <functional>
+#include <type_safe/strong_typedef.hpp>
 
 #include <godot_cpp/classes/time.hpp>
 #include <godot_cpp/core/error_macros.hpp>
 #include <godot_cpp/variant/packed_string_array.hpp>
 #include <godot_cpp/variant/utility_functions.hpp>
 
 #include <openvic-simulation/dataloader/ModManager.hpp>
+#include <openvic-simulation/DefinitionManager.hpp>
+#include <openvic-simulation/map/Crime.hpp>
+#include <openvic-simulation/types/TypedIndices.hpp>
 #include <openvic-simulation/utility/Containers.hpp>
 #include <openvic-simulation/utility/Logger.hpp>
 
@@ -203,19 +208,21 @@ TypedArray<Dictionary> GameSingleton::get_bookmark_info() const {
 }
 
 Error GameSingleton::setup_game(int32_t bookmark_index) {
-	Bookmark const* bookmark =
-		game_manager.get_definition_manager().get_history_manager().get_bookmark_manager().get_bookmark_by_index(bookmark_index
-		);
+	DefinitionManager const& definition_manager = game_manager.get_definition_manager();
+	Bookmark const* bookmark = definition_manager.get_history_manager()
+		.get_bookmark_manager()
+		.get_bookmark_by_index(bookmark_index_t(bookmark_index));
 	ERR_FAIL_NULL_V_MSG(bookmark, FAILED, Utilities::format("Failed to get bookmark with index: %d", bookmark_index));
-	bool ret = game_manager.setup_instance(bookmark);
+	bool ret = game_manager.setup_instance(*bookmark);
 
 	// TODO - remove this temporary crime assignment
 	InstanceManager* instance_manager = get_instance_manager();
 	ERR_FAIL_NULL_V_MSG(instance_manager, FAILED, "Failed to setup instance manager!");
+	
+	CrimeManager const& crime_manager = definition_manager.get_crime_manager();
 	for (ProvinceInstance& province : instance_manager->get_map_instance().get_province_instances()) {
-		province.set_crime(get_definition_manager().get_crime_manager().get_crime_modifier_by_index(
-			province.index % get_definition_manager().get_crime_manager().get_crime_modifier_count()
-		));
+		const crime_index_t crime_index = crime_index_t(type_safe::get(province.index) % crime_manager.get_crime_modifier_count());
+		province.set_crime(crime_manager.get_crime_modifier_by_index(crime_index));
 	}
 
 	ret &= MenuSingleton::get_singleton()->_population_menu_update_provinces() == OK;
@@ -314,17 +321,18 @@ Ref<ImageTexture> GameSingleton::get_flag_sheet_texture() const {
 	return flag_sheet_texture;
 }
 
-int32_t GameSingleton::get_flag_sheet_index(int32_t country_index, StringName const& flag_type) const {
+int32_t GameSingleton::get_flag_sheet_index(const country_index_t country_index, StringName const& flag_type) const {
+	const uint64_t index = static_cast<uint64_t>(type_safe::get(country_index));
 	ERR_FAIL_COND_V_MSG(
-		country_index < 0 ||
-			country_index >= get_definition_manager().get_country_definition_manager().get_country_definition_count(),
-		-1, Utilities::format("Invalid country index: %d", country_index)
+		index < 0 ||
+			index >= get_definition_manager().get_country_definition_manager().get_country_definition_count(),
+		-1, Utilities::format("Invalid country index: %d", index)
 	);
 
 	const typename decltype(flag_type_index_map)::const_iterator it = flag_type_index_map.find(flag_type);
 	ERR_FAIL_COND_V_MSG(it == flag_type_index_map.end(), -1, Utilities::format("Invalid flag type %s", flag_type));
 
-	return flag_type_index_map.size() * country_index + it->second;
+	return flag_type_index_map.size() * index + it->second;
 }
 
 Rect2i GameSingleton::get_flag_sheet_rect(int32_t flag_index) const {
@@ -335,7 +343,7 @@ Rect2i GameSingleton::get_flag_sheet_rect(int32_t flag_index) const {
 	return { Vector2i { flag_index % flag_sheet_dims.x, flag_index / flag_sheet_dims.x } * flag_dims, flag_dims };
 }
 
-Rect2i GameSingleton::get_flag_sheet_rect(int32_t country_index, StringName const& flag_type) const {
+Rect2i GameSingleton::get_flag_sheet_rect(const country_index_t country_index, StringName const& flag_type) const {
 	return get_flag_sheet_rect(get_flag_sheet_index(country_index, flag_type));
 }
 
@@ -408,9 +416,7 @@ TypedArray<Dictionary> GameSingleton::get_province_names() const {
 	TypedArray<Dictionary> ret;
 	ERR_FAIL_COND_V(ret.resize(map_definition.get_province_definition_count()) != OK, {});
 
-	for (int32_t index = 0; index < map_definition.get_province_definition_count(); ++index) {
-		ProvinceDefinition const& province = map_definition.get_province_definitions()[index];
-
+	for (ProvinceDefinition const& province : map_definition.get_province_definitions()) {
 		Dictionary province_dict;
 
 		province_dict[identifier_key] = convert_to<String>(province.get_identifier());
@@ -426,7 +432,7 @@ TypedArray<Dictionary> GameSingleton::get_province_names() const {
 			province_dict[scale_key] = scale;
 		}
 
-		ret[index] = std::move(province_dict);
+		ret[type_safe::get(province.index)] = std::move(province_dict);
 	}
 
 	return ret;
@@ -437,31 +443,37 @@ int32_t GameSingleton::get_mapmode_count() const {
 }
 
 String GameSingleton::get_mapmode_identifier(int32_t index) const {
-	Mapmode const* identifier_mapmode = get_definition_manager().get_mapmode_manager().get_mapmode_by_index(index);
+	Mapmode const* identifier_mapmode = get_definition_manager()
+		.get_mapmode_manager()
+		.get_mapmode_by_index(map_mode_index_t(index));
 	if (identifier_mapmode != nullptr) {
 		return convert_to<String>(identifier_mapmode->get_identifier());
 	}
 	return String {};
 }
 
 String GameSingleton::get_mapmode_localisation_key(int32_t index) const {
-	Mapmode const* localisation_key_mapmode = get_definition_manager().get_mapmode_manager().get_mapmode_by_index(index);
+	Mapmode const* localisation_key_mapmode = get_definition_manager()
+		.get_mapmode_manager()
+		.get_mapmode_by_index(map_mode_index_t(index));
 	if (localisation_key_mapmode != nullptr) {
 		return convert_to<String>(localisation_key_mapmode->get_localisation_key());
 	}
 	return String {};
 }
 
 int32_t GameSingleton::get_current_mapmode_index() const {
-	return mapmode->index;
+	return type_safe::get(mapmode->index);
 }
 
 Error GameSingleton::set_mapmode(int32_t index) {
-	Mapmode const* new_mapmode = get_definition_manager().get_mapmode_manager().get_mapmode_by_index(index);
+	Mapmode const* new_mapmode = get_definition_manager()
+		.get_mapmode_manager()
+		.get_mapmode_by_index(map_mode_index_t(index));
 	ERR_FAIL_NULL_V_MSG(new_mapmode, FAILED, Utilities::format("Failed to find mapmode with index: %d", index));
 	mapmode = new_mapmode;
 	const Error err = _update_colour_image();
-	emit_signal(_signal_mapmode_changed(), mapmode->index);
+	emit_signal(_signal_mapmode_changed(), static_cast<uint64_t>(type_safe::get(mapmode->index)));
 	return err;
 }
 

extension/src/openvic-extension/singletons/GameSingleton.hpp

@@ -6,6 +6,7 @@
 
 #include <openvic-simulation/GameManager.hpp>
 #include <openvic-simulation/dataloader/Dataloader.hpp>
+#include <openvic-simulation/types/TypedIndices.hpp>
 
 namespace OpenVic {
 
@@ -106,9 +107,9 @@ namespace OpenVic {
 
 		/* The index of the flag in the flag sheet corresponding to the requested country / flag_type
 		 * combination, or -1 if no such flag can be found. */
-		int32_t get_flag_sheet_index(int32_t country_index, godot::StringName const& flag_type) const;
+		int32_t get_flag_sheet_index(const country_index_t country_index, godot::StringName const& flag_type) const;
 		godot::Rect2i get_flag_sheet_rect(int32_t flag_index) const;
-		godot::Rect2i get_flag_sheet_rect(int32_t country_index, godot::StringName const& flag_type) const;
+		godot::Rect2i get_flag_sheet_rect(const country_index_t country_index, godot::StringName const& flag_type) const;
 
 		/* Number of (vertical, horizontal) subdivisions the province shape image
 		 * was split into when making the province_shape_texture to ensure no

extension/src/openvic-extension/singletons/MapItemSingleton.cpp

@@ -1,5 +1,7 @@
 #include "MapItemSingleton.hpp"
 
+#include <type_safe/strong_typedef.hpp>
+
 #include <openvic-simulation/utility/Containers.hpp>
 
 #include "godot_cpp/core/error_macros.hpp"
@@ -226,7 +228,9 @@ PackedByteArray MapItemSingleton::get_rgo_icons() const {
 		}
 
 		GoodDefinition const* rgo_good = prov_inst.get_rgo_good();
-		icons[index++] = rgo_good != nullptr ? rgo_good->index + 1 : 0; // 0 if no rgo good in the province
+		icons[index++] = rgo_good != nullptr
+			? type_safe::get(rgo_good->index) + 1
+			: 0; // 0 if no rgo good in the province
 	}
 
 	return icons;

extension/src/openvic-extension/singletons/MenuSingleton.cpp

@@ -1,6 +1,7 @@
 #include "MenuSingleton.hpp"
 
 #include <span>
+#include <type_safe/strong_typedef.hpp>
 
 #include <godot_cpp/variant/utility_functions.hpp>
 
@@ -539,7 +540,7 @@ Dictionary MenuSingleton::get_province_info_from_number(int32_t province_number)
 		ProductionType const& production_type = *rgo.get_production_type_nullable();
 		GoodDefinition const& rgo_good = *province->get_rgo_good();
 
-		ret[province_info_rgo_icon_key] = static_cast<int32_t>(rgo_good.index);
+		ret[province_info_rgo_icon_key] = static_cast<uint64_t>(type_safe::get(rgo_good.index));
 
 		ret[province_info_rgo_output_quantity_yesterday_key] = static_cast<real_t>(rgo.get_output_quantity_yesterday());
 		ret[province_info_rgo_revenue_yesterday_key] = static_cast<real_t>(rgo.get_revenue_yesterday());

extension/src/openvic-extension/singletons/MilitaryMenu.cpp

@@ -3,6 +3,7 @@
 #include <godot_cpp/variant/utility_functions.hpp>
 
 #include <openvic-simulation/military/UnitInstanceGroup.hpp>
+#include <openvic-simulation/types/TypedIndices.hpp>
 #include <openvic-simulation/types/UnitBranchType.hpp>
 
 #include "openvic-extension/classes/GUINode.hpp"
@@ -308,16 +309,16 @@ Dictionary MenuSingleton::make_in_progress_unit_dict() const {
 	const fixed_point_t progress = fixed_point_t::_0_50;
 	const ordered_map<GoodDefinition const*, std::pair<fixed_point_t, fixed_point_t>> required_goods {
 		{
-			good_definition_manager.get_good_definition_by_index(0),
+			good_definition_manager.get_good_definition_by_index(good_index_t(0)),
 			{ fixed_point_t::parse(1234) / 100, fixed_point_t::parse(1900) / 100 }
 		}, {
-			good_definition_manager.get_good_definition_by_index(1),
+			good_definition_manager.get_good_definition_by_index(good_index_t(1)),
 			{ fixed_point_t::parse(888) / 100, fixed_point_t::parse(1444) / 100 }
 		}, {
-			good_definition_manager.get_good_definition_by_index(2),
+			good_definition_manager.get_good_definition_by_index(good_index_t(2)),
 			{ fixed_point_t::parse(1622) / 100, fixed_point_t::parse(1622) / 100 }
 		}, {
-			good_definition_manager.get_good_definition_by_index(3),
+			good_definition_manager.get_good_definition_by_index(good_index_t(3)),
 			{ fixed_point_t::parse(211) / 100, fixed_point_t::parse(805) / 100 }
 		}
 	};