apply format

app/core/game_engine.cpp

@@ -1051,9 +1051,9 @@ auto GameEngine::availableNations() const -> QVariantList {
   ordered.reserve(static_cast<int>(all.size()));
   for (const auto &nation : all) {
     QVariantMap entry;
-    entry.insert(QStringLiteral("id"),
-                 QString::fromStdString(
-                     Game::Systems::nationIDToString(nation.id)));
+    entry.insert(
+        QStringLiteral("id"),
+        QString::fromStdString(Game::Systems::nationIDToString(nation.id)));
     entry.insert(QStringLiteral("name"),
                  QString::fromStdString(nation.displayName));
     ordered.append(entry);

game/map/skirmish_loader.cpp

@@ -187,7 +187,8 @@ auto SkirmishLoader::start(const QString &map_path,
 
         Game::Systems::NationID chosen_nation;
         if (!nation_id_str.isEmpty()) {
-          auto parsed = Game::Systems::nationIDFromString(nation_id_str.toStdString());
+          auto parsed =
+              Game::Systems::nationIDFromString(nation_id_str.toStdString());
           chosen_nation = parsed.value_or(
               Game::Systems::NationRegistry::instance().default_nation_id());
         } else {

game/systems/nation_id.h

@@ -8,8 +8,6 @@
 
 namespace Game::Systems {
 
-// Nation identifiers for all playable factions
-// Each nation has unique troop variants and characteristics defined in JSON
 enum class NationID : std::uint8_t { KingdomOfIron, RomanRepublic, Carthage };
 
 inline auto nationIDToQString(NationID id) -> QString {
@@ -21,8 +19,7 @@ inline auto nationIDToQString(NationID id) -> QString {
   case NationID::Carthage:
     return QStringLiteral("carthage");
   }
-  // Default fallback - should never reach here with valid enum
-  // KingdomOfIron is the default nation used throughout the game
+
   return QStringLiteral("kingdom_of_iron");
 }
 
@@ -47,7 +44,8 @@ inline auto tryParseNationID(const QString &value, NationID &out) -> bool {
   return false;
 }
 
-inline auto nationIDFromString(const std::string &str) -> std::optional<NationID> {
+inline auto
+nationIDFromString(const std::string &str) -> std::optional<NationID> {
   NationID result;
   if (tryParseNationID(QString::fromStdString(str), result)) {
     return result;

game/systems/nation_loader.cpp

@@ -344,13 +344,15 @@ auto NationLoader::load_from_file(const QString &path)
   }
   nation.id = *parsed_id;
 
-  nation.displayName = root.value("display_name").toString(id_str).toStdString();
+  nation.displayName =
+      root.value("display_name").toString(id_str).toStdString();
 
   const QString building_str =
       root.value("primary_building").toString(QStringLiteral("barracks"));
   auto parsed_building =
       Game::Units::buildingTypeFromString(building_str.toStdString());
-  nation.primaryBuilding = parsed_building.value_or(Game::Units::BuildingType::Barracks);
+  nation.primaryBuilding =
+      parsed_building.value_or(Game::Units::BuildingType::Barracks);
   if (auto formation =
           parse_formation_type(root.value("formation_type").toString())) {
     nation.formation_type = *formation;

game/systems/nation_registry.h

@@ -49,7 +49,8 @@ struct Nation {
   NationID id;
   std::string displayName;
   std::vector<TroopType> availableTroops;
-  Game::Units::BuildingType primaryBuilding = Game::Units::BuildingType::Barracks;
+  Game::Units::BuildingType primaryBuilding =
+      Game::Units::BuildingType::Barracks;
   FormationType formation_type = FormationType::Roman;
   std::unordered_map<Game::Units::TroopType, NationTroopVariant> troopVariants;
 

game/systems/troop_profile_service.cpp

@@ -12,9 +12,8 @@ auto TroopProfileService::instance() -> TroopProfileService & {
 
 void TroopProfileService::clear() { m_cache.clear(); }
 
-auto TroopProfileService::get_profile(NationID nation_id,
-                                      Game::Units::TroopType type)
-    -> TroopProfile {
+auto TroopProfileService::get_profile(
+    NationID nation_id, Game::Units::TroopType type) -> TroopProfile {
   auto &nationCache = m_cache[nation_id];
   auto cached = nationCache.find(type);
   if (cached != nationCache.end()) {

game/systems/troop_profile_service.h

@@ -22,8 +22,8 @@ class TroopProfileService {
 public:
   static auto instance() -> TroopProfileService &;
 
-  auto get_profile(NationID nation_id, Game::Units::TroopType type)
-      -> TroopProfile;
+  auto get_profile(NationID nation_id,
+                   Game::Units::TroopType type) -> TroopProfile;
 
   void clear();
 

game/units/building_type.h

@@ -6,9 +6,6 @@
 
 namespace Game::Units {
 
-// Building types available in the game
-// Currently only Barracks is implemented, but this enum is designed
-// to be extensible for future building types (e.g., Tower, Wall, etc.)
 enum class BuildingType : std::uint8_t { Barracks };
 
 inline auto buildingTypeToQString(BuildingType type) -> QString {
@@ -16,7 +13,7 @@ inline auto buildingTypeToQString(BuildingType type) -> QString {
   case BuildingType::Barracks:
     return QStringLiteral("barracks");
   }
-  // Default fallback - should never reach here with valid enum
+
   return QStringLiteral("barracks");
 }
 
@@ -24,8 +21,8 @@ inline auto buildingTypeToString(BuildingType type) -> std::string {
   return buildingTypeToQString(type).toStdString();
 }
 
-inline auto tryParseBuildingType(const QString &value, BuildingType &out)
-    -> bool {
+inline auto tryParseBuildingType(const QString &value,
+                                 BuildingType &out) -> bool {
   const QString lowered = value.trimmed().toLower();
   if (lowered == QStringLiteral("barracks")) {
     out = BuildingType::Barracks;

game/units/unit.cpp

@@ -21,7 +21,8 @@ auto Unit::entity() const -> Engine::Core::Entity * {
   return (m_world != nullptr) ? m_world->getEntity(m_id) : nullptr;
 }
 
-auto Unit::resolve_nation_id(const SpawnParams &params) -> Game::Systems::NationID {
+auto Unit::resolve_nation_id(const SpawnParams &params)
+    -> Game::Systems::NationID {
   auto &registry = Game::Systems::NationRegistry::instance();
   if (const auto *nation = registry.getNationForPlayer(params.player_id)) {
     return nation->id;

game/units/unit.h

@@ -54,7 +54,8 @@ protected:
 
   void ensureCoreComponents();
 
-  static auto resolve_nation_id(const SpawnParams &params) -> Game::Systems::NationID;
+  static auto
+  resolve_nation_id(const SpawnParams &params) -> Game::Systems::NationID;
 
   Engine::Core::World *m_world = nullptr;
   Engine::Core::EntityID m_id = 0;