fix compilation errors

README.md

@@ -437,7 +437,7 @@ This roadmap replaces the single nation template with a scalable civilization la
 ### Phase 3 — Multi-Nation Support
 - Author Roman and Carthaginian JSON definitions with differentiated stats, formations, and renderer ids; set the default nation in `NationRegistry` to one of them.
 - Rename the shared melee infantry profile to `Swordsman` so nations can share core assets while still tuning stats in their override files.
-- Audit gameplay systems (AI build orders, UI panels, tutorials) to resolve troop data via `NationRegistry::getNationForPlayer` instead of assuming Kingdom of Iron.
+- Audit gameplay systems (AI build orders, UI panels, tutorials) to resolve troop data via `NationRegistry::get_nation_for_player` instead of assuming Kingdom of Iron.
 - Register renderer variants (e.g., `render/entity/roman_archer_renderer.cpp`) keyed by the profile’s renderer id, with graceful fallbacks to baseline assets.
 - Add hooks for balance levers (passive modifiers, tech prerequisites) inside `NationTroopVariant` so future expansions require data changes rather than engine rewrites.
 

app/core/game_engine.cpp

@@ -195,17 +195,17 @@ GameEngine::GameEngine(QObject *parent)
   m_hoverTracker = std::make_unique<HoverTracker>(m_pickingService.get());
 
   m_mapCatalog = std::make_unique<Game::Map::MapCatalog>(this);
