apply format

app/core/game_engine.cpp

@@ -96,8 +96,8 @@
 #include "render/ground/pine_renderer.h"
 #include "render/ground/plant_renderer.h"
 #include "render/ground/river_renderer.h"
-#include "render/ground/road_renderer.h"
 #include "render/ground/riverbank_renderer.h"
+#include "render/ground/road_renderer.h"
 #include "render/ground/stone_renderer.h"
 #include "render/ground/terrain_renderer.h"
 #include "render/scene_renderer.h"
@@ -136,10 +136,10 @@ GameEngine::GameEngine(QObject *parent)
   m_pine = std::make_unique<Render::GL::PineRenderer>();
   m_firecamp = std::make_unique<Render::GL::FireCampRenderer>();
 
-  m_passes = {m_ground.get(),    m_terrain.get(), m_river.get(),
-              m_road.get(),      m_riverbank.get(), m_bridge.get(),
-              m_biome.get(),     m_stone.get(),   m_plant.get(),
-              m_pine.get(),      m_firecamp.get(), m_fog.get()};
+  m_passes = {m_ground.get(), m_terrain.get(),   m_river.get(),
+              m_road.get(),   m_riverbank.get(), m_bridge.get(),
+              m_biome.get(),  m_stone.get(),     m_plant.get(),
+              m_pine.get(),   m_firecamp.get(),  m_fog.get()};
 
   std::unique_ptr<Engine::Core::System> arrow_sys =
       std::make_unique<Game::Systems::ArrowSystem>();

assets/shaders/road.frag

