Clang-format formatting (with manual cleanup)

.clang-format

@@ -5,7 +5,9 @@ Standard: c++20
 UseTab: Always
 TabWidth: 4
 IndentWidth: 4
-ColumnLimit: 0
+ColumnLimit: 128
+PointerAlignment: Left
+DerivePointerAlignment: false
 SpacesInSquareBrackets: false
 SpacesInParentheses: false
 SpacesInCStyleCastParentheses: false
@@ -14,6 +16,7 @@ SpacesInConditionalStatement: false
 SpacesInAngles: false
 SpaceInEmptyParentheses: false
 SpaceInEmptyBlock: false
+SpacesInParens: Never
 SpaceBeforeSquareBrackets: false
 SpaceBeforeRangeBasedForLoopColon: true
 SpaceBeforeParens: ControlStatements
@@ -23,13 +26,14 @@ SpaceBeforeCpp11BracedList: true
 SpaceBeforeAssignmentOperators: true
 SpaceAfterTemplateKeyword: false
 SpaceAfterLogicalNot: false
-PointerAlignment: Left
 PackConstructorInitializers: BinPack
 NamespaceIndentation: All
-LambdaBodyIndentation: Signature
+#LambdaBodyIndentation: Signature
 IndentExternBlock: Indent
-IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentCaseLabels: false
 IndentAccessModifiers: false
+IndentRequiresClause: false
 IncludeBlocks: Regroup
 FixNamespaceComments: false
 EmptyLineBeforeAccessModifier: LogicalBlock
@@ -38,17 +42,35 @@ CompactNamespaces: false
 BreakConstructorInitializers: BeforeColon
 BreakBeforeBraces: Attach
 AlwaysBreakTemplateDeclarations: Yes
-AllowShortLambdasOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AlwaysBreakAfterReturnType: None
+PenaltyReturnTypeOnItsOwnLine: 10
+BreakBeforeConceptDeclarations: Always
+AllowShortLambdasOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
 AllowShortEnumsOnASingleLine: true
 AllowShortCaseLabelsOnASingleLine: true
-AlignTrailingComments: true
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLoopsOnASingleLine: false
+AlignTrailingComments:
+  Kind: Never
+  OverEmptyLines: 0
 AlignEscapedNewlines: DontAlign
 AlignAfterOpenBracket: BlockIndent
+AlignOperands: DontAlign
+AlignConsecutiveShortCaseStatements:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: true
+  AlignCaseColons: false
 BinPackArguments: true
 BinPackParameters: true
-IndentRequiresClause: false
 AccessModifierOffset: -4
+InsertNewlineAtEOF: true
+InsertBraces: true
+MaxEmptyLinesToKeep: 2
+RequiresClausePosition: OwnLine
 IncludeCategories:
   - Regex: <[[:alnum:]_]+>
     Priority: 1

clang-format.sh

@@ -0,0 +1,13 @@
+#/usr/bin/env bash
+
+echo "\n\nFormatting openvic-extension with clang-format:\n"
+find ./extension/src/ -iname *.hpp -o -iname *.cpp | xargs clang-format --verbose -i
+
+if [ -d ./extension/deps/openvic-simulation ]; then
+    cd ./extension/deps/openvic-simulation
+    if [ -f ./clang-format.sh ]; then
+        ./clang-format.sh
+    fi
+fi
+
+exit 0

extension/src/openvic-extension/Checksum.hpp

@@ -7,15 +7,15 @@ namespace OpenVic {
 		GDCLASS(Checksum, godot::Object)
 
 		// BEGIN BOILERPLATE
-		inline static Checksum* _checksum = nullptr;
+		static inline Checksum* _checksum = nullptr;
 
 	protected:
 		static void _bind_methods() {
 			godot::ClassDB::bind_method(godot::D_METHOD("get_checksum_text"), &Checksum::get_checksum_text);
 		}
 
 	public:
-		inline static Checksum* get_singleton() {
+		static inline Checksum* get_singleton() {
 			return _checksum;
 		}
 

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) {