-  connect(m_mapCatalog.get(), &Game::Map::MapCatalog::mapLoaded, this,
+  connect(m_mapCatalog.get(), &Game::Map::MapCatalog::map_loaded, this,
           [this](const QVariantMap &mapData) {
             m_available_maps.append(mapData);
             emit available_maps_changed();
           });
-  connect(m_mapCatalog.get(), &Game::Map::MapCatalog::loadingChanged, this,
+  connect(m_mapCatalog.get(), &Game::Map::MapCatalog::loading_changed, this,
           [this](bool loading) {
             m_maps_loading = loading;
             emit maps_loading_changed();
           });
-  connect(m_mapCatalog.get(), &Game::Map::MapCatalog::allMapsLoaded, this,
+  connect(m_mapCatalog.get(), &Game::Map::MapCatalog::all_maps_loaded, this,
           [this]() { emit available_maps_changed(); });
 
   if (AudioSystem::getInstance().initialize()) {
@@ -936,7 +936,7 @@ void GameEngine::camera_set_follow_lerp(float alpha) {
     return;
   }
 
-  m_cameraService->setFollowLerp(*m_camera, alpha);
+  m_cameraService->set_follow_lerp(*m_camera, alpha);
 }
 
 auto GameEngine::selected_units_model() -> QAbstractItemModel * {
@@ -1102,7 +1102,7 @@ void GameEngine::set_rally_at_screen(qreal sx, qreal sy) {
 void GameEngine::start_loading_maps() {
   m_available_maps.clear();
   if (m_mapCatalog) {
-    m_mapCatalog->loadMapsAsync();
+    m_mapCatalog->load_maps_async();
   }
   load_campaigns();
 }
@@ -1409,7 +1409,7 @@ auto GameEngine::load_from_slot(const QString &slot) -> bool {
 
   m_runtime.loading = true;
 
-  if (!m_saveLoadService->loadGameFromSlot(*m_world, slot)) {
+  if (!m_saveLoadService->load_game_from_slot(*m_world, slot)) {
     set_error(m_saveLoadService->getLastError());
     m_runtime.loading = false;
     return false;
@@ -1480,7 +1480,7 @@ auto GameEngine::get_save_slots() const -> QVariantList {
     return {};
   }
 
-  return m_saveLoadService->getSaveSlots();
+  return m_saveLoadService->get_save_slots();
 }
 
 void GameEngine::refresh_save_slots() { emit save_slots_changed(); }
@@ -2358,7 +2358,7 @@ void GameEngine::update_minimap_units() {
       marker.world_z = transform->position.z;
       marker.owner_id = unit->owner_id;
       marker.is_selected = selected_ids.count(entity_id) > 0;
-      marker.is_building = Game::Units::isBuildingSpawn(unit->spawn_type);
+      marker.is_building = Game::Units::is_building_spawn(unit->spawn_type);
 
       markers.push_back(marker);
     }

app/core/game_engine.h

@@ -173,10 +173,10 @@ public:
 
   Q_INVOKABLE [[nodiscard]] static QVariantMap get_player_stats(int owner_id);
 
-  [[nodiscard]] int selected_player_id() const { return m_selectedPlayerId; }
+  [[nodiscard]] int selected_player_id() const { return m_selected_player_id; }
   void set_selected_player_id(int id) {
-    if (m_selectedPlayerId != id) {
-      m_selectedPlayerId = id;
+    if (m_selected_player_id != id) {
+      m_selected_player_id = id;
       emit selected_player_id_changed();
     }
   }
@@ -332,7 +332,7 @@ private:
   Game::Systems::LevelSnapshot m_level;
   SelectedUnitsModel *m_selectedUnitsModel = nullptr;
   int m_enemyTroopsDefeated = 0;
-  int m_selectedPlayerId = 1;
+  int m_selected_player_id = 1;
   QVariantList m_available_maps;
   QVariantList m_available_campaigns;
   bool m_maps_loading = false;

game/core/world.cpp

@@ -141,7 +141,8 @@ auto World::get_enemy_units(int owner_id) const -> std::vector<Entity *> {
 }
 
 auto World::count_troops_for_player(int owner_id) -> int {
-  return Game::Systems::TroopCountRegistry::instance().get_troop_count(owner_id);
+  return Game::Systems::TroopCountRegistry::instance().get_troop_count(
+      owner_id);
 }
 
 auto World::get_next_entity_id() const -> EntityID {

game/map/level_loader.cpp

@@ -75,7 +75,8 @@ auto LevelLoader::loadFromAssets(
 
     const Game::Visuals::VisualCatalog *catalog_ptr =
         visuals_loaded ? &visual_catalog : nullptr;
-    auto rt = Game::Map::MapTransformer::applyToWorld(def, world, catalog_ptr);
+    auto rt =
+        Game::Map::MapTransformer::apply_to_world(def, world, catalog_ptr);
     if (!rt.unit_ids.empty()) {
       res.player_unit_id = rt.unit_ids.front();
     } else {

game/map/map_catalog.cpp

@@ -127,7 +127,7 @@ auto MapCatalog::availableMaps() -> QVariantList {
   return list;
 }
 
-void MapCatalog::loadMapsAsync() {
+void MapCatalog::load_maps_async() {
   if (m_loading) {
     return;
   }
@@ -135,15 +135,15 @@ void MapCatalog::loadMapsAsync() {
   m_maps.clear();
   m_pendingFiles.clear();
   m_loading = true;
-  emit loadingChanged(true);
+  emit loading_changed(true);
 
   const QString maps_root =
       Utils::Resources::resolveResourcePath(QStringLiteral(":/assets/maps"));
   QDir const maps_dir(maps_root);
   if (!maps_dir.exists()) {
     m_loading = false;
-    emit loadingChanged(false);
-    emit allMapsLoaded();
+    emit loading_changed(false);
+    emit all_maps_loaded();
     return;
   }
 
@@ -152,19 +152,19 @@ void MapCatalog::loadMapsAsync() {
 
   if (m_pendingFiles.isEmpty()) {
     m_loading = false;
-    emit loadingChanged(false);
-    emit allMapsLoaded();
+    emit loading_changed(false);
+    emit all_maps_loaded();
     return;
   }
 
-  QTimer::singleShot(0, this, &MapCatalog::loadNextMap);
+  QTimer::singleShot(0, this, &MapCatalog::load_next_map);
 }
 
-void MapCatalog::loadNextMap() {
+void MapCatalog::load_next_map() {
   if (m_pendingFiles.isEmpty()) {
     m_loading = false;
-    emit loadingChanged(false);
-    emit allMapsLoaded();
+    emit loading_changed(false);
+    emit all_maps_loaded();
     return;
   }
 
@@ -178,15 +178,15 @@ void MapCatalog::loadNextMap() {
   QVariantMap const entry = loadSingleMap(path);
   if (!entry.isEmpty()) {
     m_maps.append(entry);
-    emit mapLoaded(entry);
+    emit map_loaded(entry);
   }
 
   if (!m_pendingFiles.isEmpty()) {
-    QTimer::singleShot(10, this, &MapCatalog::loadNextMap);
+    QTimer::singleShot(10, this, &MapCatalog::load_next_map);
   } else {
     m_loading = false;
-    emit loadingChanged(false);
-    emit allMapsLoaded();
+    emit loading_changed(false);
+    emit all_maps_loaded();
   }
 }
 

game/map/map_catalog.h

@@ -13,7 +13,7 @@ public:
 
   static auto availableMaps() -> QVariantList;
 
-  Q_INVOKABLE void loadMapsAsync();
+  Q_INVOKABLE void load_maps_async();
 
   [[nodiscard]] auto isLoading() const -> bool { return m_loading; }
   [[nodiscard]] auto maps() const -> const QVariantList & { return m_maps; }

game/map/map_transformer.cpp

@@ -58,7 +58,7 @@ void MapTransformer::clearPlayerTeamOverrides() {
   s_player_team_overrides.clear();
 }
 
-auto MapTransformer::applyToWorld(
+auto MapTransformer::apply_to_world(
     const MapDefinition &def, Engine::Core::World &world,
     const Game::Visuals::VisualCatalog *visuals) -> MapRuntime {
   MapRuntime rt;
@@ -141,7 +141,8 @@ auto MapTransformer::applyToWorld(
     }
 
     auto &terrain = Game::Map::TerrainService::instance();
-    if (terrain.is_initialized() && terrain.is_forbidden_world(world_x, world_z)) {
+    if (terrain.is_initialized() &&
+        terrain.is_forbidden_world(world_x, world_z)) {
       const float tile = std::max(0.0001F, def.grid.tile_size);
       bool found = false;
       const int max_radius = 12;
@@ -211,7 +212,7 @@ auto MapTransformer::applyToWorld(
       if (visuals != nullptr) {
         Game::Visuals::VisualDef defv;
         if (visuals->lookup(Game::Units::spawn_typeToString(s.type), defv)) {
-          Game::Visuals::applyToRenderable(defv, *r);
+          Game::Visuals::apply_to_renderable(defv, *r);
         }
       }
       if (r->color[0] == 0.0F && r->color[1] == 0.0F && r->color[2] == 0.0F) {

game/map/map_transformer.h

@@ -21,7 +21,7 @@ struct MapRuntime {
 
 class MapTransformer {
 public:
-  static auto applyToWorld(
+  static auto apply_to_world(
       const MapDefinition &def, Engine::Core::World &world,
       const Game::Visuals::VisualCatalog *visuals = nullptr) -> MapRuntime;
 

game/map/minimap/minimap_generator.cpp

@@ -455,7 +455,7 @@ void MinimapGenerator::render_structures(QImage &image,
   painter.setRenderHint(QPainter::Antialiasing, true);
 
   for (const auto &spawn : map_def.spawns) {
-    if (!Game::Units::isBuildingSpawn(spawn.type)) {
+    if (!Game::Units::is_building_spawn(spawn.type)) {
       continue;
     }
 

game/map/skirmish_loader.cpp

@@ -108,7 +108,7 @@ auto SkirmishLoader::start(const QString &map_path,
                            int &out_selected_player_id) -> SkirmishLoadResult {
   SkirmishLoadResult result;
 
-  resetGameState();
+  reset_game_state();
 
   QSet<int> map_player_ids;
   QFile map_file(map_path);
@@ -229,20 +229,20 @@ auto SkirmishLoader::start(const QString &map_path,
     int player_id = *it;
     auto nat_it = nation_overrides.find(player_id);
     if (nat_it != nation_overrides.end()) {
-      nation_registry.setPlayerNation(player_id, nat_it->second);
+      nation_registry.set_player_nation(player_id, nat_it->second);
     } else {
-      nation_registry.setPlayerNation(player_id,
-                                      nation_registry.default_nation_id());
+      nation_registry.set_player_nation(player_id,
+                                        nation_registry.default_nation_id());
     }
   }
 
   if (map_player_ids.isEmpty()) {
     auto nat_it = nation_overrides.find(player_owner_id);
     if (nat_it != nation_overrides.end()) {
-      nation_registry.setPlayerNation(player_owner_id, nat_it->second);
+      nation_registry.set_player_nation(player_owner_id, nat_it->second);
     } else {
-      nation_registry.setPlayerNation(player_owner_id,
-                                      nation_registry.default_nation_id());
+      nation_registry.set_player_nation(player_owner_id,
+                                        nation_registry.default_nation_id());
     }
   }
 
@@ -273,7 +273,7 @@ auto SkirmishLoader::start(const QString &map_path,
         const int green = color_hex.mid(3, 2).toInt(&conversion_ok, hex_base);
         const int blue = color_hex.mid(5, 2).toInt(&conversion_ok, hex_base);
         owner_registry.set_owner_color(player_id, red / color_scale,
-                                     green / color_scale, blue / color_scale);
+                                       green / color_scale, blue / color_scale);
       }
     }
 
@@ -347,8 +347,9 @@ auto SkirmishLoader::start(const QString &map_path,
   if (m_riverbank != nullptr) {
     if (terrain_service.is_initialized() &&
         (terrain_service.get_height_map() != nullptr)) {
-      m_riverbank->configure(terrain_service.get_height_map()->getRiverSegments(),
-                             *terrain_service.get_height_map());
+      m_riverbank->configure(
+          terrain_service.get_height_map()->getRiverSegments(),
+          *terrain_service.get_height_map());
     }
   }
 

game/map/skirmish_loader.h

@@ -58,35 +58,35 @@ public:
   SkirmishLoader(Engine::Core::World &world, Render::GL::Renderer &renderer,
                  Render::GL::Camera &camera);
 
-  void setGroundRenderer(Render::GL::GroundRenderer *ground) {
+  void set_ground_renderer(Render::GL::GroundRenderer *ground) {
     m_ground = ground;
   }
-  void setTerrainRenderer(Render::GL::TerrainRenderer *terrain) {
+  void set_terrain_renderer(Render::GL::TerrainRenderer *terrain) {
     m_terrain = terrain;
   }
-  void setBiomeRenderer(Render::GL::BiomeRenderer *biome) { m_biome = biome; }
-  void setRiverRenderer(Render::GL::RiverRenderer *river) { m_river = river; }
-  void setRoadRenderer(Render::GL::RoadRenderer *road) { m_road = road; }
-  void setRiverbankRenderer(Render::GL::RiverbankRenderer *riverbank) {
+  void set_biome_renderer(Render::GL::BiomeRenderer *biome) { m_biome = biome; }
+  void set_river_renderer(Render::GL::RiverRenderer *river) { m_river = river; }
+  void set_road_renderer(Render::GL::RoadRenderer *road) { m_road = road; }
+  void set_riverbank_renderer(Render::GL::RiverbankRenderer *riverbank) {
     m_riverbank = riverbank;
   }
-  void setBridgeRenderer(Render::GL::BridgeRenderer *bridge) {
+  void set_bridge_renderer(Render::GL::BridgeRenderer *bridge) {
     m_bridge = bridge;
   }
-  void setFogRenderer(Render::GL::FogRenderer *fog) { m_fog = fog; }
-  void setStoneRenderer(Render::GL::StoneRenderer *stone) { m_stone = stone; }
-  void setPlantRenderer(Render::GL::PlantRenderer *plant) { m_plant = plant; }
-  void setPineRenderer(Render::GL::PineRenderer *pine) { m_pine = pine; }
-  void setOliveRenderer(Render::GL::OliveRenderer *olive) { m_olive = olive; }
-  void setFireCampRenderer(Render::GL::FireCampRenderer *firecamp) {
+  void set_fog_renderer(Render::GL::FogRenderer *fog) { m_fog = fog; }
+  void set_stone_renderer(Render::GL::StoneRenderer *stone) { m_stone = stone; }
+  void set_plant_renderer(Render::GL::PlantRenderer *plant) { m_plant = plant; }
+  void set_pine_renderer(Render::GL::PineRenderer *pine) { m_pine = pine; }
+  void set_olive_renderer(Render::GL::OliveRenderer *olive) { m_olive = olive; }
+  void set_fire_camp_renderer(Render::GL::FireCampRenderer *firecamp) {
     m_firecamp = firecamp;
   }
 
-  void setOnOwnersUpdated(OwnersUpdatedCallback callback) {
+  void set_on_owners_updated(OwnersUpdatedCallback callback) {
     m_onOwnersUpdated = std::move(callback);
   }
 
-  void setOnVisibilityMaskReady(VisibilityMaskReadyCallback callback) {
+  void set_on_visibility_mask_ready(VisibilityMaskReadyCallback callback) {
     m_onVisibilityMaskReady = std::move(callback);
   }
 
@@ -95,7 +95,7 @@ public:
              int &out_selected_player_id) -> SkirmishLoadResult;
 
 private:
-  void resetGameState();
+  void reset_game_state();
   Engine::Core::World &m_world;
   Render::GL::Renderer &m_renderer;
   Render::GL::Camera &m_camera;

game/map/terrain_service.cpp

@@ -37,7 +37,7 @@ void TerrainService::clear() {
 }
 
 auto TerrainService::get_terrain_height(float world_x,
-                                      float world_z) const -> float {
+                                        float world_z) const -> float {
   if (!m_height_map) {
     return 0.0F;
   }
@@ -45,7 +45,7 @@ auto TerrainService::get_terrain_height(float world_x,
 }
 
 auto TerrainService::get_terrain_height_grid(int grid_x,
-                                          int grid_z) const -> float {
+                                             int grid_z) const -> float {
   if (!m_height_map) {
     return 0.0F;
   }
@@ -86,7 +86,7 @@ auto TerrainService::is_forbidden(int grid_x, int grid_z) const -> bool {
 }
 
 auto TerrainService::is_forbidden_world(float world_x,
-                                      float world_z) const -> bool {
+                                        float world_z) const -> bool {
   if (!m_height_map) {
     return false;
   }
@@ -106,7 +106,7 @@ auto TerrainService::is_forbidden_world(float world_x,
   const int grid_x_int = static_cast<int>(std::round(grid_x));
   const int grid_z_int = static_cast<int>(std::round(grid_z));
 
-  return isForbidden(grid_x_int, grid_z_int);
+  return is_forbidden(grid_x_int, grid_z_int);
 }
 
 auto TerrainService::is_hill_entrance(int grid_x, int grid_z) const -> bool {
@@ -117,7 +117,7 @@ auto TerrainService::is_hill_entrance(int grid_x, int grid_z) const -> bool {
 }
 
 auto TerrainService::get_terrain_type(int grid_x,
-                                    int grid_z) const -> TerrainType {
+                                      int grid_z) const -> TerrainType {
   if (!m_height_map) {
     return TerrainType::Flat;
   }

game/map/terrain_service.h

@@ -18,10 +18,10 @@ public:
   void clear();
 
   [[nodiscard]] auto get_terrain_height(float world_x,
-                                      float world_z) const -> float;
+                                        float world_z) const -> float;
 
   [[nodiscard]] auto get_terrain_height_grid(int grid_x,
-                                          int grid_z) const -> float;
+                                             int grid_z) const -> float;
 
   [[nodiscard]] auto is_walkable(int grid_x, int grid_z) const -> bool;
 
@@ -30,10 +30,10 @@ public:
   [[nodiscard]] auto is_forbidden(int grid_x, int grid_z) const -> bool;
 
   [[nodiscard]] auto is_forbidden_world(float world_x,
-                                      float world_z) const -> bool;
+                                        float world_z) const -> bool;
 
   [[nodiscard]] auto get_terrain_type(int grid_x,
-                                    int grid_z) const -> TerrainType;
+                                      int grid_z) const -> TerrainType;
 
   [[nodiscard]] auto get_height_map() const -> const TerrainHeightMap * {
     return m_height_map.get();
@@ -59,12 +59,12 @@ public:
   }
 
   void restore_from_serialized(int width, int height, float tile_size,
-                             const std::vector<float> &heights,
-                             const std::vector<TerrainType> &terrain_types,
-                             const std::vector<RiverSegment> &rivers,
-                             const std::vector<RoadSegment> &roads,
-                             const std::vector<Bridge> &bridges,
-                             const BiomeSettings &biome);
+                               const std::vector<float> &heights,
+                               const std::vector<TerrainType> &terrain_types,
+                               const std::vector<RiverSegment> &rivers,
+                               const std::vector<RoadSegment> &roads,
+                               const std::vector<Bridge> &bridges,
+                               const BiomeSettings &biome);
 
 private:
   TerrainService() = default;

game/map/visibility_service.h

@@ -28,7 +28,7 @@ public:
   auto update(Engine::Core::World &world, int player_id) -> bool;
   void computeImmediate(Engine::Core::World &world, int player_id);
 
-  auto isInitialized() const -> bool { return m_initialized; }
+  auto is_initialized() const -> bool { return m_initialized; }
 
   auto getWidth() const -> int { return m_width; }
   auto getHeight() const -> int { return m_height; }

game/systems/ai_system.cpp

@@ -34,7 +34,7 @@ AISystem::AISystem() {
   m_buildingAttackedSubscription = Engine::Core::ScopedEventSubscription<
       Engine::Core::BuildingAttackedEvent>(
       [this](const Engine::Core::BuildingAttackedEvent &event) {
-        this->onBuildingAttacked(event);
+        this->on_building_attacked(event);
       });
 
   initializeAIPlayers();
@@ -77,7 +77,7 @@ void AISystem::update(Engine::Core::World *world, float delta_time) {
 
   m_commandFilter.update(m_total_game_time);
 
-  processResults(*world);
+  process_results(*world);
 
   for (auto &ai : m_aiInstances) {
 
@@ -93,7 +93,7 @@ void AISystem::update(Engine::Core::World *world, float delta_time) {
 
     AI::AISnapshot snapshot = Game::Systems::AI::AISnapshotBuilder::build(
         *world, ai.context.player_id);
-    snapshot.gameTime = m_total_game_time;
+    snapshot.game_time = m_total_game_time;
 
     AI::AIJob job;
     job.snapshot = std::move(snapshot);
@@ -136,7 +136,7 @@ void AISystem::on_building_attacked(
       ai.context.buildingsUnderAttack[event.buildingId] = m_total_game_time;
 
       if (event.buildingId == ai.context.primaryBarracks) {
-        ai.context.barracksUnderThreat = true;
+        ai.context.barracks_under_threat = true;
       }
       break;
     }

game/systems/ai_system.h

@@ -52,9 +52,9 @@ private:
 
   void initializeAIPlayers();
 
-  void processResults(Engine::Core::World &world);
+  void process_results(Engine::Core::World &world);
 
-  void onBuildingAttacked(const Engine::Core::BuildingAttackedEvent &event);
+  void on_building_attacked(const Engine::Core::BuildingAttackedEvent &event);
 };
 
 } // namespace Game::Systems

game/systems/ai_system/ai_reasoner.cpp

@@ -13,8 +13,9 @@ namespace Game::Systems::AI {
 void AIReasoner::updateContext(const AISnapshot &snapshot, AIContext &ctx) {
 
   if (ctx.nation == nullptr) {
-    ctx.nation = Game::Systems::NationRegistry::instance().getNationForPlayer(
-        ctx.player_id);
+    ctx.nation =
+        Game::Systems::NationRegistry::instance().get_nation_for_player(
+            ctx.player_id);
   }
 
   cleanupDeadUnits(snapshot, ctx);
@@ -127,8 +128,9 @@ void AIReasoner::updateContext(const AISnapshot &snapshot, AIContext &ctx) {
     }
 
     if (ctx.primaryBarracks != 0) {
-      float const dist = distance(enemy.posX, enemy.posY, enemy.posZ,
-                                  ctx.base_pos_x, ctx.base_pos_y, ctx.base_pos_z);
+      float const dist =
+          distance(enemy.posX, enemy.posY, enemy.posZ, ctx.base_pos_x,
+                   ctx.base_pos_y, ctx.base_pos_z);
       total_enemy_dist += dist;
     }
   }
@@ -155,7 +157,8 @@ void AIReasoner::updateContext(const AISnapshot &snapshot, AIContext &ctx) {
         ctx.nearby_threat_count++;
 
         float const dist = std::sqrt(std::max(dist_sq, 0.0F));
-        ctx.closest_threat_distance = std::min(ctx.closest_threat_distance, dist);
+        ctx.closest_threat_distance =
+            std::min(ctx.closest_threat_distance, dist);
       }
     }
 

game/systems/ai_system/ai_tactical.cpp

@@ -226,7 +226,7 @@ auto TacticalUtils::getUnitTypePriority(const std::string &unit_type,
   }
 
   auto spawn_type = Game::Units::spawn_typeFromString(unit_type);
-  if (spawn_type && Game::Units::is_buildingSpawn(*spawn_type)) {
+  if (spawn_type && Game::Units::is_building_spawn(*spawn_type)) {
     return 0.5F;
   }
 

game/systems/ai_system/behaviors/defend_behavior.cpp

@@ -228,7 +228,7 @@ void DefendBehavior::execute(const AISnapshot &snapshot, AIContext &context,
   }
 
   const Nation *nation =
-      NationRegistry::instance().getNationForPlayer(context.player_id);
+      NationRegistry::instance().get_nation_for_player(context.player_id);
   FormationType formation_type = FormationType::Roman;
   if (nation != nullptr) {
     formation_type = nation->formation_type;

game/systems/ai_system/behaviors/gather_behavior.cpp

@@ -55,7 +55,7 @@ void GatherBehavior::execute(const AISnapshot &snapshot, AIContext &context,
   }
 
   const Nation *nation =
-      NationRegistry::instance().getNationForPlayer(context.player_id);
+      NationRegistry::instance().get_nation_for_player(context.player_id);
   FormationType formation_type = FormationType::Roman;
   if (nation != nullptr) {
     formation_type = nation->formation_type;

game/systems/ai_system/behaviors/production_behavior.cpp

@@ -20,7 +20,7 @@ void ProductionBehavior::execute(const AISnapshot &snapshot, AIContext &context,
   static int const exec_counter = 0;
 
   auto &nation_registry = Game::Systems::NationRegistry::instance();
-  const auto *nation = nation_registry.getNationForPlayer(context.player_id);
+  const auto *nation = nation_registry.get_nation_for_player(context.player_id);
 
   if (nation == nullptr) {
 

game/systems/ai_system/behaviors/retreat_behavior.cpp

@@ -57,7 +57,8 @@ void RetreatBehavior::execute(const AISnapshot &snapshot, AIContext &context,
     return;
   }
 
-  QVector3D retreat_pos(context.base_pos_x, context.base_pos_y, context.base_pos_z);
+  QVector3D retreat_pos(context.base_pos_x, context.base_pos_y,
+                        context.base_pos_z);
 
   retreat_pos.setX(retreat_pos.x() - 8.0F);
 

game/systems/building_collision_registry.cpp

@@ -41,7 +41,7 @@ void BuildingCollisionRegistry::register_building(
 
   if (m_entityToIndex.find(entity_id) != m_entityToIndex.end()) {
 
-    updateBuildingPosition(entity_id, center_x, center_z);
+    update_building_position(entity_id, center_x, center_z);
     return;
   }
 
@@ -80,8 +80,8 @@ void BuildingCollisionRegistry::unregister_building(unsigned int entity_id) {
 }
 
 void BuildingCollisionRegistry::update_building_position(unsigned int entity_id,
-                                                       float center_x,
-                                                       float center_z) {
+                                                         float center_x,
+                                                         float center_z) {
   auto it = m_entityToIndex.find(entity_id);
   if (it == m_entityToIndex.end()) {
     return;
@@ -97,7 +97,7 @@ void BuildingCollisionRegistry::update_building_position(unsigned int entity_id,
 }
 
 void BuildingCollisionRegistry::update_building_owner(unsigned int entity_id,
-                                                    int owner_id) {
+                                                      int owner_id) {
   auto it = m_entityToIndex.find(entity_id);
   if (it == m_entityToIndex.end()) {
     return;

game/systems/building_collision_registry.h

@@ -32,15 +32,16 @@ public:
 
   static auto getBuildingSize(const std::string &buildingType) -> BuildingSize;
 
-  void registerBuilding(unsigned int entity_id, const std::string &buildingType,
-                        float center_x, float center_z, int owner_id);
+  void register_building(unsigned int entity_id,
+                         const std::string &buildingType, float center_x,
+                         float center_z, int owner_id);
 
-  void unregisterBuilding(unsigned int entity_id);
+  void unregister_building(unsigned int entity_id);
 
-  void updateBuildingPosition(unsigned int entity_id, float center_x,
-                              float center_z);
+  void update_building_position(unsigned int entity_id, float center_x,
+                                float center_z);
 
-  void updateBuildingOwner(unsigned int entity_id, int owner_id);
+  void update_building_owner(unsigned int entity_id, int owner_id);
 
   [[nodiscard]] auto
   getAllBuildings() const -> const std::vector<BuildingFootprint> & {

game/systems/camera_controller.cpp

@@ -46,12 +46,13 @@ void CameraController::zoomDistance(Render::GL::Camera &camera, float delta) {
   }
 }
 
-void CameraController::setFollowEnabled(Render::GL::Camera &camera,
-                                        bool enable) {
-  camera.setFollowEnabled(enable);
+void CameraController::set_follow_enabled(Render::GL::Camera &camera,
+                                          bool enable) {
+  camera.set_follow_enabled(enable);
 }
 
-void CameraController::setFollowLerp(Render::GL::Camera &camera, float alpha) {
+void CameraController::set_follow_lerp(Render::GL::Camera &camera,
+                                       float alpha) {
   camera.setFollowLerp(alpha);
 }
 

game/systems/camera_controller.h

@@ -14,8 +14,8 @@ public:
   static void yaw(Render::GL::Camera &camera, float degrees);
   static void orbit(Render::GL::Camera &camera, float yaw_deg, float pitch_deg);
   static void zoomDistance(Render::GL::Camera &camera, float delta);
-  static void setFollowEnabled(Render::GL::Camera &camera, bool enable);
-  static void setFollowLerp(Render::GL::Camera &camera, float alpha);
+  static void set_follow_enabled(Render::GL::Camera &camera, bool enable);
+  static void set_follow_lerp(Render::GL::Camera &camera, float alpha);
 };
 
 } // namespace Game::Systems

game/systems/camera_service.cpp

@@ -64,7 +64,7 @@ void CameraService::orbit_direction(Render::GL::Camera &camera, int direction,
 
 void CameraService::follow_selection(Render::GL::Camera &camera,
                                      Engine::Core::World &world, bool enable) {
-  m_controller->setFollowEnabled(camera, enable);
+  m_controller->set_follow_enabled(camera, enable);
 
   if (enable) {
     if (auto *selection_system = world.get_system<SelectionSystem>()) {
@@ -79,7 +79,7 @@ void CameraService::follow_selection(Render::GL::Camera &camera,
 
 void CameraService::set_follow_lerp(Render::GL::Camera &camera, float alpha) {
   float const a = std::clamp(alpha, 0.0F, 1.0F);
-  m_controller->setFollowLerp(camera, a);
+  m_controller->set_follow_lerp(camera, a);
 }
 
 void CameraService::resetCamera(Render::GL::Camera &camera,

game/systems/camera_service.h

@@ -30,7 +30,7 @@ public:
   void orbit_direction(Render::GL::Camera &camera, int direction, bool shift);
   void follow_selection(Render::GL::Camera &camera, Engine::Core::World &world,
                         bool enable);
-  void setFollowLerp(Render::GL::Camera &camera, float alpha);
+  void set_follow_lerp(Render::GL::Camera &camera, float alpha);
   [[nodiscard]] static auto
   get_distance(const Render::GL::Camera &camera) -> float;
   static void resetCamera(Render::GL::Camera &camera,

game/systems/capture_system.cpp

@@ -76,7 +76,8 @@ void CaptureSystem::transferBarrackOwnership(Engine::Core::World *,
 
   auto &nation_registry = NationRegistry::instance();
   if (!Game::Core::isNeutralOwner(new_owner_id)) {
-    if (const auto *nation = nation_registry.get_nation_for_player(new_owner_id)) {
+    if (const auto *nation =
+            nation_registry.get_nation_for_player(new_owner_id)) {
       unit->nation_id = nation->id;
     } else {
       unit->nation_id = nation_registry.default_nation_id();

game/systems/combat_system.cpp

@@ -20,12 +20,12 @@
 namespace Game::Systems {
 
 void CombatSystem::update(Engine::Core::World *world, float delta_time) {
-  processAttacks(world, delta_time);
-  processAutoEngagement(world, delta_time);
+  process_attacks(world, delta_time);
+  process_auto_engagement(world, delta_time);
 }
 
-void CombatSystem::processAttacks(Engine::Core::World *world,
-                                  float delta_time) {
+void CombatSystem::process_attacks(Engine::Core::World *world,
+                                   float delta_time) {
   auto units = world->get_entities_with<Engine::Core::UnitComponent>();
 
   auto *arrow_sys = world->get_system<ArrowSystem>();
@@ -167,7 +167,7 @@ void CombatSystem::processAttacks(Engine::Core::World *world,
 
         auto &owner_registry = Game::Systems::OwnerRegistry::instance();
         bool const is_ally = owner_registry.are_allies(attacker_unit->owner_id,
-                                                      target_unit->owner_id);
+                                                       target_unit->owner_id);
 
         if ((target_unit != nullptr) && target_unit->health > 0 &&
             target_unit->owner_id != attacker_unit->owner_id && !is_ally) {
@@ -396,7 +396,7 @@ void CombatSystem::processAttacks(Engine::Core::World *world,
         }
 
         if (owner_registry.are_allies(attacker_unit->owner_id,
-                                     target_unit->owner_id)) {
+                                      target_unit->owner_id)) {
           continue;
         }
 
@@ -760,7 +760,7 @@ void CombatSystem::updateCombatMode(
     }
 
     if (owner_registry.are_allies(attacker_unit->owner_id,
-                                 target_unit->owner_id)) {
+                                  target_unit->owner_id)) {
       continue;
     }
 
@@ -817,7 +817,7 @@ void CombatSystem::updateCombatMode(
 }
 
 void CombatSystem::process_auto_engagement(Engine::Core::World *world,
-                                         float delta_time) {
+                                           float delta_time) {
   auto units = world->get_entities_with<Engine::Core::UnitComponent>();
 
   for (auto it = m_engagementCooldowns.begin();
@@ -861,7 +861,7 @@ void CombatSystem::process_auto_engagement(Engine::Core::World *world,
       continue;
     }
 
-    if (!isUnitIdle(unit)) {
+    if (!is_unit_idle(unit)) {
       continue;
     }
 
@@ -886,7 +886,7 @@ void CombatSystem::process_auto_engagement(Engine::Core::World *world,
   }
 }
 
-auto CombatSystem::isUnitIdle(Engine::Core::Entity *unit) -> bool {
+auto CombatSystem::is_unit_idle(Engine::Core::Entity *unit) -> bool {
 
   auto *hold_mode = unit->get_component<Engine::Core::HoldModeComponent>();
   if ((hold_mode != nullptr) && hold_mode->active) {

game/systems/combat_system.h

@@ -15,7 +15,7 @@ public:
   void update(Engine::Core::World *world, float delta_time) override;
 
 private:
-  static void processAttacks(Engine::Core::World *world, float delta_time);
+  static void process_attacks(Engine::Core::World *world, float delta_time);
   static void updateCombatMode(Engine::Core::Entity *attacker,
                                Engine::Core::World *world,
                                Engine::Core::AttackComponent *attack_comp);
@@ -24,8 +24,8 @@ private:
   static void dealDamage(Engine::Core::World *world,
                          Engine::Core::Entity *target, int damage,
                          Engine::Core::EntityID attackerId = 0);
-  void processAutoEngagement(Engine::Core::World *world, float delta_time);
-  static auto isUnitIdle(Engine::Core::Entity *unit) -> bool;
+  void process_auto_engagement(Engine::Core::World *world, float delta_time);
+  static auto is_unit_idle(Engine::Core::Entity *unit) -> bool;
   static auto findNearestEnemy(Engine::Core::Entity *unit,
                                Engine::Core::World *world,
                                float max_range) -> Engine::Core::Entity *;
@@ -34,4 +34,4 @@ private:
   static constexpr float ENGAGEMENT_COOLDOWN = 0.5F;
 };
 
-} // namespace Game::Systems
+} // namespace Game::Systems

game/systems/formation_system.h

@@ -61,8 +61,8 @@ public:
 
   auto
   get_formation_positions(FormationType type, int unit_count,
-                        const QVector3D &center,
-                        float base_spacing = 1.0F) -> std::vector<QVector3D>;
+                          const QVector3D &center,
+                          float base_spacing = 1.0F) -> std::vector<QVector3D>;
 
   void registerFormation(FormationType type,
                          std::unique_ptr<IFormation> formation);

game/systems/healing_system.cpp

@@ -9,11 +9,11 @@
 namespace Game::Systems {
 
 void HealingSystem::update(Engine::Core::World *world, float delta_time) {
-  processHealing(world, delta_time);
+  process_healing(world, delta_time);
 }
 
 void HealingSystem::process_healing(Engine::Core::World *world,
-                                   float delta_time) {
+                                    float delta_time) {
   auto healers = world->get_entities_with<Engine::Core::HealerComponent>();
   auto *arrow_system = world->get_system<ArrowSystem>();
 

game/systems/healing_system.h

@@ -13,7 +13,7 @@ public:
   void update(Engine::Core::World *world, float delta_time) override;
 
 private:
-  void processHealing(Engine::Core::World *world, float delta_time);
+  void process_healing(Engine::Core::World *world, float delta_time);
 };
 
 } // namespace Game::Systems

game/systems/nation_registry.cpp

@@ -109,7 +109,8 @@ auto NationRegistry::getNation(NationID nationId) const -> const Nation * {
   return &m_nations[it->second];
 }
 
-auto NationRegistry::get_nation_for_player(int player_id) const -> const Nation * {
+auto NationRegistry::get_nation_for_player(int player_id) const
+    -> const Nation * {
 
   auto it = m_playerNations.find(player_id);
   if (it != m_playerNations.end()) {
@@ -123,7 +124,7 @@ auto NationRegistry::get_nation_for_player(int player_id) const -> const Nation
   return nation;
 }
 
-void NationRegistry::setPlayerNation(int player_id, NationID nationId) {
+void NationRegistry::set_player_nation(int player_id, NationID nationId) {
   m_playerNations[player_id] = nationId;
 }
 
@@ -163,12 +164,12 @@ void NationRegistry::initialize_defaults() {
     appendTroop(Game::Units::TroopType::Spearman);
     appendTroop(Game::Units::TroopType::MountedKnight);
 
-    registerNation(std::move(roman));
+    register_nation(std::move(roman));
     m_defaultNation = NationID::RomanRepublic;
   } else {
     NationID fallback_default = nations.front().id;
     for (auto &nation : nations) {
-      registerNation(std::move(nation));
+      register_nation(std::move(nation));
     }
     m_defaultNation = fallback_default;
   }

game/systems/nation_registry.h

@@ -75,23 +75,23 @@ class NationRegistry {
 public:
   static auto instance() -> NationRegistry &;
 
-  void registerNation(Nation nation);
+  void register_nation(Nation nation);
 
   auto getNation(NationID nationId) const -> const Nation *;
 
-  auto getNationForPlayer(int player_id) const -> const Nation *;
+  auto get_nation_for_player(int player_id) const -> const Nation *;
 
-  void setPlayerNation(int player_id, NationID nationId);
+  void set_player_nation(int player_id, NationID nationId);
 
-  auto getAllNations() const -> const std::vector<Nation> & {
+  auto get_all_nations() const -> const std::vector<Nation> & {
     return m_nations;
   }
 
-  void initializeDefaults();
+  void initialize_defaults();
 
   void clear();
 
-  void clearPlayerAssignments();
+  void clear_player_assignments();
 
   auto default_nation_id() const -> NationID { return m_defaultNation; }
 

game/systems/owner_registry.cpp

@@ -71,7 +71,7 @@ void OwnerRegistry::clear() {
 }
 
 auto OwnerRegistry::register_owner(OwnerType type,
-                                  const std::string &name) -> int {
+                                   const std::string &name) -> int {
   int const owner_id = m_next_owner_id++;
   OwnerInfo info;
   info.owner_id = owner_id;
@@ -104,7 +104,7 @@ auto OwnerRegistry::register_owner(OwnerType type,
 }
 
 void OwnerRegistry::register_owner_with_id(int owner_id, OwnerType type,
-                                        const std::string &name) {
+                                           const std::string &name) {
   if (m_owner_id_to_index.find(owner_id) != m_owner_id_to_index.end()) {
     return;
   }
@@ -145,7 +145,9 @@ void OwnerRegistry::set_local_player_id(int player_id) {
   m_local_player_id = player_id;
 }
 
-auto OwnerRegistry::get_local_player_id() const -> int { return m_local_player_id; }
+auto OwnerRegistry::get_local_player_id() const -> int {
+  return m_local_player_id;
+}
 
 auto OwnerRegistry::is_player(int owner_id) const -> bool {
   auto it = m_owner_id_to_index.find(owner_id);
@@ -279,7 +281,8 @@ void OwnerRegistry::set_owner_color(int owner_id, float r, float g, float b) {
   }
 }
 
-auto OwnerRegistry::get_owner_color(int owner_id) const -> std::array<float, 3> {
+auto OwnerRegistry::get_owner_color(int owner_id) const
+    -> std::array<float, 3> {
   auto it = m_owner_id_to_index.find(owner_id);
   if (it != m_owner_id_to_index.end()) {
     return m_owners[it->second].color;

game/systems/production_service.cpp

@@ -85,7 +85,8 @@ auto ProductionService::startProductionForFirstSelectedBarracks(
 
   int const current_troops =
       Engine::Core::World::count_troops_for_player(owner_id);
-  int const max_troops = Game::GameConfig::instance().get_max_troops_per_player();
+  int const max_troops =
+      Game::GameConfig::instance().get_max_troops_per_player();
   if (current_troops + production_cost > max_troops) {
     return ProductionResult::GlobalTroopLimitReached;
   }

game/systems/projectile_system.cpp

@@ -27,9 +27,9 @@ void ProjectileSystem::spawn_arrow(const QVector3D &start, const QVector3D &end,
                             m_arrow_config.arc_height_max * 0.6F);
   } else {
 
-    arc_height =
-        std::clamp(m_arrow_config.arc_height_multiplier * dist,
-                   m_arrow_config.arc_height_min, m_arrow_config.arc_height_max);
+    arc_height = std::clamp(m_arrow_config.arc_height_multiplier * dist,
+                            m_arrow_config.arc_height_min,
+                            m_arrow_config.arc_height_max);
   }
   float inv_dist = (dist > 0.001F) ? (1.0F / dist) : 1.0F;
 

game/systems/save_load_service.cpp

@@ -109,7 +109,7 @@ auto SaveLoadService::saveGameToSlot(Engine::Core::World &world,
 }
 
 auto SaveLoadService::load_game_from_slot(Engine::Core::World &world,
-                                       const QString &slotName) -> bool {
+                                          const QString &slotName) -> bool {
   qInfo() << "Loading game from slot:" << slotName;
 
   try {

game/systems/save_load_service.h

@@ -25,10 +25,10 @@ public:
                       const QJsonObject &metadata = {},
                       const QByteArray &screenshot = QByteArray()) -> bool;
 
-  auto loadGameFromSlot(Engine::Core::World &world,
-                        const QString &slotName) -> bool;
+  auto load_game_from_slot(Engine::Core::World &world,
+                           const QString &slotName) -> bool;
 
-  auto getSaveSlots() const -> QVariantList;
+  auto get_save_slots() const -> QVariantList;
 
   auto deleteSaveSlot(const QString &slotName) -> bool;
 

game/systems/save_storage.cpp

@@ -480,12 +480,12 @@ auto SaveStorage::ensureSchema(QString *out_error) const -> bool {
     return false;
   }
 
-  if (!migrateSchema(current_version, out_error)) {
+  if (!migrate_schema(current_version, out_error)) {
     transaction.rollback();
     return false;
   }
 
-  if (!setSchemaVersion(k_current_schema_version, out_error)) {
+  if (!set_schema_version(k_current_schema_version, out_error)) {
     transaction.rollback();
     return false;
   }
@@ -515,7 +515,7 @@ auto SaveStorage::schemaVersion(QString *out_error) const -> int {
 }
 
 auto SaveStorage::set_schema_version(int version,
-                                   QString *out_error) const -> bool {
+                                     QString *out_error) const -> bool {
   QSqlQuery pragma_query(m_database);
   if (!pragma_query.exec(
           QStringLiteral("PRAGMA user_version = %1").arg(version))) {
@@ -567,7 +567,7 @@ auto SaveStorage::createBaseSchema(QString *out_error) const -> bool {
 }
 
 auto SaveStorage::migrate_schema(int fromVersion,
-                                QString *out_error) const -> bool {
+                                 QString *out_error) const -> bool {
   int version = fromVersion;
 
   while (version < k_current_schema_version) {

game/systems/save_storage.h

@@ -41,11 +41,11 @@ private:
   auto open(QString *out_error = nullptr) const -> bool;
   auto ensureSchema(QString *out_error = nullptr) const -> bool;
   auto createBaseSchema(QString *out_error = nullptr) const -> bool;
-  auto migrateSchema(int fromVersion,
-                     QString *out_error = nullptr) const -> bool;
+  auto migrate_schema(int fromVersion,
+                      QString *out_error = nullptr) const -> bool;
   auto schemaVersion(QString *out_error = nullptr) const -> int;
-  auto setSchemaVersion(int version,
-                        QString *out_error = nullptr) const -> bool;
+  auto set_schema_version(int version,
+                          QString *out_error = nullptr) const -> bool;
   auto migrate_to_2(QString *out_error = nullptr) const -> bool;
 
   QString m_database_path;

game/systems/troop_count_registry.h

@@ -16,7 +16,7 @@ public:
   void initialize();
   void clear();
 
-  auto getTroopCount(int owner_id) const -> int;
+  auto get_troop_count(int owner_id) const -> int;
 
   void on_unit_spawned(const Engine::Core::UnitSpawnedEvent &event);
   void on_unit_died(const Engine::Core::UnitDiedEvent &event);

game/systems/victory_service.cpp

@@ -88,12 +88,12 @@ void VictoryService::update(Engine::Core::World &world, float delta_time) {
     m_elapsed_time += delta_time;
   }
 
-  checkVictoryConditions(world);
+  check_victory_conditions(world);
   if (!m_victoryState.isEmpty()) {
     return;
   }
 
-  checkDefeatConditions(world);
+  check_defeat_conditions(world);
 }
 
 void VictoryService::on_unit_died(const Engine::Core::UnitDiedEvent &event) {}
@@ -105,12 +105,12 @@ void VictoryService::on_barrack_captured(
     return;
   }
 
-  checkVictoryConditions(*m_worldPtr);
+  check_victory_conditions(*m_worldPtr);
   if (!m_victoryState.isEmpty()) {
     return;
   }
 
-  checkDefeatConditions(*m_worldPtr);
+  check_defeat_conditions(*m_worldPtr);
 }
 
 void VictoryService::check_victory_conditions(Engine::Core::World &world) {
@@ -118,7 +118,7 @@ void VictoryService::check_victory_conditions(Engine::Core::World &world) {
 
   switch (m_victoryType) {
   case VictoryType::Elimination:
-    victory = checkElimination(world);
+    victory = check_elimination(world);
     break;
   case VictoryType::SurviveTime:
     victory = checkSurviveTime();
@@ -160,10 +160,10 @@ void VictoryService::check_defeat_conditions(Engine::Core::World &world) {
 
     switch (condition) {
     case DefeatCondition::NoUnits:
-      defeat = checkNoUnits(world);
+      defeat = check_no_units(world);
       break;
     case DefeatCondition::NoKeyStructures:
-      defeat = checkNoKeyStructures(world);
+      defeat = check_no_key_structures(world);
       break;
     case DefeatCondition::TimeExpired:
 
@@ -252,7 +252,8 @@ auto VictoryService::check_no_units(Engine::Core::World &world) const -> bool {
   return true;
 }
 
-auto VictoryService::check_no_key_structures(Engine::Core::World &world) -> bool {
+auto VictoryService::check_no_key_structures(Engine::Core::World &world)
+    -> bool {
 
   auto entities = world.get_entities_with<Engine::Core::UnitComponent>();
   for (auto *e : entities) {

game/systems/victory_service.h

@@ -51,13 +51,13 @@ public:
 private:
   void on_unit_died(const Engine::Core::UnitDiedEvent &event);
   void on_barrack_captured(const Engine::Core::BarrackCapturedEvent &event);
-  void checkVictoryConditions(Engine::Core::World &world);
-  void checkDefeatConditions(Engine::Core::World &world);
+  void check_victory_conditions(Engine::Core::World &world);
+  void check_defeat_conditions(Engine::Core::World &world);
 
-  auto checkElimination(Engine::Core::World &world) -> bool;
+  auto check_elimination(Engine::Core::World &world) -> bool;
   [[nodiscard]] auto checkSurviveTime() const -> bool;
-  auto checkNoUnits(Engine::Core::World &world) const -> bool;
-  auto checkNoKeyStructures(Engine::Core::World &world) -> bool;
+  auto check_no_units(Engine::Core::World &world) const -> bool;
+  auto check_no_key_structures(Engine::Core::World &world) -> bool;
 
   VictoryType m_victoryType = VictoryType::Elimination;
   std::vector<QString> m_keyStructures;

game/units/spawn_type.h

@@ -137,7 +137,7 @@ inline auto isTroopSpawn(SpawnType type) -> bool {
   return type != SpawnType::Barracks;
 }
 
-inline auto isBuildingSpawn(SpawnType type) -> bool {
+inline auto is_building_spawn(SpawnType type) -> bool {
   return type == SpawnType::Barracks;
 }
 

game/visuals/visual_catalog.cpp

@@ -103,7 +103,7 @@ auto VisualCatalog::lookup(const std::string &unitType,
 }
 
 void apply_to_renderable(const VisualDef &def,
-                       Engine::Core::RenderableComponent &r) {
+                         Engine::Core::RenderableComponent &r) {
   r.mesh = toRenderableMesh(def.mesh);
   r.color[0] = def.color.x();
   r.color[1] = def.color.y();

game/visuals/visual_catalog.h

@@ -32,6 +32,6 @@ private:
 auto meshKindFromString(const QString &s) -> VisualDef::MeshKind;
 
 void apply_to_renderable(const VisualDef &def,
-                       Engine::Core::RenderableComponent &r);
+                         Engine::Core::RenderableComponent &r);
 
 } // namespace Game::Visuals

render/gl/backend.cpp

@@ -1414,7 +1414,7 @@ void Backend::execute(const DrawQueue &queue, const Camera &cam) {
     case PrimitiveBatchCmdIndex: {
       const auto &batch = std::get<PrimitiveBatchCmdIndex>(cmd);
       if (batch.instance_count() == 0 || m_primitiveBatchPipeline == nullptr ||
-          !m_primitiveBatchPipeline->isInitialized()) {
+          !m_primitiveBatchPipeline->is_initialized()) {
         break;
       }
 

render/gl/backend/README.md

@@ -61,7 +61,7 @@ python3 scripts/validate_shader_uniforms.py
 When creating a new rendering pipeline:
 
 1. Inherit from `IPipeline` interface
-2. Implement `initialize()`, `shutdown()`, `cacheUniforms()`, `isInitialized()`
+2. Implement `initialize()`, `shutdown()`, `cacheUniforms()`, `is_initialized()`
 3. Add validation to ensure uniform names match shader files
 4. Document any shader dependencies
 5. Update this README with the new pipeline

render/gl/backend/character_pipeline.cpp

@@ -34,7 +34,7 @@ auto CharacterPipeline::initialize() -> bool {
 
   cacheUniforms();
 
-  return isInitialized();
+  return is_initialized();
 }
 
 void CharacterPipeline::shutdown() {
@@ -52,7 +52,7 @@ void CharacterPipeline::cacheUniforms() {
   cacheSpearmanUniforms();
 }
 
-auto CharacterPipeline::isInitialized() const -> bool {
+auto CharacterPipeline::is_initialized() const -> bool {
   return m_basicShader != nullptr && m_archerShader != nullptr &&
          m_swordsmanShader != nullptr && m_spearmanShader != nullptr;
 }

render/gl/backend/character_pipeline.h

@@ -19,7 +19,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override;
+  [[nodiscard]] auto is_initialized() const -> bool override;
 
   struct BasicUniforms {
     GL::Shader::UniformHandle mvp{GL::Shader::InvalidUniform};

render/gl/backend/cylinder_pipeline.h

@@ -17,7 +17,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override {
+  [[nodiscard]] auto is_initialized() const -> bool override {
     return m_initialized;
   }
 

render/gl/backend/effects_pipeline.cpp

@@ -24,7 +24,7 @@ auto EffectsPipeline::initialize() -> bool {
 
   cacheUniforms();
 
-  return isInitialized();
+  return is_initialized();
 }
 
 void EffectsPipeline::shutdown() {
@@ -37,7 +37,7 @@ void EffectsPipeline::cacheUniforms() {
   cacheGridUniforms();
 }
 
-auto EffectsPipeline::isInitialized() const -> bool {
+auto EffectsPipeline::is_initialized() const -> bool {
   return m_basicShader != nullptr && m_gridShader != nullptr;
 }
 

render/gl/backend/effects_pipeline.h

@@ -18,7 +18,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override;
+  [[nodiscard]] auto is_initialized() const -> bool override;
 
   struct GridUniforms {
     GL::Shader::UniformHandle mvp{GL::Shader::InvalidUniform};

render/gl/backend/pipeline_interface.h

@@ -15,7 +15,7 @@ public:
 
   virtual void cacheUniforms() = 0;
 
-  [[nodiscard]] virtual auto isInitialized() const -> bool = 0;
+  [[nodiscard]] virtual auto is_initialized() const -> bool = 0;
 };
 
 } // namespace Render::GL::BackendPipelines

render/gl/backend/primitive_batch_pipeline.h

@@ -19,7 +19,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override {
+  [[nodiscard]] auto is_initialized() const -> bool override {
     return m_initialized;
   }
 

render/gl/backend/terrain_pipeline.cpp

@@ -42,7 +42,7 @@ auto TerrainPipeline::initialize() -> bool {
 
   cacheUniforms();
 
-  return isInitialized();
+  return is_initialized();
 }
 
 void TerrainPipeline::shutdown() {
@@ -58,7 +58,7 @@ void TerrainPipeline::cacheUniforms() {
   cacheTerrainUniforms();
 }
 
-auto TerrainPipeline::isInitialized() const -> bool {
+auto TerrainPipeline::is_initialized() const -> bool {
   return m_grassShader != nullptr && m_groundShader != nullptr &&
          m_terrainShader != nullptr && m_grassVao != 0;
 }

render/gl/backend/terrain_pipeline.h

@@ -21,7 +21,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override;
+  [[nodiscard]] auto is_initialized() const -> bool override;
 
   struct GrassUniforms {
     GL::Shader::UniformHandle view_proj{GL::Shader::InvalidUniform};

render/gl/backend/vegetation_pipeline.h

@@ -16,7 +16,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override {
+  [[nodiscard]] auto is_initialized() const -> bool override {
     return m_initialized;
   }
 

render/gl/backend/water_pipeline.cpp

@@ -32,7 +32,7 @@ auto WaterPipeline::initialize() -> bool {
 
   cacheUniforms();
 
-  return isInitialized();
+  return is_initialized();
 }
 
 void WaterPipeline::shutdown() {
@@ -49,7 +49,7 @@ void WaterPipeline::cacheUniforms() {
   cache_road_uniforms();
 }
 
-auto WaterPipeline::isInitialized() const -> bool {
+auto WaterPipeline::is_initialized() const -> bool {
   return m_riverShader != nullptr && m_riverbankShader != nullptr &&
          m_bridgeShader != nullptr && m_road_shader != nullptr;
 }

render/gl/backend/water_pipeline.h

@@ -18,7 +18,7 @@ public:
   auto initialize() -> bool override;
   void shutdown() override;
   void cacheUniforms() override;
-  [[nodiscard]] auto isInitialized() const -> bool override;
+  [[nodiscard]] auto is_initialized() const -> bool override;
 
   struct RiverUniforms {
     GL::Shader::UniformHandle model{GL::Shader::InvalidUniform};

render/gl/camera.cpp

@@ -603,7 +603,7 @@ void Camera::applySoftBoundaries(bool isPanning) {
   }
 
   auto &vis = Game::Map::VisibilityService::instance();
-  if (!vis.isInitialized()) {
+  if (!vis.is_initialized()) {
     return;
   }
 

render/gl/camera.h

@@ -54,7 +54,7 @@ public:
   auto world_to_screen(const QVector3D &world, qreal screenW, qreal screenH,
                        QPointF &outScreen) const -> bool;
 
-  void setFollowEnabled(bool enable) { m_followEnabled = enable; }
+  void set_follow_enabled(bool enable) { m_followEnabled = enable; }
   [[nodiscard]] auto isFollowEnabled() const -> bool { return m_followEnabled; }
   void setFollowLerp(float alpha) { m_followLerp = alpha; }
   void setFollowOffset(const QVector3D &off) { m_followOffset = off; }

render/ground/biome_renderer.cpp

@@ -64,23 +64,23 @@ BiomeRenderer::BiomeRenderer() = default;
 BiomeRenderer::~BiomeRenderer() = default;
 
 void BiomeRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
-                              const Game::Map::BiomeSettings &biomeSettings) {
+                              const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_grassInstances.clear();
   m_grassInstanceBuffer.reset();
   m_grassInstanceCount = 0;
   m_grassInstancesDirty = false;
 
-  m_grassParams.soil_color = m_biomeSettings.soil_color;
-  m_grassParams.wind_strength = m_biomeSettings.sway_strength;
-  m_grassParams.wind_speed = m_biomeSettings.sway_speed;
+  m_grassParams.soil_color = m_biome_settings.soil_color;
+  m_grassParams.wind_strength = m_biome_settings.sway_strength;
+  m_grassParams.wind_speed = m_biome_settings.sway_speed;
   m_grassParams.light_direction = QVector3D(0.35F, 0.8F, 0.45F);
   m_grassParams.time = 0.0F;
 
@@ -131,7 +131,7 @@ void BiomeRenderer::generateGrassInstances() {
     return;
   }
 
-  if (m_biomeSettings.patch_density < 0.01F) {
+  if (m_biome_settings.patch_density < 0.01F) {
     m_grassInstanceCount = 0;
     m_grassInstancesDirty = false;
     return;
@@ -142,7 +142,7 @@ void BiomeRenderer::generateGrassInstances() {
   const float tile_safe = std::max(0.001F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
+      std::clamp(m_biome_settings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
@@ -268,16 +268,17 @@ void BiomeRenderer::generateGrassInstances() {
     float const dryness =
         std::clamp(dryness_noise * 0.6F + slope * 0.4F, 0.0F, 1.0F);
     QVector3D const lush_mix =
-        m_biomeSettings.grass_primary * (1.0F - lush_noise) +
-        m_biomeSettings.grass_secondary * lush_noise;
+        m_biome_settings.grass_primary * (1.0F - lush_noise) +
+        m_biome_settings.grass_secondary * lush_noise;
     QVector3D const color =
-        lush_mix * (1.0F - dryness) + m_biomeSettings.grass_dry * dryness;
-
-    float const height = remap(rand_01(state), m_biomeSettings.blade_height_min,
-                               m_biomeSettings.blade_height_max) *
-                         tile_safe * 0.5F;
-    float const width = remap(rand_01(state), m_biomeSettings.blade_width_min,
-                              m_biomeSettings.blade_width_max) *
+        lush_mix * (1.0F - dryness) + m_biome_settings.grass_dry * dryness;
+
+    float const height =
+        remap(rand_01(state), m_biome_settings.blade_height_min,
+              m_biome_settings.blade_height_max) *
+        tile_safe * 0.5F;
+    float const width = remap(rand_01(state), m_biome_settings.blade_width_min,
+                              m_biome_settings.blade_width_max) *
                         tile_safe;
 
     float const sway_strength = remap(rand_01(state), 0.75F, 1.25F);
@@ -382,7 +383,7 @@ void BiomeRenderer::generateGrassInstances() {
       float const type_bias = 1.0F;
       constexpr float k_cluster_boost = 1.35F;
       float const expected_clusters =
-          std::max(0.0F, m_biomeSettings.patch_density * k_cluster_boost *
+          std::max(0.0F, m_biome_settings.patch_density * k_cluster_boost *
                              slope_penalty * type_bias * usable_coverage);
       int cluster_count = static_cast<int>(std::floor(expected_clusters));
       float const frac = expected_clusters - float(cluster_count);
@@ -394,7 +395,7 @@ void BiomeRenderer::generateGrassInstances() {
         auto chunk_span_x = float(chunk_max_x - chunk_x + 1);
         auto chunk_span_z = float(chunk_max_z - chunk_z + 1);
         float const scatter_base =
-            std::max(0.25F, m_biomeSettings.patch_jitter);
+            std::max(0.25F, m_biome_settings.patch_jitter);
 
         auto pick_cluster_center =
             [&](uint32_t &rng) -> std::optional<QVector2D> {
@@ -456,7 +457,7 @@ void BiomeRenderer::generateGrassInstances() {
   }
 
   const float background_density =
-      std::max(0.0F, m_biomeSettings.background_blade_density);
+      std::max(0.0F, m_biome_settings.background_blade_density);
   if (background_density > 0.0F) {
     for (int z = 0; z < m_height; ++z) {
       for (int x = 0; x < m_width; ++x) {

render/ground/biome_renderer.h

@@ -18,7 +18,7 @@ public:
   ~BiomeRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -35,7 +35,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<GrassInstanceGpu> m_grassInstances;

render/ground/bridge_renderer.cpp

@@ -220,7 +220,7 @@ void BridgeRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   Q_UNUSED(resources);
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
 
   auto *shader = renderer.get_shader("bridge");
   if (shader == nullptr) {

render/ground/firecamp_renderer.cpp

@@ -58,14 +58,14 @@ FireCampRenderer::~FireCampRenderer() = default;
 
 void FireCampRenderer::configure(
     const Game::Map::TerrainHeightMap &height_map,
-    const Game::Map::BiomeSettings &biomeSettings) {
+    const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_fireCampInstances.clear();
   m_fireCampInstanceBuffer.reset();
@@ -92,7 +92,7 @@ void FireCampRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
   const std::uint64_t current_version =
       use_visibility ? visibility.version() : 0;
 
@@ -261,7 +261,7 @@ void FireCampRenderer::generateFireCampInstances() {
   const float tile_safe = std::max(0.1F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
+      std::clamp(m_biome_settings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 

render/ground/firecamp_renderer.h

@@ -18,7 +18,7 @@ public:
   ~FireCampRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void setExplicitFireCamps(const std::vector<QVector3D> &positions,
                             const std::vector<float> &intensities = {},
@@ -38,7 +38,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<FireCampInstanceGpu> m_fireCampInstances;

render/ground/ground_renderer.cpp

@@ -43,7 +43,7 @@ void GroundRenderer::updateNoiseOffset() {
   const float span_x = (m_width > 0 ? float(m_width) * m_tile_size : m_extent);
   const float span_z =
       (m_height > 0 ? float(m_height) * m_tile_size : m_extent);
-  const auto seed = static_cast<float>(m_biomeSettings.seed % 1024U);
+  const auto seed = static_cast<float>(m_biome_settings.seed % 1024U);
 
   QVector2D new_offset;
   new_offset.setX(span_x * 0.37F + seed * 0.21F);
@@ -64,52 +64,52 @@ auto GroundRenderer::buildParams() const -> TerrainChunkParams {
 
   TerrainChunkParams params;
 
-  const QVector3D primary = m_biomeSettings.grass_primary * 0.97F;
-  const QVector3D secondary = m_biomeSettings.grass_secondary * 0.93F;
-  const QVector3D dry = m_biomeSettings.grass_dry * 0.90F;
-  const QVector3D soil = m_biomeSettings.soil_color * 0.68F;
+  const QVector3D primary = m_biome_settings.grass_primary * 0.97F;
+  const QVector3D secondary = m_biome_settings.grass_secondary * 0.93F;
+  const QVector3D dry = m_biome_settings.grass_dry * 0.90F;
+  const QVector3D soil = m_biome_settings.soil_color * 0.68F;
 
   params.grass_primary = saturate(primary);
   params.grass_secondary = saturate(secondary);
   params.grass_dry = saturate(dry);
   params.soil_color = saturate(soil);
-  params.rock_low = saturate(m_biomeSettings.rock_low);
-  params.rock_high = saturate(m_biomeSettings.rock_high);
+  params.rock_low = saturate(m_biome_settings.rock_low);
+  params.rock_high = saturate(m_biome_settings.rock_high);
 
   params.tint = QVector3D(0.96F, 0.98F, 0.96F);
 
   params.tile_size = std::max(0.25F, m_tile_size);
 
   params.macro_noise_scale =
-      std::max(0.012F, m_biomeSettings.terrain_macro_noise_scale * 0.60F);
+      std::max(0.012F, m_biome_settings.terrain_macro_noise_scale * 0.60F);
   params.detail_noise_scale =
-      std::max(0.045F, m_biomeSettings.terrain_detail_noise_scale * 0.75F);
+      std::max(0.045F, m_biome_settings.terrain_detail_noise_scale * 0.75F);
 
   params.slope_rock_threshold =
-      std::clamp(m_biomeSettings.terrain_rock_threshold + 0.30F, 0.40F, 0.90F);
+      std::clamp(m_biome_settings.terrain_rock_threshold + 0.30F, 0.40F, 0.90F);
   params.slope_rock_sharpness =
-      std::clamp(m_biomeSettings.terrain_rock_sharpness + 1.5F, 2.0F, 6.0F);
+      std::clamp(m_biome_settings.terrain_rock_sharpness + 1.5F, 2.0F, 6.0F);
 
-  params.soil_blend_height = m_biomeSettings.terrain_soil_height - 1.25F;
+  params.soil_blend_height = m_biome_settings.terrain_soil_height - 1.25F;
   params.soil_blend_sharpness =
-      std::clamp(m_biomeSettings.terrain_soil_sharpness * 0.75F, 1.5F, 5.0F);
+      std::clamp(m_biome_settings.terrain_soil_sharpness * 0.75F, 1.5F, 5.0F);
 
   params.noise_offset = m_noiseOffset;
   params.noise_angle = m_noiseAngle;
 
   float target_amp;
   float target_freq;
-  if (m_biomeSettings.ground_irregularity_enabled) {
+  if (m_biome_settings.ground_irregularity_enabled) {
 
-    target_amp = std::clamp(m_biomeSettings.irregularity_amplitude * 0.85F,
+    target_amp = std::clamp(m_biome_settings.irregularity_amplitude * 0.85F,
                             0.15F, 0.70F);
-    target_freq = std::max(0.45F, m_biomeSettings.irregularity_scale * 2.5F);
+    target_freq = std::max(0.45F, m_biome_settings.irregularity_scale * 2.5F);
   } else {
 
-    target_amp = std::clamp(m_biomeSettings.height_noise_amplitude * 0.22F,
+    target_amp = std::clamp(m_biome_settings.height_noise_amplitude * 0.22F,
                             0.10F, 0.20F);
     target_freq =
-        std::max(0.6F, m_biomeSettings.height_noise_frequency * 1.05F);
+        std::max(0.6F, m_biome_settings.height_noise_frequency * 1.05F);
   }
   params.height_noise_strength = target_amp;
   params.height_noise_frequency = target_freq;
@@ -120,27 +120,27 @@ auto GroundRenderer::buildParams() const -> TerrainChunkParams {
 
   params.albedo_jitter = 0.05F;
 
-  params.ambient_boost = m_biomeSettings.terrain_ambient_boost * 0.85F;
+  params.ambient_boost = m_biome_settings.terrain_ambient_boost * 0.85F;
 
   params.rock_detail_strength =
-      m_biomeSettings.terrain_rock_detail_strength * 0.18F;
+      m_biome_settings.terrain_rock_detail_strength * 0.18F;
 
   QVector3D const l(0.35F, 0.85F, 0.42F);
   params.light_direction = l.normalized();
 
   params.is_ground_plane = true;
 
-  params.snow_coverage = std::clamp(m_biomeSettings.snow_coverage, 0.0F, 1.0F);
+  params.snow_coverage = std::clamp(m_biome_settings.snow_coverage, 0.0F, 1.0F);
   params.moisture_level =
-      std::clamp(m_biomeSettings.moisture_level, 0.0F, 1.0F);
+      std::clamp(m_biome_settings.moisture_level, 0.0F, 1.0F);
   params.crack_intensity =
-      std::clamp(m_biomeSettings.crack_intensity, 0.0F, 1.0F);
-  params.rock_exposure = std::clamp(m_biomeSettings.rock_exposure, 0.0F, 1.0F);
+      std::clamp(m_biome_settings.crack_intensity, 0.0F, 1.0F);
+  params.rock_exposure = std::clamp(m_biome_settings.rock_exposure, 0.0F, 1.0F);
   params.grass_saturation =
-      std::clamp(m_biomeSettings.grass_saturation, 0.0F, 1.5F);
+      std::clamp(m_biome_settings.grass_saturation, 0.0F, 1.5F);
   params.soil_roughness =
-      std::clamp(m_biomeSettings.soil_roughness, 0.0F, 1.0F);
-  params.snow_color = saturate(m_biomeSettings.snow_color);
+      std::clamp(m_biome_settings.soil_roughness, 0.0F, 1.0F);
+  params.snow_color = saturate(m_biome_settings.snow_color);
 
   m_cachedParams = params;
   m_cachedParamsValid = true;
@@ -184,12 +184,12 @@ void GroundRenderer::submit(Renderer &renderer, ResourceManager *resources) {
 
 void GroundRenderer::syncBiomeFromService() {
   auto &service = Game::Map::TerrainService::instance();
-  if (!service.isInitialized()) {
+  if (!service.is_initialized()) {
     return;
   }
-  const auto &current = service.biomeSettings();
-  if (!m_hasBiome || !biomeEquals(current, m_biomeSettings)) {
-    m_biomeSettings = current;
+  const auto &current = service.biome_settings();
+  if (!m_hasBiome || !biomeEquals(current, m_biome_settings)) {
+    m_biome_settings = current;
     m_hasBiome = true;
     updateNoiseOffset();
     invalidateParamsCache();

render/ground/ground_renderer.h

@@ -38,7 +38,7 @@ public:
   void setColor(const QVector3D &c) { m_color = c; }
 
   void setBiome(const Game::Map::BiomeSettings &settings) {
-    m_biomeSettings = settings;
+    m_biome_settings = settings;
     m_hasBiome = true;
     updateNoiseOffset();
 
@@ -62,7 +62,7 @@ private:
 
   QVector3D m_color{0.15F, 0.18F, 0.15F};
   QMatrix4x4 m_model;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   bool m_hasBiome = false;
   QVector2D m_noiseOffset{0.0F, 0.0F};
   float m_noiseAngle = 0.0F;

render/ground/olive_renderer.cpp

@@ -46,14 +46,14 @@ OliveRenderer::OliveRenderer() = default;
 OliveRenderer::~OliveRenderer() = default;
 
 void OliveRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
-                              const Game::Map::BiomeSettings &biomeSettings) {
+                              const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_oliveInstances.clear();
   m_oliveInstanceBuffer.reset();
@@ -80,7 +80,7 @@ void OliveRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
   const std::uint64_t current_version =
       use_visibility ? visibility.version() : 0;
 
@@ -141,7 +141,7 @@ void OliveRenderer::generate_olive_instances() {
     return;
   }
 
-  if (m_biomeSettings.ground_type != Game::Map::GroundType::GrassDry) {
+  if (m_biome_settings.ground_type != Game::Map::GroundType::GrassDry) {
     m_oliveInstancesDirty = false;
     return;
   }
@@ -151,19 +151,19 @@ void OliveRenderer::generate_olive_instances() {
   const float tile_safe = std::max(0.1F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
+      std::clamp(m_biome_settings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
   float olive_density =
-      (m_biomeSettings.ground_type == Game::Map::GroundType::GrassDry) ? 0.12F
-                                                                       : 0.05F;
-  if (m_biomeSettings.plant_density > 0.0F) {
+      (m_biome_settings.ground_type == Game::Map::GroundType::GrassDry) ? 0.12F
+                                                                        : 0.05F;
+  if (m_biome_settings.plant_density > 0.0F) {
     float const density_mult =
-        (m_biomeSettings.ground_type == Game::Map::GroundType::GrassDry)
+        (m_biome_settings.ground_type == Game::Map::GroundType::GrassDry)
             ? 0.15F
             : 0.08F;
-    olive_density = m_biomeSettings.plant_density * density_mult;
+    olive_density = m_biome_settings.plant_density * density_mult;
   }
 
   std::vector<QVector3D> normals(static_cast<qsizetype>(m_width * m_height),
@@ -240,7 +240,7 @@ void OliveRenderer::generate_olive_instances() {
     float const base_scale = remap(rand_01(state), 2.8F, 5.5F) * tile_safe;
     float const dry_scale = remap(rand_01(state), 3.2F, 6.5F) * tile_safe;
     float const chosen_scale =
-        (m_biomeSettings.ground_type == Game::Map::GroundType::GrassDry)
+        (m_biome_settings.ground_type == Game::Map::GroundType::GrassDry)
             ? dry_scale
             : base_scale;
 

render/ground/olive_renderer.h

@@ -18,7 +18,7 @@ public:
   ~OliveRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -33,7 +33,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<OliveInstanceGpu> m_oliveInstances;

render/ground/pine_renderer.cpp

@@ -46,14 +46,14 @@ PineRenderer::PineRenderer() = default;
 PineRenderer::~PineRenderer() = default;
 
 void PineRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
-                             const Game::Map::BiomeSettings &biomeSettings) {
+                             const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_pineInstances.clear();
   m_pineInstanceBuffer.reset();
@@ -80,7 +80,7 @@ void PineRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
   const std::uint64_t current_version =
       use_visibility ? visibility.version() : 0;
 
@@ -141,7 +141,7 @@ void PineRenderer::generatePineInstances() {
     return;
   }
 
-  if (m_biomeSettings.ground_type == Game::Map::GroundType::GrassDry) {
+  if (m_biome_settings.ground_type == Game::Map::GroundType::GrassDry) {
     m_pineInstancesDirty = false;
     return;
   }
@@ -151,14 +151,14 @@ void PineRenderer::generatePineInstances() {
   const float tile_safe = std::max(0.1F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
+      std::clamp(m_biome_settings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
   float pine_density = 0.2F;
-  if (m_biomeSettings.plant_density > 0.0F) {
+  if (m_biome_settings.plant_density > 0.0F) {
 
-    pine_density = m_biomeSettings.plant_density * 0.3F;
+    pine_density = m_biome_settings.plant_density * 0.3F;
   }
 
   std::vector<QVector3D> normals(static_cast<qsizetype>(m_width * m_height),

render/ground/pine_renderer.h

@@ -18,7 +18,7 @@ public:
   ~PineRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -33,7 +33,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<PineInstanceGpu> m_pineInstances;

render/ground/plant_renderer.cpp

@@ -46,14 +46,14 @@ PlantRenderer::PlantRenderer() = default;
 PlantRenderer::~PlantRenderer() = default;
 
 void PlantRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
-                              const Game::Map::BiomeSettings &biomeSettings) {
+                              const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_plantInstances.clear();
   m_plantInstanceBuffer.reset();
@@ -62,8 +62,8 @@ void PlantRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
 
   m_plantParams.light_direction = QVector3D(0.35F, 0.8F, 0.45F);
   m_plantParams.time = 0.0F;
-  m_plantParams.wind_strength = m_biomeSettings.sway_strength;
-  m_plantParams.wind_speed = m_biomeSettings.sway_speed;
+  m_plantParams.wind_strength = m_biome_settings.sway_strength;
+  m_plantParams.wind_speed = m_biome_settings.sway_speed;
 
   generatePlantInstances();
 }
@@ -80,7 +80,7 @@ void PlantRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   }
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
   const std::uint64_t current_version =
       use_visibility ? visibility.version() : 0;
 
@@ -147,7 +147,7 @@ void PlantRenderer::generatePlantInstances() {
   }
 
   const float plant_density =
-      std::clamp(m_biomeSettings.plant_density, 0.0F, 2.0F);
+      std::clamp(m_biome_settings.plant_density, 0.0F, 2.0F);
 
   if (plant_density < 0.01F) {
     m_plantInstanceCount = 0;
@@ -160,7 +160,7 @@ void PlantRenderer::generatePlantInstances() {
   const float tile_safe = std::max(0.001F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
+      std::clamp(m_biome_settings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
@@ -275,8 +275,8 @@ void PlantRenderer::generatePlantInstances() {
     float const plant_type = std::floor(rand_01(state) * 4.0F);
 
     float const color_var = remap(rand_01(state), 0.0F, 1.0F);
-    QVector3D const base_color = m_biomeSettings.grass_primary * 0.7F;
-    QVector3D const var_color = m_biomeSettings.grass_secondary * 0.8F;
+    QVector3D const base_color = m_biome_settings.grass_primary * 0.7F;
+    QVector3D const var_color = m_biome_settings.grass_secondary * 0.8F;
     QVector3D tint_color =
         base_color * (1.0F - color_var) + var_color * color_var;
 

render/ground/plant_renderer.h

@@ -18,7 +18,7 @@ public:
   ~PlantRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -33,7 +33,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<PlantInstanceGpu> m_plantInstances;

render/ground/river_renderer.cpp

@@ -160,7 +160,7 @@ void RiverRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   Q_UNUSED(resources);
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
 
   auto *shader = renderer.get_shader("river");
   if (shader == nullptr) {

render/ground/riverbank_asset_renderer.cpp

@@ -47,15 +47,15 @@ RiverbankAssetRenderer::~RiverbankAssetRenderer() = default;
 void RiverbankAssetRenderer::configure(
     const std::vector<Game::Map::RiverSegment> &riverSegments,
     const Game::Map::TerrainHeightMap &height_map,
-    const Game::Map::BiomeSettings &biomeSettings) {
+    const Game::Map::BiomeSettings &biome_settings) {
   m_riverSegments = riverSegments;
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_assetInstances.clear();
   m_assetInstanceBuffer.reset();
@@ -76,7 +76,7 @@ void RiverbankAssetRenderer::submit(Renderer &, ResourceManager *resources) {
   }
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
   const std::uint64_t current_version =
       use_visibility ? visibility.version() : 0;
 

render/ground/riverbank_asset_renderer.h

@@ -19,7 +19,7 @@ public:
 
   void configure(const std::vector<Game::Map::RiverSegment> &riverSegments,
                  const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -35,7 +35,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<RiverbankAssetInstanceGpu> m_assetInstances;

render/ground/riverbank_renderer.cpp

@@ -248,7 +248,7 @@ void RiverbankRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   Q_UNUSED(resources);
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
 
   auto *shader = renderer.get_shader("riverbank");
   if (shader == nullptr) {

render/ground/road_renderer.cpp

@@ -153,7 +153,7 @@ void RoadRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   Q_UNUSED(resources);
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
 
   auto *shader = renderer.get_shader("road");
   if (shader == nullptr) {

render/ground/stone_renderer.cpp

@@ -48,14 +48,14 @@ StoneRenderer::StoneRenderer() = default;
 StoneRenderer::~StoneRenderer() = default;
 
 void StoneRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
-                              const Game::Map::BiomeSettings &biomeSettings) {
+                              const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
 
   m_stoneInstances.clear();
   m_stoneInstanceBuffer.reset();
@@ -111,7 +111,7 @@ void StoneRenderer::generateStoneInstances() {
   const float tile_safe = std::max(0.001F, m_tile_size);
 
   const float edge_padding =
-      std::clamp(m_biomeSettings.spawn_edge_padding, 0.0F, 0.5F);
+      std::clamp(m_biome_settings.spawn_edge_padding, 0.0F, 0.5F);
   const float edge_margin_x = static_cast<float>(m_width) * edge_padding;
   const float edge_margin_z = static_cast<float>(m_height) * edge_padding;
 
@@ -212,8 +212,8 @@ void StoneRenderer::generateStoneInstances() {
     float const scale = remap(rand_01(state), 0.08F, 0.25F) * tile_safe;
 
     float const color_var = remap(rand_01(state), 0.0F, 1.0F);
-    QVector3D const base_rock = m_biomeSettings.rock_low;
-    QVector3D const high_rock = m_biomeSettings.rock_high;
+    QVector3D const base_rock = m_biome_settings.rock_low;
+    QVector3D const high_rock = m_biome_settings.rock_high;
     QVector3D color = base_rock * (1.0F - color_var) + high_rock * color_var;
 
     float const brown_mix = remap(rand_01(state), 0.0F, 0.4F);

render/ground/stone_renderer.h

@@ -18,7 +18,7 @@ public:
   ~StoneRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -33,7 +33,7 @@ private:
 
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 
   std::vector<StoneInstanceGpu> m_stoneInstances;

render/ground/terrain_renderer.cpp

@@ -78,16 +78,17 @@ namespace Render::GL {
 TerrainRenderer::TerrainRenderer() = default;
 TerrainRenderer::~TerrainRenderer() = default;
 
-void TerrainRenderer::configure(const Game::Map::TerrainHeightMap &height_map,
-                                const Game::Map::BiomeSettings &biomeSettings) {
+void TerrainRenderer::configure(
+    const Game::Map::TerrainHeightMap &height_map,
+    const Game::Map::BiomeSettings &biome_settings) {
   m_width = height_map.getWidth();
   m_height = height_map.getHeight();
   m_tile_size = height_map.getTileSize();
 
   m_heightData = height_map.getHeightData();
   m_terrain_types = height_map.getTerrainTypes();
-  m_biomeSettings = biomeSettings;
-  m_noiseSeed = biomeSettings.seed;
+  m_biome_settings = biome_settings;
+  m_noiseSeed = biome_settings.seed;
   buildMeshes();
 }
 
@@ -99,7 +100,7 @@ void TerrainRenderer::submit(Renderer &renderer, ResourceManager *resources) {
   Q_UNUSED(resources);
 
   auto &visibility = Game::Map::VisibilityService::instance();
-  const bool use_visibility = visibility.isInitialized();
+  const bool use_visibility = visibility.is_initialized();
 
   for (const auto &chunk : m_chunks) {
     if (!chunk.mesh) {
@@ -551,7 +552,7 @@ void TerrainRenderer::buildMeshes() {
 
         QVector3D const base_color =
             getTerrainColor(chunk.type, chunk.averageHeight);
-        QVector3D const rock_tint = m_biomeSettings.rock_low;
+        QVector3D const rock_tint = m_biome_settings.rock_low;
 
         float slope_mix = std::clamp(
             avg_slope * ((chunk.type == Game::Map::TerrainType::Flat) ? 0.30F
@@ -612,18 +613,18 @@ void TerrainRenderer::buildMeshes() {
         auto tint_color = [&](const QVector3D &base) {
           return clamp01(applyTint(base, chunk.tint));
         };
-        params.grass_primary = tint_color(m_biomeSettings.grass_primary);
-        params.grass_secondary = tint_color(m_biomeSettings.grass_secondary);
-        params.grass_dry = tint_color(m_biomeSettings.grass_dry);
-        params.soil_color = tint_color(m_biomeSettings.soil_color);
-        params.rock_low = tint_color(m_biomeSettings.rock_low);
-        params.rock_high = tint_color(m_biomeSettings.rock_high);
+        params.grass_primary = tint_color(m_biome_settings.grass_primary);
+        params.grass_secondary = tint_color(m_biome_settings.grass_secondary);
+        params.grass_dry = tint_color(m_biome_settings.grass_dry);
+        params.soil_color = tint_color(m_biome_settings.soil_color);
+        params.rock_low = tint_color(m_biome_settings.rock_low);
+        params.rock_high = tint_color(m_biome_settings.rock_high);
 
         params.tile_size = std::max(0.001F, m_tile_size);
-        params.macro_noise_scale = m_biomeSettings.terrain_macro_noise_scale;
-        params.detail_noise_scale = m_biomeSettings.terrain_detail_noise_scale;
+        params.macro_noise_scale = m_biome_settings.terrain_macro_noise_scale;
+        params.detail_noise_scale = m_biome_settings.terrain_detail_noise_scale;
 
-        float slope_threshold = m_biomeSettings.terrain_rock_threshold;
+        float slope_threshold = m_biome_settings.terrain_rock_threshold;
         float sharpness_mul = 1.0F;
         if (chunk.type == Game::Map::TerrainType::Hill) {
           slope_threshold -= 0.08F;
@@ -640,9 +641,9 @@ void TerrainRenderer::buildMeshes() {
 
         params.slope_rock_threshold = slope_threshold;
         params.slope_rock_sharpness = std::max(
-            1.0F, m_biomeSettings.terrain_rock_sharpness * sharpness_mul);
+            1.0F, m_biome_settings.terrain_rock_sharpness * sharpness_mul);
 
-        float soil_height = m_biomeSettings.terrain_soil_height;
+        float soil_height = m_biome_settings.terrain_soil_height;
         if (chunk.type == Game::Map::TerrainType::Hill) {
           soil_height -= 0.06F;
         } else if (chunk.type == Game::Map::TerrainType::Mountain) {
@@ -652,7 +653,7 @@ void TerrainRenderer::buildMeshes() {
         params.soil_blend_height = soil_height;
 
         params.soil_blend_sharpness =
-            std::max(0.75F, m_biomeSettings.terrain_soil_sharpness *
+            std::max(0.75F, m_biome_settings.terrain_soil_sharpness *
                                 (chunk.type == Game::Map::TerrainType::Mountain
                                      ? 0.80F
                                      : 0.95F));
@@ -667,7 +668,7 @@ void TerrainRenderer::buildMeshes() {
                       hash_to_01(noise_key_b) * k_noise_offset_scale);
 
         float base_amp =
-            m_biomeSettings.height_noise_amplitude *
+            m_biome_settings.height_noise_amplitude *
             (0.7F + 0.3F * std::clamp(roughness * 0.6F, 0.0F, 1.0F));
         if (chunk.type == Game::Map::TerrainType::Mountain) {
           base_amp *= 1.25F;
@@ -675,13 +676,13 @@ void TerrainRenderer::buildMeshes() {
         base_amp *= (1.0F + 0.10F * edge_factor - 0.08F * plateau_factor -
                      0.06F * entrance_factor);
         params.height_noise_strength = base_amp;
-        params.height_noise_frequency = m_biomeSettings.height_noise_frequency;
+        params.height_noise_frequency = m_biome_settings.height_noise_frequency;
 
         params.ambient_boost =
-            m_biomeSettings.terrain_ambient_boost *
+            m_biome_settings.terrain_ambient_boost *
             ((chunk.type == Game::Map::TerrainType::Mountain) ? 0.90F : 0.95F);
         params.rock_detail_strength =
-            m_biomeSettings.terrain_rock_detail_strength *
+            m_biome_settings.terrain_rock_detail_strength *
             (0.75F + 0.35F * std::clamp(avg_slope * 1.2F, 0.0F, 1.0F) +
              0.15F * edge_factor - 0.10F * plateau_factor -
              0.08F * entrance_factor);
@@ -703,25 +704,25 @@ auto TerrainRenderer::getTerrainColor(Game::Map::TerrainType type,
   switch (type) {
   case Game::Map::TerrainType::Mountain:
     if (height > 4.0F) {
-      return m_biomeSettings.rock_high;
+      return m_biome_settings.rock_high;
     }
-    return m_biomeSettings.rock_low;
+    return m_biome_settings.rock_low;
   case Game::Map::TerrainType::Hill: {
     float const t = std::clamp(height / 3.0F, 0.0F, 1.0F);
-    QVector3D const grass = m_biomeSettings.grass_secondary * (1.0F - t) +
-                            m_biomeSettings.grass_dry * t;
+    QVector3D const grass = m_biome_settings.grass_secondary * (1.0F - t) +
+                            m_biome_settings.grass_dry * t;
     QVector3D const rock =
-        m_biomeSettings.rock_low * (1.0F - t) + m_biomeSettings.rock_high * t;
+        m_biome_settings.rock_low * (1.0F - t) + m_biome_settings.rock_high * t;
     float const rock_blend = std::clamp(0.25F + 0.5F * t, 0.0F, 0.75F);
     return grass * (1.0F - rock_blend) + rock * rock_blend;
   }
   case Game::Map::TerrainType::Flat:
   default: {
     float const moisture = std::clamp((height - 0.5F) * 0.2F, 0.0F, 0.4F);
-    QVector3D const base = m_biomeSettings.grass_primary * (1.0F - moisture) +
-                           m_biomeSettings.grass_secondary * moisture;
+    QVector3D const base = m_biome_settings.grass_primary * (1.0F - moisture) +
+                           m_biome_settings.grass_secondary * moisture;
     float const dry_blend = std::clamp((height - 2.0F) * 0.12F, 0.0F, 0.3F);
-    return base * (1.0F - dry_blend) + m_biomeSettings.grass_dry * dry_blend;
+    return base * (1.0F - dry_blend) + m_biome_settings.grass_dry * dry_blend;
   }
   }
 }

render/ground/terrain_renderer.h

@@ -23,7 +23,7 @@ public:
   ~TerrainRenderer() override;
 
   void configure(const Game::Map::TerrainHeightMap &height_map,
-                 const Game::Map::BiomeSettings &biomeSettings);
+                 const Game::Map::BiomeSettings &biome_settings);
 
   void submit(Renderer &renderer, ResourceManager *resources) override;
 
@@ -64,7 +64,7 @@ private:
   std::vector<float> m_heightData;
   std::vector<Game::Map::TerrainType> m_terrain_types;
   std::vector<ChunkMesh> m_chunks;
-  Game::Map::BiomeSettings m_biomeSettings;
+  Game::Map::BiomeSettings m_biome_settings;
   std::uint32_t m_noiseSeed = 0U;
 };
 

render/humanoid/rig.cpp

@@ -1594,12 +1594,12 @@ void HumanoidRendererBase::render(const DrawContext &ctx,
 
         auto &terrain_service = Game::Map::TerrainService::instance();
 
-        if (terrain_service.isInitialized()) {
+        if (terrain_service.is_initialized()) {
 
           QVector3D const instPos =
               inst_ctx.model.map(QVector3D(0.0F, 0.0F, 0.0F));
           float const shadowY =
-              terrain_service.getTerrainHeight(instPos.x(), instPos.z());
+              terrain_service.get_terrain_height(instPos.x(), instPos.z());
 
           QVector3D light_dir = k_shadow_light_dir.normalized();
           QVector2D light_dir_xz(light_dir.x(), light_dir.z());

render/scene_renderer.cpp

@@ -325,7 +325,7 @@ void Renderer::enqueue_selection_ring(
     if (troop_type_opt) {
       const auto &nation_reg = Game::Systems::NationRegistry::instance();
       const Game::Systems::Nation *nation =
-          nation_reg.getNationForPlayer(unit_comp->owner_id);
+          nation_reg.get_nation_for_player(unit_comp->owner_id);
       Game::Systems::NationID nation_id =
           nation != nullptr ? nation->id : nation_reg.default_nation_id();
 
@@ -353,8 +353,8 @@ void Renderer::enqueue_selection_ring(
                 transform->position.z);
   auto &terrain_service = Game::Map::TerrainService::instance();
   float terrain_y = transform->position.y;
-  if (terrain_service.isInitialized()) {
-    terrain_y = terrain_service.getTerrainHeight(pos.x(), pos.z());
+  if (terrain_service.is_initialized()) {
+    terrain_y = terrain_service.get_terrain_height(pos.x(), pos.z());
   } else {
     terrain_y -= ground_offset * scale_y;
   }
@@ -382,7 +382,7 @@ void Renderer::render_world(Engine::Core::World *world) {
   std::lock_guard<std::recursive_mutex> const guard(world->get_entity_mutex());
 
   auto &vis = Game::Map::VisibilityService::instance();
-  const bool visibility_enabled = vis.isInitialized();
+  const bool visibility_enabled = vis.is_initialized();
 
   auto renderable_entities =
       world->get_entities_with<Engine::Core::RenderableComponent>();