@@ -124,7 +124,8 @@ void main() {
   vec2 cell = floor(uv * 1.5);
   float cell_rnd = hash_2d(cell);
   vec2 local = fract(uv);
-  vec2 uv_var = (rotate_2d(cell_rnd * 6.2831853) * (local - 0.5) + 0.5) + floor(uv);
+  vec2 uv_var =
+      (rotate_2d(cell_rnd * 6.2831853) * (local - 0.5) + 0.5) + floor(uv);
 
   // Albedo variation - Roman roads have weathered stone look
   float var_low = (fbm_2d(uv * 0.4) - 0.5) * 0.18;

game/core/serialization.cpp

@@ -577,10 +577,9 @@ auto Serialization::serializeTerrain(
   return terrain_obj;
 }
 
-void Serialization::deserializeTerrain(Game::Map::TerrainHeightMap *height_map,
-                                       Game::Map::BiomeSettings &biome,
-                                       std::vector<Game::Map::RoadSegment> &roads,
-                                       const QJsonObject &json) {
+void Serialization::deserializeTerrain(
+    Game::Map::TerrainHeightMap *height_map, Game::Map::BiomeSettings &biome,
+    std::vector<Game::Map::RoadSegment> &roads, const QJsonObject &json) {
   if ((height_map == nullptr) || json.isEmpty()) {
     return;
   }
@@ -760,12 +759,11 @@ void Serialization::deserializeTerrain(Game::Map::TerrainHeightMap *height_map,
           QVector3D(static_cast<float>(road_obj["startX"].toDouble(0.0)),
                     static_cast<float>(road_obj["startY"].toDouble(0.0)),
                     static_cast<float>(road_obj["startZ"].toDouble(0.0)));
-      road.end =
-          QVector3D(static_cast<float>(road_obj["endX"].toDouble(0.0)),
-                    static_cast<float>(road_obj["endY"].toDouble(0.0)),
-                    static_cast<float>(road_obj["endZ"].toDouble(0.0)));
-      road.width = static_cast<float>(road_obj["width"].toDouble(
-          static_cast<double>(default_road.width)));
+      road.end = QVector3D(static_cast<float>(road_obj["endX"].toDouble(0.0)),
+                           static_cast<float>(road_obj["endY"].toDouble(0.0)),
+                           static_cast<float>(road_obj["endZ"].toDouble(0.0)));
+      road.width = static_cast<float>(
+          road_obj["width"].toDouble(static_cast<double>(default_road.width)));
       road.style = road_obj["style"].toString(default_road.style);
       roads.push_back(road);
     }

game/core/serialization.h

@@ -21,16 +21,14 @@ public:
   static auto serializeWorld(const class World *world) -> QJsonDocument;
   static void deserializeWorld(class World *world, const QJsonDocument &doc);
 
-  static auto
-  serializeTerrain(const Game::Map::TerrainHeightMap *height_map,
-                   const Game::Map::BiomeSettings &biome,
-                   const std::vector<Game::Map::RoadSegment> &roads)
+  static auto serializeTerrain(const Game::Map::TerrainHeightMap *height_map,
+                               const Game::Map::BiomeSettings &biome,
+                               const std::vector<Game::Map::RoadSegment> &roads)
       -> QJsonObject;
-  static void
-  deserializeTerrain(Game::Map::TerrainHeightMap *height_map,
-                     Game::Map::BiomeSettings &biome,
-                     std::vector<Game::Map::RoadSegment> &roads,
-                     const QJsonObject &json);
+  static void deserializeTerrain(Game::Map::TerrainHeightMap *height_map,
+                                 Game::Map::BiomeSettings &biome,
+                                 std::vector<Game::Map::RoadSegment> &roads,
+                                 const QJsonObject &json);
 
   static auto saveToFile(const QString &filename,
                          const QJsonDocument &doc) -> bool;

game/map/skirmish_loader.cpp

@@ -23,8 +23,8 @@
 #include "render/ground/pine_renderer.h"
 #include "render/ground/plant_renderer.h"
 #include "render/ground/river_renderer.h"
-#include "render/ground/road_renderer.h"
 #include "render/ground/riverbank_renderer.h"
+#include "render/ground/road_renderer.h"
 #include "render/ground/stone_renderer.h"
 #include "render/ground/terrain_renderer.h"
 #include "render/scene_renderer.h"

game/map/terrain_service.cpp

@@ -139,13 +139,13 @@ void TerrainService::restoreFromSerialized(
 auto TerrainService::is_point_on_road(float world_x,
                                       float world_z) const -> bool {
   for (const auto &segment : m_road_segments) {
-    // Calculate distance from point to line segment
+
     const float dx = segment.end.x() - segment.start.x();
     const float dz = segment.end.z() - segment.start.z();
     const float segment_length_sq = dx * dx + dz * dz;
 
     if (segment_length_sq < 0.0001F) {
-      // Degenerate segment - check distance to start point
+
       const float dist_x = world_x - segment.start.x();
       const float dist_z = world_z - segment.start.z();
       const float dist_sq = dist_x * dist_x + dist_z * dist_z;
@@ -156,17 +156,14 @@ auto TerrainService::is_point_on_road(float world_x,
       continue;
     }
 
-    // Project point onto line segment
     const float px = world_x - segment.start.x();
     const float pz = world_z - segment.start.z();
     float t = (px * dx + pz * dz) / segment_length_sq;
     t = std::clamp(t, 0.0F, 1.0F);
 
-    // Find closest point on segment
     const float closest_x = segment.start.x() + t * dx;
     const float closest_z = segment.start.z() + t * dz;
 
-    // Check distance from point to closest point on segment
     const float dist_x = world_x - closest_x;
     const float dist_z = world_z - closest_z;
     const float dist_sq = dist_x * dist_x + dist_z * dist_z;

game/map/terrain_service.h

@@ -51,7 +51,8 @@ public:
     return m_road_segments;
   }
 
-  [[nodiscard]] auto is_point_on_road(float world_x, float world_z) const -> bool;
+  [[nodiscard]] auto is_point_on_road(float world_x,
+                                      float world_z) const -> bool;
 
   [[nodiscard]] auto isInitialized() const -> bool {
     return m_height_map != nullptr;

render/gl/shader_cache.h

@@ -137,10 +137,8 @@ public:
         resolve(kShaderBase + QStringLiteral("riverbank.frag"));
     load(QStringLiteral("riverbank"), riverbankVert, riverbankFrag);
 
-    const QString roadVert =
-        resolve(kShaderBase + QStringLiteral("road.vert"));
-    const QString roadFrag =
-        resolve(kShaderBase + QStringLiteral("road.frag"));
+    const QString roadVert = resolve(kShaderBase + QStringLiteral("road.vert"));
+    const QString roadFrag = resolve(kShaderBase + QStringLiteral("road.frag"));
     load(QStringLiteral("road"), roadVert, roadFrag);
 
     const QString bridgeVert =

render/ground/biome_renderer.cpp

@@ -256,7 +256,6 @@ void BiomeRenderer::generateGrassInstances() {
       return false;
     }
 
-    // Avoid placing grass on roads
     auto &terrain_service = Game::Map::TerrainService::instance();
     if (terrain_service.is_point_on_road(world_x, world_z)) {
       return false;

render/ground/firecamp_renderer.cpp

@@ -299,7 +299,6 @@ void FireCampRenderer::generateFireCampInstances() {
       return false;
     }
 
-    // Avoid placing fire camps on roads
     auto &terrain_service = Game::Map::TerrainService::instance();
     if (terrain_service.is_point_on_road(world_x, world_z)) {
       return false;

render/ground/pine_renderer.cpp

@@ -191,7 +191,6 @@ void PineRenderer::generatePineInstances() {
       return false;
     }
 
-    // Avoid placing pine trees on roads
     auto &terrain_service = Game::Map::TerrainService::instance();
     if (terrain_service.is_point_on_road(world_x, world_z)) {
       return false;

render/ground/plant_renderer.cpp

@@ -264,7 +264,6 @@ void PlantRenderer::generatePlantInstances() {
       return false;
     }
 
-    // Avoid placing plants on roads
     auto &terrain_service = Game::Map::TerrainService::instance();
     if (terrain_service.is_point_on_road(world_x, world_z)) {
       return false;

render/ground/road_renderer.cpp

@@ -77,7 +77,6 @@ void RoadRenderer::build_meshes() {
           static_cast<float>(i) / static_cast<float>(length_steps - 1);
       QVector3D center_pos = segment.start + dir * (length * t);
 
-      // Roads have subtle edge variation (less than rivers)
       constexpr float k_edge_noise_freq_1 = 1.5F;
       constexpr float k_edge_noise_freq_2 = 4.0F;
 
@@ -89,10 +88,8 @@ void RoadRenderer::build_meshes() {
       float combined_noise = edge_noise1 * 0.6F + edge_noise2 * 0.4F;
       combined_noise = (combined_noise - 0.5F) * 2.0F;
 
-      // Roads have less width variation than rivers
       float const width_variation = combined_noise * half_width * 0.15F;
 
-      // Slight Y offset for road surface above ground
       constexpr float road_y_offset = 0.02F;
 
       QVector3D const left =
@@ -160,7 +157,7 @@ void RoadRenderer::submit(Renderer &renderer, ResourceManager *resources) {
 
   auto *shader = renderer.getShader("road");
   if (shader == nullptr) {
-    // Fallback to a basic shader if road shader not found
+
     shader = renderer.getShader("terrain");
     if (shader == nullptr) {
       return;
@@ -172,7 +169,6 @@ void RoadRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   QMatrix4x4 model;
   model.setToIdentity();
 
-  // Road stone/gravel color (brownish-gray like Roman roads)
   QVector3D const road_base_color(0.45F, 0.42F, 0.38F);
 
   size_t mesh_index = 0;