Clang-format formatting (with manual cleanup)

9 files changed, 161 insertions, 107 deletions

diff --git a/extension/src/openvic-extension/Checksum.hpp b/extension/src/openvic-extension/Checksum.hpp
index 38839df..c5d8daf 100644
--- a/extension/src/openvic-extension/Checksum.hpp
+++ b/extension/src/openvic-extension/Checksum.hpp
@@ -7,7 +7,7 @@ namespace OpenVic {
 		GDCLASS(Checksum, godot::Object)
 
 		// BEGIN BOILERPLATE
-		inline static Checksum* _checksum = nullptr;
+		static inline Checksum* _checksum = nullptr;
 
 	protected:
 		static void _bind_methods() {
@@ -15,7 +15,7 @@ namespace OpenVic {
 		}
 
 	public:
-		inline static Checksum* get_singleton() {
+		static inline Checksum* get_singleton() {
 			return _checksum;
 		}
 
diff --git a/extension/src/openvic-extension/GameSingleton.cpp b/extension/src/openvic-extension/GameSingleton.cpp
index 877fb4a..311b602 100644
--- a/extension/src/openvic-extension/GameSingleton.cpp
+++ b/extension/src/openvic-extension/GameSingleton.cpp
@@ -10,9 +10,9 @@
 using namespace godot;
 using namespace OpenVic;
 
+using OpenVic::Utilities::godot_to_std_string;
 using OpenVic::Utilities::std_to_godot_string;
 using OpenVic::Utilities::std_view_to_godot_string;
-using OpenVic::Utilities::godot_to_std_string;
 
 GameSingleton* GameSingleton::singleton = nullptr;
 
@@ -22,7 +22,9 @@ GameSingleton* GameSingleton::singleton = nullptr;
 void GameSingleton::_bind_methods() {
 	BSM("GameSingleton", D_METHOD("setup_logger"), &GameSingleton::setup_logger);
 	BM(D_METHOD("load_defines_compatibility_mode", "file_paths"), &GameSingleton::load_defines_compatibility_mode);
-	BSM("GameSingleton", D_METHOD("search_for_game_path", "hint_path"), &GameSingleton::search_for_game_path, DEFVAL(String{}));
+	BSM(
+		"GameSingleton", D_METHOD("search_for_game_path", "hint_path"), &GameSingleton::search_for_game_path, DEFVAL(String {})
+	);
 	BM(D_METHOD("lookup_file", "path"), &GameSingleton::lookup_file);
 	BM(D_METHOD("setup_game"), &GameSingleton::setup_game);
 
@@ -61,42 +63,56 @@ void GameSingleton::_bind_methods() {
 	BSM("GameSingleton", D_METHOD("get_province_info_region_key"), &GameSingleton::get_province_info_region_key);
 	BSM("GameSingleton", D_METHOD("get_province_info_life_rating_key"), &GameSingleton::get_province_info_life_rating_key);
 	BSM("GameSingleton", D_METHOD("get_province_info_terrain_type_key"), &GameSingleton::get_province_info_terrain_type_key);
-	BSM("GameSingleton", D_METHOD("get_province_info_total_population_key"),
-		&GameSingleton::get_province_info_total_population_key);
+	BSM(
+		"GameSingleton", D_METHOD("get_province_info_total_population_key"),
+		&GameSingleton::get_province_info_total_population_key
+	);
 	BSM("GameSingleton", D_METHOD("get_province_info_pop_types_key"), &GameSingleton::get_province_info_pop_types_key);
-	BSM("GameSingleton", D_METHOD("get_province_info_pop_ideologies_key"), &GameSingleton::get_province_info_pop_ideologies_key);
+	BSM(
+		"GameSingleton", D_METHOD("get_province_info_pop_ideologies_key"),
+		&GameSingleton::get_province_info_pop_ideologies_key
+	);
 	BSM("GameSingleton", D_METHOD("get_province_info_pop_cultures_key"), &GameSingleton::get_province_info_pop_cultures_key);
 	BSM("GameSingleton", D_METHOD("get_province_info_rgo_key"), &GameSingleton::get_province_info_rgo_key);
 	BSM("GameSingleton", D_METHOD("get_province_info_buildings_key"), &GameSingleton::get_province_info_buildings_key);
 
 	BSM("GameSingleton", D_METHOD("get_building_info_building_key"), &GameSingleton::get_building_info_building_key);
 	BSM("GameSingleton", D_METHOD("get_building_info_level_key"), &GameSingleton::get_building_info_level_key);
-	BSM("GameSingleton", D_METHOD("get_building_info_expansion_state_key"), &GameSingleton::get_building_info_expansion_state_key);
+	BSM(
+		"GameSingleton", D_METHOD("get_building_info_expansion_state_key"),
+		&GameSingleton::get_building_info_expansion_state_key
+	);
 	BSM("GameSingleton", D_METHOD("get_building_info_start_date_key"), &GameSingleton::get_building_info_start_date_key);
 	BSM("GameSingleton", D_METHOD("get_building_info_end_date_key"), &GameSingleton::get_building_info_end_date_key);
-	BSM("GameSingleton", D_METHOD("get_building_info_expansion_progress_key"),
-		&GameSingleton::get_building_info_expansion_progress_key);
+	BSM(
+		"GameSingleton", D_METHOD("get_building_info_expansion_progress_key"),
+		&GameSingleton::get_building_info_expansion_progress_key
+	);
 
 	BSM("GameSingleton", D_METHOD("get_piechart_info_size_key"), &GameSingleton::get_piechart_info_size_key);
 	BSM("GameSingleton", D_METHOD("get_piechart_info_colour_key"), &GameSingleton::get_piechart_info_colour_key);
 
-	BSM("GameSingleton", D_METHOD("draw_pie_chart", "image", "stopAngles", "colours", "radius",
-		"shadow_displacement", "shadow_tightness", "shadow_radius", "shadow_thickness",
-		"trim_colour", "trim_size", "gradient_falloff", "gradient_base",
-		"donut", "donut_inner_trim", "donut_inner_radius"), &GameSingleton::draw_pie_chart);
+	BSM(
+		"GameSingleton",
+		D_METHOD(
+			"draw_pie_chart", "image", "stopAngles", "colours", "radius", "shadow_displacement", "shadow_tightness",
+			"shadow_radius", "shadow_thickness", "trim_colour", "trim_size", "gradient_falloff", "gradient_base", "donut",
+			"donut_inner_trim", "donut_inner_radius"
+		),
+		&GameSingleton::draw_pie_chart
+	);
 	BSM("GameSingleton", D_METHOD("load_image", "path"), &GameSingleton::load_image);
 }
 
-void GameSingleton::draw_pie_chart(Ref<Image> image,
-	Array const& stopAngles, Array const& colours, float radius,
-	Vector2 shadow_displacement, float shadow_tightness, float shadow_radius, float shadow_thickness,
-	Color trim_colour, float trim_size, float gradient_falloff, float gradient_base,
-	bool donut, bool donut_inner_trim, float donut_inner_radius) {
-
-	Utilities::draw_pie_chart(image, stopAngles, colours, radius, shadow_displacement,
-		shadow_tightness, shadow_radius, shadow_thickness,
-		trim_colour, trim_size, gradient_falloff, gradient_base,
-		donut, donut_inner_trim, donut_inner_radius);
+void GameSingleton::draw_pie_chart(
+	Ref<Image> image, Array const& stopAngles, Array const& colours, float radius, Vector2 shadow_displacement,
+	float shadow_tightness, float shadow_radius, float shadow_thickness, Color trim_colour, float trim_size,
+	float gradient_falloff, float gradient_base, bool donut, bool donut_inner_trim, float donut_inner_radius
+) {
+	Utilities::draw_pie_chart(
+		image, stopAngles, colours, radius, shadow_displacement, shadow_tightness, shadow_radius, shadow_thickness,
+		trim_colour, trim_size, gradient_falloff, gradient_base, donut, donut_inner_trim, donut_inner_radius
+	);
 }
 
 Ref<Image> GameSingleton::load_image(String const& path) {
@@ -115,10 +131,8 @@ void GameSingleton::_on_state_updated() {
 /* REQUIREMENTS:
  * MAP-21, MAP-23, MAP-25, MAP-32, MAP-33, MAP-34
  */
-GameSingleton::GameSingleton() : game_manager {
-	[this]() {
-		_on_state_updated();
-	} } {
+GameSingleton::GameSingleton()
+	: game_manager { std::bind(&GameSingleton::_on_state_updated, this) } {
 	ERR_FAIL_COND(singleton != nullptr);
 	singleton = this;
 }
@@ -227,20 +241,27 @@ StringName const& GameSingleton::get_piechart_info_colour_key() {
 	return key;
 }
 
-Dictionary GameSingleton::_distribution_to_dictionary(distribution_t const& dist) const {
+template<std::derived_from<HasIdentifierAndColour> T>
+static Dictionary _distribution_to_dictionary(decimal_map_t<T const*> const& dist) {
 	Dictionary dict;
-	for (distribution_t::value_type const& p : dist) {
-		Dictionary sub_dict;
-		sub_dict[get_piechart_info_size_key()] = p.second.to_float();
-		sub_dict[get_piechart_info_colour_key()] = Utilities::to_godot_color(p.first->get_colour());
-		dict[std_view_to_godot_string(p.first->get_identifier())] = sub_dict;
+	for (auto const& [key, val] : dist) {
+		if (key != nullptr) {
+			Dictionary sub_dict;
+			sub_dict[GameSingleton::get_piechart_info_size_key()] = val.to_float();
+			sub_dict[GameSingleton::get_piechart_info_colour_key()] = Utilities::to_godot_color(key->get_colour());
+			dict[std_view_to_godot_string(key->get_identifier())] = std::move(sub_dict);
+		} else {
+			UtilityFunctions::push_error("Null distribution key with value ", val.to_float());
+		}
 	}
 	return dict;
 }
 
 Dictionary GameSingleton::get_province_info_from_index(int32_t index) const {
 	Province const* province = game_manager.get_map().get_province_by_index(index);
-	if (province == nullptr) return {};
+	if (province == nullptr) {
+		return {};
+	}
 	Dictionary ret;
 
 	ret[get_province_info_province_key()] = std_view_to_godot_string(province->get_identifier());
@@ -263,13 +284,15 @@ Dictionary GameSingleton::get_province_info_from_index(int32_t index) const {
 	}
 
 	ret[get_province_info_total_population_key()] = province->get_total_population();
-	distribution_t const& pop_types = province->get_pop_type_distribution();
+	decimal_map_t<PopType const*> const& pop_types = province->get_pop_type_distribution();
 	if (!pop_types.empty()) {
 		ret[get_province_info_pop_types_key()] = _distribution_to_dictionary(pop_types);
 	}
-	//distribution_t const& ideologies = province->get_ideology_distribution();
-	//if (!ideologies.empty()) ret[get_province_info_pop_ideologies_key()] = _distribution_to_dictionary(ideologies);
-	distribution_t const& cultures = province->get_culture_distribution();
+	decimal_map_t<Ideology const*> const& ideologies = province->get_ideology_distribution();
+	if (!ideologies.empty()) {
+		ret[get_province_info_pop_ideologies_key()] = _distribution_to_dictionary(ideologies);
+	}
+	decimal_map_t<Culture const*> const& cultures = province->get_culture_distribution();
 	if (!cultures.empty()) {
 		ret[get_province_info_pop_cultures_key()] = _distribution_to_dictionary(cultures);
 	}
@@ -326,7 +349,8 @@ Ref<Texture> GameSingleton::get_province_colour_texture() const {
 
 Error GameSingleton::_update_colour_image() {
 	static PackedByteArray colour_data_array;
-	static constexpr int64_t colour_data_array_size = (static_cast<int64_t>(Province::MAX_INDEX) + 1) * Map::MAPMODE_COLOUR_SIZE;
+	static constexpr int64_t colour_data_array_size =
+		(static_cast<int64_t>(Province::MAX_INDEX) + 1) * Map::MAPMODE_COLOUR_SIZE;
 	colour_data_array.resize(colour_data_array_size);
 
 	Error err = OK;
@@ -337,15 +361,12 @@ Error GameSingleton::_update_colour_image() {
 	static constexpr int32_t PROVINCE_INDEX_SQRT = 1 << (sizeof(Province::index_t) * 4);
 	if (province_colour_image.is_null()) {
 		province_colour_image.instantiate();
-		ERR_FAIL_NULL_V_EDMSG(province_colour_image, FAILED,
-			"Failed to create province colour image");
+		ERR_FAIL_NULL_V_EDMSG(province_colour_image, FAILED, "Failed to create province colour image");
 	}
-	province_colour_image->set_data(PROVINCE_INDEX_SQRT, PROVINCE_INDEX_SQRT,
-		false, Image::FORMAT_RGBA8, colour_data_array);
+	province_colour_image->set_data(PROVINCE_INDEX_SQRT, PROVINCE_INDEX_SQRT, false, Image::FORMAT_RGBA8, colour_data_array);
 	if (province_colour_texture.is_null()) {
 		province_colour_texture = ImageTexture::create_from_image(province_colour_image);
-		ERR_FAIL_NULL_V_EDMSG(province_colour_texture, FAILED,
-			"Failed to create province colour texture");
+		ERR_FAIL_NULL_V_EDMSG(province_colour_texture, FAILED, "Failed to create province colour texture");
 	} else {
 		province_colour_texture->update(province_colour_image);
 	}
@@ -439,13 +460,18 @@ Error GameSingleton::_load_map_images(bool flip_vertical) {
 
 	const Vector2i province_dims {
 		static_cast<int32_t>(game_manager.get_map().get_width()),
-		static_cast<int32_t>(game_manager.get_map().get_height()) };
+		static_cast<int32_t>(game_manager.get_map().get_height())
+	};
 
 	static constexpr int32_t GPU_DIM_LIMIT = 0x3FFF;
-	// For each dimension of the image, this finds the small number of equal subdivisions required get the individual texture dims under GPU_DIM_LIMIT
-	for (int i = 0; i < 2; ++i)
-		for (image_subdivisions[i] = 1; province_dims[i] / image_subdivisions[i] > GPU_DIM_LIMIT ||
-			province_dims[i] % image_subdivisions[i] != 0; ++image_subdivisions[i]);
+	// For each dimension of the image, this finds the small number of equal subdivisions
+	// required get the individual texture dims under GPU_DIM_LIMIT
+	for (int i = 0; i < 2; ++i) {
+		image_subdivisions[i] = 1;
+		while (province_dims[i] / image_subdivisions[i] > GPU_DIM_LIMIT || province_dims[i] % image_subdivisions[i] != 0) {
+			++image_subdivisions[i];
+		}
+	}
 
 	Map::shape_pixel_t const* province_shape_data = game_manager.get_map().get_province_shape_image().data();
 	const Vector2i divided_dims = province_dims / image_subdivisions;
@@ -456,14 +482,16 @@ Error GameSingleton::_load_map_images(bool flip_vertical) {
 			PackedByteArray index_data_array;
 			index_data_array.resize(divided_dims.x * divided_dims.y * sizeof(Map::shape_pixel_t));
 
-			for (int32_t y = 0; y < divided_dims.y; ++y)
-				memcpy(index_data_array.ptrw() + y * divided_dims.x * sizeof(Map::shape_pixel_t),
+			for (int32_t y = 0; y < divided_dims.y; ++y) {
+				memcpy(
+					index_data_array.ptrw() + y * divided_dims.x * sizeof(Map::shape_pixel_t),
 					province_shape_data + (v * divided_dims.y + y) * province_dims.x + u * divided_dims.x,
-					divided_dims.x * sizeof(Map::shape_pixel_t));
+					divided_dims.x * sizeof(Map::shape_pixel_t)
+				);
+			}
 
-			const Ref<Image> province_shape_subimage = Image::create_from_data(
-				divided_dims.x, divided_dims.y,
-				false, Image::FORMAT_RGB8, index_data_array);
+			const Ref<Image> province_shape_subimage =
+				Image::create_from_data(divided_dims.x, divided_dims.y, false, Image::FORMAT_RGB8, index_data_array);
 			if (province_shape_subimage.is_null()) {
 				UtilityFunctions::push_error("Failed to create province shape image (", u, ", ", v, ")");
 				err = FAILED;
@@ -497,8 +525,10 @@ Error GameSingleton::_load_terrain_variants_compatibility_mode(String const& ter
 	terrain_sheet->flip_y();
 	const int32_t sheet_width = terrain_sheet->get_width(), sheet_height = terrain_sheet->get_height();
 	if (sheet_width < 1 || sheet_width % SHEET_DIMS != 0 || sheet_width != sheet_height) {
-		UtilityFunctions::push_error("Invalid terrain texture sheet dims: ", sheet_width, "x", sheet_height,
-			" (must be square with dims positive multiples of ", SHEET_DIMS, ")");
+		UtilityFunctions::push_error(
+			"Invalid terrain texture sheet dims: ", sheet_width, "x", sheet_height,
+			" (must be square with dims positive multiples of ", SHEET_DIMS, ")"
+		);
 		return FAILED;
 	}
 	const int32_t slice_size = sheet_width / SHEET_DIMS;
@@ -516,7 +546,9 @@ Error GameSingleton::_load_terrain_variants_compatibility_mode(String const& ter
 		const Rect2i slice { (idx % SHEET_DIMS) * slice_size, (7 - (idx / SHEET_DIMS)) * slice_size, slice_size, slice_size };
 		const Ref<Image> terrain_image = terrain_sheet->get_region(slice);
 		if (terrain_image.is_null() || terrain_image->is_empty()) {
-			UtilityFunctions::push_error("Failed to extract terrain texture slice ", slice, " from ", terrain_texturesheet_path);
+			UtilityFunctions::push_error(
+				"Failed to extract terrain texture slice ", slice, " from ", terrain_texturesheet_path
+			);
 			err = FAILED;
 		}
 		terrain_images.append(terrain_image);
@@ -531,7 +563,7 @@ Error GameSingleton::_load_terrain_variants_compatibility_mode(String const& ter
 }
 
 Error GameSingleton::load_defines_compatibility_mode(PackedStringArray const& file_paths) {
-	static const fs::path terrain_texture_file = "map/terrain/texturesheet.tga";
+	static constexpr std::string_view terrain_texture_file = "map/terrain/texturesheet.tga";
 
 	Dataloader::path_vector_t roots;
 	for (String const& path : file_paths) {
diff --git a/extension/src/openvic-extension/GameSingleton.hpp b/extension/src/openvic-extension/GameSingleton.hpp
index 8145a39..1d92ef0 100644
--- a/extension/src/openvic-extension/GameSingleton.hpp
+++ b/extension/src/openvic-extension/GameSingleton.hpp
@@ -33,17 +33,16 @@ namespace OpenVic {
 		godot::Error _update_colour_image();
 		void _on_state_updated();
 
-		godot::Dictionary _distribution_to_dictionary(distribution_t const& dist) const;
-
 	protected:
 		static void _bind_methods();
 
 	public:
-		static void draw_pie_chart(godot::Ref<godot::Image> image,
-			godot::Array const& stopAngles, godot::Array const& colours, float radius,
+		static void draw_pie_chart(
+			godot::Ref<godot::Image> image, godot::Array const& stopAngles, godot::Array const& colours, float radius,
 			godot::Vector2 shadow_displacement, float shadow_tightness, float shadow_radius, float shadow_thickness,
-			godot::Color trim_colour, float trim_size, float gradient_falloff, float gradient_base,
-			bool donut, bool donut_inner_trim, float donut_inner_radius);
+			godot::Color trim_colour, float trim_size, float gradient_falloff, float gradient_base, bool donut,
+			bool donut_inner_trim, float donut_inner_radius
+		);
 
 		static godot::Ref<godot::Image> load_image(godot::String const& path);
 
diff --git a/extension/src/openvic-extension/LoadLocalisation.cpp b/extension/src/openvic-extension/LoadLocalisation.cpp
index 6ed92fd..ee90633 100644
--- a/extension/src/openvic-extension/LoadLocalisation.cpp
+++ b/extension/src/openvic-extension/LoadLocalisation.cpp
@@ -32,7 +32,7 @@ LoadLocalisation::~LoadLocalisation() {
 	singleton = nullptr;
 }
 
-Error LoadLocalisation::_load_file_into_translation(String const& file_path, Ref<Translation> translation) const {
+Error LoadLocalisation::_load_file(String const& file_path, Ref<Translation> translation) const {
 	const Ref<FileAccess> file = FileAccess::open(file_path, FileAccess::ModeFlags::READ);
 	Error err = FileAccess::get_open_error();
 	if (err != OK || file.is_null()) {
@@ -46,10 +46,14 @@ Error LoadLocalisation::_load_file_into_translation(String const& file_path, Ref
 		line_number++;
 		if (line.size() < 2 || line[0].is_empty() || line[1].is_empty()) {
 			if (!line[0].is_empty()) {
-				UtilityFunctions::push_warning("Key \"", line[0], "\" missing value on line ", line_number, " in file: ", file_path);
+				UtilityFunctions::push_warning(
+					"Key \"", line[0], "\" missing value on line ", line_number, " in file: ", file_path
+				);
 				err = FAILED;
 			} else if (line.size() >= 2 && !line[1].is_empty()) {
-				UtilityFunctions::push_warning("Value \"", line[1], "\" missing key on line ", line_number, " in file: ", file_path);
+				UtilityFunctions::push_warning(
+					"Value \"", line[1], "\" missing key on line ", line_number, " in file: ", file_path
+				);
 				err = FAILED;
 			}
 			continue;
@@ -75,7 +79,7 @@ Ref<Translation> LoadLocalisation::_get_translation(String const& locale) const
 }
 
 Error LoadLocalisation::load_file(String const& file_path, String const& locale) const {
-	return _load_file_into_translation(file_path, _get_translation(locale));
+	return _load_file(file_path, _get_translation(locale));
 }
 
 /* REQUIREMENTS
@@ -101,7 +105,7 @@ Error LoadLocalisation::load_locale_dir(String const& dir_path, String const& lo
 	Error err = OK;
 	for (String const& file_name : files) {
 		if (file_name.get_extension().to_lower() == "csv") {
-			if (_load_file_into_translation(dir_path.path_join(file_name), translation) != OK) {
+			if (_load_file(dir_path.path_join(file_name), translation) != OK) {
 				err = FAILED;
 			}
 		}
@@ -153,8 +157,10 @@ bool LoadLocalisation::add_message(std::string_view key, Dataloader::locale_t lo
 	if (0) {
 		const StringName old_localisation = translation->get_message(godot_key);
 		if (!old_localisation.is_empty()) {
-			UtilityFunctions::push_warning("Changing translation ", godot_key, " (", Dataloader::locale_names[locale], ") from \"",
-				old_localisation, "\" to \"", godot_localisation, "\"");
+			UtilityFunctions::push_warning(
+				"Changing translation ", godot_key, " (", Dataloader::locale_names[locale], ") from \"",
+				old_localisation, "\" to \"", godot_localisation, "\""
+			);
 		}
 	}
 	translation->add_message(godot_key, godot_localisation);
diff --git a/extension/src/openvic-extension/LoadLocalisation.hpp b/extension/src/openvic-extension/LoadLocalisation.hpp
index 4f09ef3..8f6423e 100644
--- a/extension/src/openvic-extension/LoadLocalisation.hpp
+++ b/extension/src/openvic-extension/LoadLocalisation.hpp
@@ -11,7 +11,7 @@ namespace OpenVic {
 
 		static LoadLocalisation* singleton;
 
-		godot::Error _load_file_into_translation(godot::String const& file_path, godot::Ref<godot::Translation> translation) const;
+		godot::Error _load_file(godot::String const& file_path, godot::Ref<godot::Translation> translation) const;
 		godot::Ref<godot::Translation> _get_translation(godot::String const& locale) const;
 
 	protected:
diff --git a/extension/src/openvic-extension/MapMesh.cpp b/extension/src/openvic-extension/MapMesh.cpp
index 39cee41..e407391 100644
--- a/extension/src/openvic-extension/MapMesh.cpp
+++ b/extension/src/openvic-extension/MapMesh.cpp
@@ -21,14 +21,21 @@ void MapMesh::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_core_aabb"), &MapMesh::get_core_aabb);
 	ClassDB::bind_method(D_METHOD("is_valid_uv_coord"), &MapMesh::is_valid_uv_coord);
 
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "aspect_ratio", PROPERTY_HINT_NONE, "suffix:m"),
-		"set_aspect_ratio", "get_aspect_ratio");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "repeat_proportion", PROPERTY_HINT_NONE, "suffix:m"),
-		"set_repeat_proportion", "get_repeat_proportion");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1,or_greater"),
-		"set_subdivide_width", "get_subdivide_width");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1,or_greater"),
-		"set_subdivide_depth", "get_subdivide_depth");
+	ADD_PROPERTY(
+		PropertyInfo(Variant::FLOAT, "aspect_ratio", PROPERTY_HINT_NONE, "suffix:m"), "set_aspect_ratio", "get_aspect_ratio"
+	);
+	ADD_PROPERTY(
+		PropertyInfo(Variant::FLOAT, "repeat_proportion", PROPERTY_HINT_NONE, "suffix:m"), "set_repeat_proportion",
+		"get_repeat_proportion"
+	);
+	ADD_PROPERTY(
+		PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1,or_greater"), "set_subdivide_width",
+		"get_subdivide_width"
+	);
+	ADD_PROPERTY(
+		PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1,or_greater"), "set_subdivide_depth",
+		"get_subdivide_depth"
+	);
 }
 
 void MapMesh::_request_update() {
diff --git a/extension/src/openvic-extension/Utilities.cpp b/extension/src/openvic-extension/Utilities.cpp
index 87f0422..520f78e 100644
--- a/extension/src/openvic-extension/Utilities.cpp
+++ b/extension/src/openvic-extension/Utilities.cpp
@@ -75,10 +75,11 @@ static inline float parabola_shadow(float base, float x) {
 	return base * x * x;
 }
 
-static Color pie_chart_fragment(Vector2 UV, float radius, Array const& stopAngles, Array const& colours,
-	Vector2 shadow_displacement, float shadow_tightness, float shadow_radius, float shadow_thickness,
-	Color trim_colour, float trim_size, float gradient_falloff, float gradient_base,
-	bool donut, bool donut_inner_trim, float donut_inner_radius) {
+static Color pie_chart_fragment(
+	Vector2 UV, float radius, Array const& stopAngles, Array const& colours, Vector2 shadow_displacement,
+	float shadow_tightness, float shadow_radius, float shadow_thickness, Color trim_colour, float trim_size,
+	float gradient_falloff, float gradient_base, bool donut, bool donut_inner_trim, float donut_inner_radius
+) {
 
 	Vector2 coords = getPolar(UV, { 0.5, 0.5 });
 	float dist = coords.x;
@@ -86,8 +87,8 @@ static Color pie_chart_fragment(Vector2 UV, float radius, Array const& stopAngle
 
 	Vector2 shadow_polar = getPolar(UV, shadow_displacement);
 	float shadow_peak = radius + (radius - donut_inner_radius) / 2.0;
-	float shadow_gradient = shadow_thickness + parabola_shadow(shadow_tightness * -10.0,
-		shadow_polar.x + shadow_peak - shadow_radius);
+	float shadow_gradient =
+		shadow_thickness + parabola_shadow(shadow_tightness * -10.0, shadow_polar.x + shadow_peak - shadow_radius);
 
 	// Inner hole of the donut => make it transparent
 	if (donut && dist <= donut_inner_radius) {
@@ -119,11 +120,11 @@ static Color pie_chart_fragment(Vector2 UV, float radius, Array const& stopAngle
 	}
 }
 
-void Utilities::draw_pie_chart(Ref<Image> image,
-	Array const& stopAngles, Array const& colours, float radius,
-	Vector2 shadow_displacement, float shadow_tightness, float shadow_radius, float shadow_thickness,
-	Color trim_colour, float trim_size, float gradient_falloff, float gradient_base,
-	bool donut, bool donut_inner_trim, float donut_inner_radius) {
+void Utilities::draw_pie_chart(
+	Ref<Image> image, Array const& stopAngles, Array const& colours, float radius, Vector2 shadow_displacement,
+	float shadow_tightness, float shadow_radius, float shadow_thickness, Color trim_colour, float trim_size,
+	float gradient_falloff, float gradient_base, bool donut, bool donut_inner_trim, float donut_inner_radius
+) {
 
 	ERR_FAIL_NULL_EDMSG(image, "Cannot draw pie chart to null image.");
 	const int32_t width = image->get_width();
@@ -135,12 +136,14 @@ void Utilities::draw_pie_chart(Ref<Image> image,
 	const int32_t size = std::min(width, height);
 	for (int32_t y = 0; y < size; ++y) {
 		for (int32_t x = 0; x < size; ++x) {
-			image->set_pixel(x, y, pie_chart_fragment(
-				Vector2 { static_cast<float>(x), static_cast<float>(y) } / size,
-				radius, stopAngles, colours,
-				shadow_displacement, shadow_tightness, shadow_radius, shadow_thickness,
-				trim_colour, trim_size, gradient_falloff, gradient_base,
-				donut, donut_inner_trim, donut_inner_radius));
+			image->set_pixel(
+				x, y,
+				pie_chart_fragment(
+					Vector2 { static_cast<float>(x), static_cast<float>(y) } / size, radius, stopAngles, colours,
+					shadow_displacement, shadow_tightness, shadow_radius, shadow_thickness, trim_colour, trim_size,
+					gradient_falloff, gradient_base, donut, donut_inner_trim, donut_inner_radius
+				)
+			);
 		}
 	}
 }
diff --git a/extension/src/openvic-extension/Utilities.hpp b/extension/src/openvic-extension/Utilities.hpp
index 68e72d2..f789f84 100644
--- a/extension/src/openvic-extension/Utilities.hpp
+++ b/extension/src/openvic-extension/Utilities.hpp
@@ -22,7 +22,11 @@ namespace OpenVic::Utilities {
 	}
 
 	inline godot::Color to_godot_color(colour_t colour) {
-		return { colour_byte_to_float((colour >> 16) & 0xFF), colour_byte_to_float((colour >> 8) & 0xFF), colour_byte_to_float(colour & 0xFF) };
+		return {
+			colour_byte_to_float((colour >> 16) & 0xFF),
+			colour_byte_to_float((colour >> 8) & 0xFF),
+			colour_byte_to_float(colour & 0xFF)
+		};
 	}
 
 	inline godot::Vector2i to_godot_ivec2(ivec2_t vec) {
@@ -31,9 +35,10 @@ namespace OpenVic::Utilities {
 
 	godot::Ref<godot::Image> load_godot_image(godot::String const& path);
 
-	void draw_pie_chart(godot::Ref<godot::Image> image,
-		godot::Array const& stopAngles, godot::Array const& colours, float radius,
+	void draw_pie_chart(
+		godot::Ref<godot::Image> image, godot::Array const& stopAngles, godot::Array const& colours, float radius,
 		godot::Vector2 shadow_displacement, float shadow_tightness, float shadow_radius, float shadow_thickness,
-		godot::Color trim_colour, float trim_size, float gradient_falloff, float gradient_base,
-		bool donut, bool donut_inner_trim, float donut_inner_radius);
+		godot::Color trim_colour, float trim_size, float gradient_falloff, float gradient_base, bool donut,
+		bool donut_inner_trim, float donut_inner_radius
+	);
 }
diff --git a/extension/src/openvic-extension/register_types.cpp b/extension/src/openvic-extension/register_types.cpp
index c954de1..2739e2e 100644
--- a/extension/src/openvic-extension/register_types.cpp
+++ b/extension/src/openvic-extension/register_types.cpp
@@ -51,8 +51,10 @@ void uninitialize_openvic_types(ModuleInitializationLevel p_level) {
 
 extern "C" {
 	// Initialization.
-	GDExtensionBool GDE_EXPORT openvic_library_init(GDExtensionInterfaceGetProcAddress p_get_proc_address,
-		GDExtensionClassLibraryPtr p_library, GDExtensionInitialization* r_initialization) {
+	GDExtensionBool GDE_EXPORT openvic_library_init(
+		GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library,
+		GDExtensionInitialization* r_initialization
+	) {
 		GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);
 
 		init_obj.register_initializer(initialize_openvic_types);