Refactor serialization system to use snake_case naming convention

Co-authored-by: djeada <[email protected]>

app/core/game_engine.cpp

@@ -1197,7 +1197,7 @@ void GameEngine::start_skirmish(const QString &map_path,
 
 void GameEngine::open_settings() {
   if (m_saveLoadService) {
-    m_saveLoadService->openSettings();
+    m_saveLoadService->open_settings();
   }
 }
 
@@ -1224,12 +1224,12 @@ auto GameEngine::load_from_slot(const QString &slot) -> bool {
   m_runtime.loading = true;
 
   if (!m_saveLoadService->load_game_from_slot(*m_world, slot)) {
-    set_error(m_saveLoadService->getLastError());
+    set_error(m_saveLoadService->get_last_error());
     m_runtime.loading = false;
     return false;
   }
 
-  const QJsonObject meta = m_saveLoadService->getLastMetadata();
+  const QJsonObject meta = m_saveLoadService->get_last_metadata();
 
   Game::Systems::GameStateSerializer::restoreLevelFromMetadata(meta, m_level);
   Game::Systems::GameStateSerializer::restoreCameraFromMetadata(
@@ -1288,9 +1288,9 @@ auto GameEngine::save_to_slot(const QString &slot,
       *m_world, m_camera.get(), m_level, runtime_snap);
   meta["title"] = title;
   const QByteArray screenshot = capture_screenshot();
-  if (!m_saveLoadService->saveGameToSlot(*m_world, slot, title,
+  if (!m_saveLoadService->save_game_to_slot(*m_world, slot, title,
                                          m_level.map_name, meta, screenshot)) {
-    set_error(m_saveLoadService->getLastError());
+    set_error(m_saveLoadService->get_last_error());
     return false;
   }
   emit save_slots_changed();
@@ -1314,10 +1314,10 @@ auto GameEngine::delete_save_slot(const QString &slotName) -> bool {
     return false;
   }
 
-  bool const success = m_saveLoadService->deleteSaveSlot(slotName);
+  bool const success = m_saveLoadService->delete_save_slot(slotName);
 
   if (!success) {
-    QString const error = m_saveLoadService->getLastError();
+    QString const error = m_saveLoadService->get_last_error();
     qWarning() << "Failed to delete save slot:" << error;
     set_error(error);
   } else {
@@ -1358,7 +1358,7 @@ auto GameEngine::capture_screenshot() const -> QByteArray { return {}; }
 
 void GameEngine::exit_game() {
   if (m_saveLoadService) {
-    m_saveLoadService->exitGame();
+    m_saveLoadService->exit_game();
   }
 }
 

game/core/serialization.cpp

@@ -35,7 +35,7 @@ namespace Engine::Core {
 
 namespace {
 
-auto combatModeToString(AttackComponent::CombatMode mode) -> QString {
+auto combat_mode_to_string(AttackComponent::CombatMode mode) -> QString {
   switch (mode) {
   case AttackComponent::CombatMode::Melee:
     return "melee";
@@ -47,7 +47,7 @@ auto combatModeToString(AttackComponent::CombatMode mode) -> QString {
   }
 }
 
-auto combatModeFromString(const QString &value) -> AttackComponent::CombatMode {
+auto combat_mode_from_string(const QString &value) -> AttackComponent::CombatMode {
   if (value == "melee") {
     return AttackComponent::CombatMode::Melee;
   }
@@ -57,7 +57,7 @@ auto combatModeFromString(const QString &value) -> AttackComponent::CombatMode {
   return AttackComponent::CombatMode::Auto;
 }
 
-auto serializeColor(const std::array<float, 3> &color) -> QJsonArray {
+auto serialize_color(const std::array<float, 3> &color) -> QJsonArray {
   QJsonArray array;
   array.append(color[0]);
   array.append(color[1]);
@@ -65,7 +65,7 @@ auto serializeColor(const std::array<float, 3> &color) -> QJsonArray {
   return array;
 }
 
-void deserializeColor(const QJsonArray &array, std::array<float, 3> &color) {
+void deserialize_color(const QJsonArray &array, std::array<float, 3> &color) {
   if (array.size() >= 3) {
     color[0] = static_cast<float>(array.at(0).toDouble());
     color[1] = static_cast<float>(array.at(1).toDouble());
@@ -75,7 +75,7 @@ void deserializeColor(const QJsonArray &array, std::array<float, 3> &color) {
 
 } // namespace
 
-auto Serialization::serializeEntity(const Entity *entity) -> QJsonObject {
+auto Serialization::serialize_entity(const Entity *entity) -> QJsonObject {
   QJsonObject entity_obj;
   entity_obj["id"] = static_cast<qint64>(entity->get_id());
 
@@ -106,7 +106,7 @@ auto Serialization::serializeEntity(const Entity *entity) -> QJsonObject {
     }
     renderable_obj["visible"] = renderable->visible;
     renderable_obj["mesh"] = static_cast<int>(renderable->mesh);
-    renderable_obj["color"] = serializeColor(renderable->color);
+    renderable_obj["color"] = serialize_color(renderable->color);
     entity_obj["renderable"] = renderable_obj;
   }
 
@@ -161,8 +161,8 @@ auto Serialization::serializeEntity(const Entity *entity) -> QJsonObject {
     attack_obj["melee_range"] = attack->melee_range;
     attack_obj["melee_damage"] = attack->melee_damage;
     attack_obj["melee_cooldown"] = attack->melee_cooldown;
-    attack_obj["preferred_mode"] = combatModeToString(attack->preferred_mode);
-    attack_obj["current_mode"] = combatModeToString(attack->current_mode);
+    attack_obj["preferred_mode"] = combat_mode_to_string(attack->preferred_mode);
+    attack_obj["current_mode"] = combat_mode_to_string(attack->current_mode);
     attack_obj["can_melee"] = attack->can_melee;
     attack_obj["can_ranged"] = attack->can_ranged;
     attack_obj["max_height_difference"] = attack->max_height_difference;
@@ -283,7 +283,7 @@ auto Serialization::serializeEntity(const Entity *entity) -> QJsonObject {
   return entity_obj;
 }
 
-void Serialization::deserializeEntity(Entity *entity, const QJsonObject &json) {
+void Serialization::deserialize_entity(Entity *entity, const QJsonObject &json) {
   if (json.contains("transform")) {
     const auto transform_obj = json["transform"].toObject();
     auto *transform = entity->add_component<TransformComponent>();
@@ -324,7 +324,7 @@ void Serialization::deserializeEntity(Entity *entity, const QJsonObject &json) {
         static_cast<RenderableComponent::MeshKind>(renderable_obj["mesh"].toInt(
             static_cast<int>(RenderableComponent::MeshKind::Cube)));
     if (renderable_obj.contains("color")) {
-      deserializeColor(renderable_obj["color"].toArray(), renderable->color);
+      deserialize_color(renderable_obj["color"].toArray(), renderable->color);
     }
   }
 
@@ -411,9 +411,9 @@ void Serialization::deserializeEntity(Entity *entity, const QJsonObject &json) {
     attack->melee_cooldown =
         static_cast<float>(attack_obj["melee_cooldown"].toDouble());
     attack->preferred_mode =
-        combatModeFromString(attack_obj["preferred_mode"].toString());
+        combat_mode_from_string(attack_obj["preferred_mode"].toString());
     attack->current_mode =
-        combatModeFromString(attack_obj["current_mode"].toString());
+        combat_mode_from_string(attack_obj["current_mode"].toString());
     attack->can_melee = attack_obj["can_melee"].toBool(true);
     attack->can_ranged = attack_obj["can_ranged"].toBool(false);
     attack->max_height_difference =
@@ -549,7 +549,7 @@ void Serialization::deserializeEntity(Entity *entity, const QJsonObject &json) {
   }
 }
 
-auto Serialization::serializeTerrain(
+auto Serialization::serialize_terrain(
     const Game::Map::TerrainHeightMap *height_map,
     const Game::Map::BiomeSettings &biome,
     const std::vector<Game::Map::RoadSegment> &roads) -> QJsonObject {
@@ -671,7 +671,7 @@ auto Serialization::serializeTerrain(
   return terrain_obj;
 }
 
-void Serialization::deserializeTerrain(
+void Serialization::deserialize_terrain(
     Game::Map::TerrainHeightMap *height_map, Game::Map::BiomeSettings &biome,
     std::vector<Game::Map::RoadSegment> &roads, const QJsonObject &json) {
   if ((height_map == nullptr) || json.isEmpty()) {
@@ -866,13 +866,13 @@ void Serialization::deserializeTerrain(
   height_map->restoreFromData(heights, terrain_types, rivers, bridges);
 }
 
-auto Serialization::serializeWorld(const World *world) -> QJsonDocument {
+auto Serialization::serialize_world(const World *world) -> QJsonDocument {
   QJsonObject world_obj;
   QJsonArray entities_array;
 
   const auto &entities = world->get_entities();
   for (const auto &[id, entity] : entities) {
-    QJsonObject const entity_obj = serializeEntity(entity.get());
+    QJsonObject const entity_obj = serialize_entity(entity.get());
     entities_array.append(entity_obj);
   }
 
@@ -885,7 +885,7 @@ auto Serialization::serializeWorld(const World *world) -> QJsonDocument {
   const auto &terrain_service = Game::Map::TerrainService::instance();
   if (terrain_service.is_initialized() &&
       (terrain_service.get_height_map() != nullptr)) {
-    world_obj["terrain"] = serializeTerrain(terrain_service.get_height_map(),
+    world_obj["terrain"] = serialize_terrain(terrain_service.get_height_map(),
                                             terrain_service.biome_settings(),
                                             terrain_service.road_segments());
   }
@@ -893,7 +893,7 @@ auto Serialization::serializeWorld(const World *world) -> QJsonDocument {
   return QJsonDocument(world_obj);
 }
 
-void Serialization::deserializeWorld(World *world, const QJsonDocument &doc) {
+void Serialization::deserialize_world(World *world, const QJsonDocument &doc) {
   auto world_obj = doc.object();
   auto entities_array = world_obj["entities"].toArray();
   for (const auto &value : entities_array) {
@@ -904,7 +904,7 @@ void Serialization::deserializeWorld(World *world, const QJsonDocument &doc) {
                        ? world->create_entity()
                        : world->create_entity_with_id(entity_id);
     if (entity != nullptr) {
-      deserializeEntity(entity, entity_obj);
+      deserialize_entity(entity, entity_obj);
     }
   }
 
@@ -935,7 +935,7 @@ void Serialization::deserializeWorld(World *world, const QJsonDocument &doc) {
 
     auto temp_height_map =
         std::make_unique<Game::Map::TerrainHeightMap>(width, height, tile_size);
-    deserializeTerrain(temp_height_map.get(), biome, roads, terrain_obj);
+    deserialize_terrain(temp_height_map.get(), biome, roads, terrain_obj);
 
     auto &terrain_service = Game::Map::TerrainService::instance();
     terrain_service.restore_from_serialized(
@@ -945,8 +945,8 @@ void Serialization::deserializeWorld(World *world, const QJsonDocument &doc) {
   }
 }
 
-auto Serialization::saveToFile(const QString &filename,
-                               const QJsonDocument &doc) -> bool {
+auto Serialization::save_to_file(const QString &filename,
+                                const QJsonDocument &doc) -> bool {
   QFile file(filename);
   if (!file.open(QIODevice::WriteOnly)) {
     qWarning() << "Could not open file for writing:" << filename;

game/core/serialization.h

@@ -15,23 +15,23 @@ namespace Engine::Core {
 
 class Serialization {
 public:
-  static auto serializeEntity(const class Entity *entity) -> QJsonObject;
-  static void deserializeEntity(class Entity *entity, const QJsonObject &json);
+  static auto serialize_entity(const class Entity *entity) -> QJsonObject;
+  static void deserialize_entity(class Entity *entity, const QJsonObject &json);
 
-  static auto serializeWorld(const class World *world) -> QJsonDocument;
-  static void deserializeWorld(class World *world, const QJsonDocument &doc);
+  static auto serialize_world(const class World *world) -> QJsonDocument;
+  static void deserialize_world(class World *world, const QJsonDocument &doc);
 
-  static auto serializeTerrain(const Game::Map::TerrainHeightMap *height_map,
-                               const Game::Map::BiomeSettings &biome,
-                               const std::vector<Game::Map::RoadSegment> &roads)
+  static auto serialize_terrain(const Game::Map::TerrainHeightMap *height_map,
+                                const Game::Map::BiomeSettings &biome,
+                                const std::vector<Game::Map::RoadSegment> &roads)
       -> QJsonObject;
-  static void deserializeTerrain(Game::Map::TerrainHeightMap *height_map,
-                                 Game::Map::BiomeSettings &biome,
-                                 std::vector<Game::Map::RoadSegment> &roads,
-                                 const QJsonObject &json);
+  static void deserialize_terrain(Game::Map::TerrainHeightMap *height_map,
+                                  Game::Map::BiomeSettings &biome,
+                                  std::vector<Game::Map::RoadSegment> &roads,
+                                  const QJsonObject &json);
 
-  static auto saveToFile(const QString &filename,
-                         const QJsonDocument &doc) -> bool;
+  static auto save_to_file(const QString &filename,
+                           const QJsonDocument &doc) -> bool;
   static auto load_from_file(const QString &filename) -> QJsonDocument;
 };
 

game/systems/save_load_service.cpp

@@ -28,7 +28,7 @@
 namespace Game::Systems {
 
 SaveLoadService::SaveLoadService() {
-  ensureSavesDirectoryExists();
+  ensure_saves_directory_exists();
   m_storage = std::make_unique<SaveStorage>(get_database_path());
   QString init_error;
   if (!m_storage->initialize(&init_error)) {
@@ -39,31 +39,31 @@ SaveLoadService::SaveLoadService() {
 
 SaveLoadService::~SaveLoadService() = default;
 
-auto SaveLoadService::getSavesDirectory() -> QString {
+auto SaveLoadService::get_saves_directory() -> QString {
   QString const saves_path =
       QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
   return saves_path + "/saves";
 }
 
 auto SaveLoadService::get_database_path() -> QString {
-  return getSavesDirectory() + QStringLiteral("/saves.sqlite");
+  return get_saves_directory() + QStringLiteral("/saves.sqlite");
 }
 
-void SaveLoadService::ensureSavesDirectoryExists() {
-  QString const saves_dir = getSavesDirectory();
+void SaveLoadService::ensure_saves_directory_exists() {
+  QString const saves_dir = get_saves_directory();
   QDir const dir;
   if (!dir.exists(saves_dir)) {
     dir.mkpath(saves_dir);
   }
 }
 
-auto SaveLoadService::saveGameToSlot(Engine::Core::World &world,
-                                     const QString &slotName,
-                                     const QString &title,
-                                     const QString &map_name,
-                                     const QJsonObject &metadata,
-                                     const QByteArray &screenshot) -> bool {
-  qInfo() << "Saving game to slot:" << slotName;
+auto SaveLoadService::save_game_to_slot(Engine::Core::World &world,
+                                        const QString &slot_name,
+                                        const QString &title,
+                                        const QString &map_name,
+                                        const QJsonObject &metadata,
+                                        const QByteArray &screenshot) -> bool {
+  qInfo() << "Saving game to slot:" << slot_name;
 
   try {
     if (!m_storage) {
@@ -73,11 +73,11 @@ auto SaveLoadService::saveGameToSlot(Engine::Core::World &world,
     }
 
     QJsonDocument const world_doc =
-        Engine::Core::Serialization::serializeWorld(&world);
+        Engine::Core::Serialization::serialize_world(&world);
     const QByteArray world_bytes = world_doc.toJson(QJsonDocument::Compact);
 
     QJsonObject combined_metadata = metadata;
-    combined_metadata["slotName"] = slotName;
+    combined_metadata["slotName"] = slot_name;
     combined_metadata["title"] = title;
     combined_metadata["timestamp"] =
         QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs);
@@ -88,15 +88,15 @@ auto SaveLoadService::saveGameToSlot(Engine::Core::World &world,
     combined_metadata["version"] = QStringLiteral("1.0");
 
     QString storage_error;
-    if (!m_storage->saveSlot(slotName, title, combined_metadata, world_bytes,
-                             screenshot, &storage_error)) {
+    if (!m_storage->save_slot(slot_name, title, combined_metadata, world_bytes,
+                              screenshot, &storage_error)) {
       m_last_error = storage_error;
       qWarning() << "SaveLoadService: failed to persist slot" << storage_error;
       return false;
     }
 
     m_last_metadata = combined_metadata;
-    m_lastTitle = title;
+    m_last_title = title;
     m_last_screenshot = screenshot;
     m_last_error.clear();
     return true;
@@ -109,8 +109,8 @@ auto SaveLoadService::saveGameToSlot(Engine::Core::World &world,
 }
 
 auto SaveLoadService::load_game_from_slot(Engine::Core::World &world,
-                                          const QString &slotName) -> bool {
-  qInfo() << "Loading game from slot:" << slotName;
+                                          const QString &slot_name) -> bool {
+  qInfo() << "Loading game from slot:" << slot_name;
 
   try {
     if (!m_storage) {
@@ -125,8 +125,8 @@ auto SaveLoadService::load_game_from_slot(Engine::Core::World &world,
     QString title;
 
     QString load_error;
-    if (!m_storage->loadSlot(slotName, world_bytes, metadata, screenshot, title,
-                             &load_error)) {
+    if (!m_storage->load_slot(slot_name, world_bytes, metadata, screenshot, title,
+                              &load_error)) {
       m_last_error = load_error;
       qWarning() << "SaveLoadService: failed to load slot" << load_error;
       return false;
@@ -137,16 +137,16 @@ auto SaveLoadService::load_game_from_slot(Engine::Core::World &world,
         QJsonDocument::fromJson(world_bytes, &parse_error);
     if (parse_error.error != QJsonParseError::NoError || doc.isNull()) {
       m_last_error = QStringLiteral("Corrupted save data for slot '%1': %2")
-                         .arg(slotName, parse_error.errorString());
+                         .arg(slot_name, parse_error.errorString());
       qWarning() << m_last_error;
       return false;
     }
 
     world.clear();
-    Engine::Core::Serialization::deserializeWorld(&world, doc);
+    Engine::Core::Serialization::deserialize_world(&world, doc);
 
     m_last_metadata = metadata;
-    m_lastTitle = title;
+    m_last_title = title;
     m_last_screenshot = screenshot;
     m_last_error.clear();
     return true;
@@ -164,7 +164,7 @@ auto SaveLoadService::get_save_slots() const -> QVariantList {
   }
 
   QString list_error;
-  QVariantList slot_list = m_storage->listSlots(&list_error);
+  QVariantList slot_list = m_storage->list_slots(&list_error);
   if (!list_error.isEmpty()) {
     m_last_error = list_error;
     qWarning() << "SaveLoadService: failed to enumerate slots" << list_error;
@@ -174,8 +174,8 @@ auto SaveLoadService::get_save_slots() const -> QVariantList {
   return slot_list;
 }
 
-auto SaveLoadService::deleteSaveSlot(const QString &slotName) -> bool {
-  qInfo() << "Deleting save slot:" << slotName;
+auto SaveLoadService::delete_save_slot(const QString &slot_name) -> bool {
+  qInfo() << "Deleting save slot:" << slot_name;
 
   if (!m_storage) {
     m_last_error = QStringLiteral("Save storage unavailable");
@@ -184,7 +184,7 @@ auto SaveLoadService::deleteSaveSlot(const QString &slotName) -> bool {
   }
 
   QString delete_error;
-  if (!m_storage->deleteSlot(slotName, &delete_error)) {
+  if (!m_storage->delete_slot(slot_name, &delete_error)) {
     m_last_error = delete_error;
     qWarning() << "SaveLoadService: failed to delete slot" << delete_error;
     return false;
@@ -226,9 +226,9 @@ auto SaveLoadService::mark_campaign_completed(const QString &campaign_id,
   return m_storage->mark_campaign_completed(campaign_id, out_error);
 }
 
-void SaveLoadService::openSettings() { qInfo() << "Open settings requested"; }
+void SaveLoadService::open_settings() { qInfo() << "Open settings requested"; }
 
-void SaveLoadService::exitGame() {
+void SaveLoadService::exit_game() {
   qInfo() << "Exit game requested";
 
   QCoreApplication::quit();

game/systems/save_load_service.h

@@ -20,25 +20,25 @@ public:
   SaveLoadService();
   ~SaveLoadService();
 
-  auto saveGameToSlot(Engine::Core::World &world, const QString &slotName,
-                      const QString &title, const QString &map_name,
-                      const QJsonObject &metadata = {},
-                      const QByteArray &screenshot = QByteArray()) -> bool;
+  auto save_game_to_slot(Engine::Core::World &world, const QString &slot_name,
+                         const QString &title, const QString &map_name,
+                         const QJsonObject &metadata = {},
+                         const QByteArray &screenshot = QByteArray()) -> bool;
 
   auto load_game_from_slot(Engine::Core::World &world,
-                           const QString &slotName) -> bool;
+                           const QString &slot_name) -> bool;
 
   auto get_save_slots() const -> QVariantList;
 
-  auto deleteSaveSlot(const QString &slotName) -> bool;
+  auto delete_save_slot(const QString &slot_name) -> bool;
 
-  auto getLastError() const -> QString { return m_last_error; }
+  auto get_last_error() const -> QString { return m_last_error; }
 
-  void clearError() { m_last_error.clear(); }
+  void clear_error() { m_last_error.clear(); }
 
-  auto getLastMetadata() const -> QJsonObject { return m_last_metadata; }
-  auto getLastTitle() const -> QString { return m_lastTitle; }
-  auto getLastScreenshot() const -> QByteArray { return m_last_screenshot; }
+  auto get_last_metadata() const -> QJsonObject { return m_last_metadata; }
+  auto get_last_title() const -> QString { return m_last_title; }
+  auto get_last_screenshot() const -> QByteArray { return m_last_screenshot; }
 
   auto list_campaigns(QString *out_error = nullptr) const -> QVariantList;
   auto get_campaign_progress(const QString &campaign_id,
@@ -46,18 +46,18 @@ public:
   auto mark_campaign_completed(const QString &campaign_id,
                                QString *out_error = nullptr) -> bool;
 
-  static void openSettings();
+  static void open_settings();
 
-  static void exitGame();
+  static void exit_game();
 
 private:
-  static auto getSavesDirectory() -> QString;
+  static auto get_saves_directory() -> QString;
   static auto get_database_path() -> QString;
-  static void ensureSavesDirectoryExists();
+  static void ensure_saves_directory_exists();
 
   mutable QString m_last_error;
   QJsonObject m_last_metadata;
-  QString m_lastTitle;
+  QString m_last_title;
   QByteArray m_last_screenshot;
   std::unique_ptr<SaveStorage> m_storage;
 };

game/systems/save_storage.cpp

@@ -25,12 +25,12 @@ namespace {
 constexpr const char *k_driver_name = "QSQLITE";
 constexpr int k_current_schema_version = 2;
 
-auto buildConnectionName(const SaveStorage *instance) -> QString {
+auto build_connection_name(const SaveStorage *instance) -> QString {
   return QStringLiteral("SaveStorage_%1")
       .arg(reinterpret_cast<quintptr>(instance), 0, 16);
 }
 
-auto lastErrorString(const QSqlError &error) -> QString {
+auto last_error_string(const QSqlError &error) -> QString {
   if (error.type() == QSqlError::NoError) {
     return {};
   }
@@ -45,7 +45,7 @@ public:
     if (!m_database.transaction()) {
       if (out_error != nullptr) {
         *out_error = QStringLiteral("Failed to begin transaction: %1")
-                         .arg(lastErrorString(m_database.lastError()));
+                         .arg(last_error_string(m_database.lastError()));
       }
       return false;
     }
@@ -61,7 +61,7 @@ public:
     if (!m_database.commit()) {
       if (out_error != nullptr) {
         *out_error = QStringLiteral("Failed to commit transaction: %1")
-                         .arg(lastErrorString(m_database.lastError()));
+                         .arg(last_error_string(m_database.lastError()));
       }
       rollback();
       return false;
@@ -88,7 +88,7 @@ private:
 
 SaveStorage::SaveStorage(QString database_path)
     : m_database_path(std::move(database_path)),
-      m_connection_name(buildConnectionName(this)) {}
+      m_connection_name(build_connection_name(this)) {}
 
 SaveStorage::~SaveStorage() {
   if (m_database.isValid()) {
@@ -108,16 +108,16 @@ auto SaveStorage::initialize(QString *out_error) -> bool {
   if (!open(out_error)) {
     return false;
   }
-  if (!ensureSchema(out_error)) {
+  if (!ensure_schema(out_error)) {
     return false;
   }
   m_initialized = true;
   return true;
 }
 
-auto SaveStorage::saveSlot(const QString &slotName, const QString &title,
+auto SaveStorage::save_slot(const QString &slot_name, const QString &title,
                            const QJsonObject &metadata,
-                           const QByteArray &worldState,
+                           const QByteArray &world_state,
                            const QByteArray &screenshot,
                            QString *out_error) -> bool {
   if (!initialize(out_error)) {
@@ -147,7 +147,7 @@ auto SaveStorage::saveSlot(const QString &slotName, const QString &title,
   if (!query.prepare(insert_sql)) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to prepare save query: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return false;
   }
@@ -161,12 +161,12 @@ auto SaveStorage::saveSlot(const QString &slotName, const QString &title,
   const QByteArray metadata_bytes =
       QJsonDocument(metadata).toJson(QJsonDocument::Compact);
 
-  query.bindValue(QStringLiteral(":slot_name"), slotName);
+  query.bindValue(QStringLiteral(":slot_name"), slot_name);
   query.bindValue(QStringLiteral(":title"), title);
   query.bindValue(QStringLiteral(":map_name"), map_name);
   query.bindValue(QStringLiteral(":timestamp"), now_iso);
   query.bindValue(QStringLiteral(":metadata"), metadata_bytes);
-  query.bindValue(QStringLiteral(":world_state"), worldState);
+  query.bindValue(QStringLiteral(":world_state"), world_state);
   if (screenshot.isEmpty()) {
     query.bindValue(QStringLiteral(":screenshot"),
                     QVariant(QMetaType::fromType<QByteArray>()));
@@ -179,7 +179,7 @@ auto SaveStorage::saveSlot(const QString &slotName, const QString &title,
   if (!query.exec()) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to persist save slot: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     transaction.rollback();
     return false;
@@ -192,7 +192,7 @@ auto SaveStorage::saveSlot(const QString &slotName, const QString &title,
   return true;
 }
 
-auto SaveStorage::loadSlot(const QString &slotName, QByteArray &worldState,
+auto SaveStorage::load_slot(const QString &slot_name, QByteArray &world_state,
                            QJsonObject &metadata, QByteArray &screenshot,
                            QString &title, QString *out_error) -> bool {
   if (!initialize(out_error)) {
@@ -203,19 +203,19 @@ auto SaveStorage::loadSlot(const QString &slotName, QByteArray &worldState,
   query.prepare(QStringLiteral(
       "SELECT title, metadata, world_state, screenshot FROM saves "
       "WHERE slot_name = :slot_name"));
-  query.bindValue(QStringLiteral(":slot_name"), slotName);
+  query.bindValue(QStringLiteral(":slot_name"), slot_name);
 
   if (!query.exec()) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to read save slot: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return false;
   }
 
   if (!query.next()) {
     if (out_error != nullptr) {
-      *out_error = QStringLiteral("Save slot '%1' not found").arg(slotName);
+      *out_error = QStringLiteral("Save slot '%1' not found").arg(slot_name);
     }
     return false;
   }
@@ -223,12 +223,12 @@ auto SaveStorage::loadSlot(const QString &slotName, QByteArray &worldState,
   title = query.value(0).toString();
   const QByteArray metadata_bytes = query.value(1).toByteArray();
   metadata = QJsonDocument::fromJson(metadata_bytes).object();
-  worldState = query.value(2).toByteArray();
+  world_state = query.value(2).toByteArray();
   screenshot = query.value(3).toByteArray();
   return true;
 }
 
-auto SaveStorage::listSlots(QString *out_error) const -> QVariantList {
+auto SaveStorage::list_slots(QString *out_error) const -> QVariantList {
   QVariantList result;
   if (!const_cast<SaveStorage *>(this)->initialize(out_error)) {
     return result;
@@ -240,7 +240,7 @@ auto SaveStorage::listSlots(QString *out_error) const -> QVariantList {
           "FROM saves ORDER BY datetime(timestamp) DESC"))) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to enumerate save slots: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return result;
   }
@@ -295,7 +295,7 @@ auto SaveStorage::list_campaigns(QString *out_error) const -> QVariantList {
   if (!query.exec(sql)) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to list campaigns: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return result;
   }
@@ -332,7 +332,7 @@ auto SaveStorage::get_campaign_progress(
   if (!query.exec()) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to get campaign progress: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return result;
   }
@@ -373,7 +373,7 @@ auto SaveStorage::mark_campaign_completed(const QString &campaign_id,
   if (!query.exec()) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to mark campaign as completed: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     transaction.rollback();
     return false;
@@ -386,8 +386,8 @@ auto SaveStorage::mark_campaign_completed(const QString &campaign_id,
   return true;
 }
 
-auto SaveStorage::deleteSlot(const QString &slotName,
-                             QString *out_error) -> bool {
+auto SaveStorage::delete_slot(const QString &slot_name,
+                              QString *out_error) -> bool {
   if (!initialize(out_error)) {
     return false;
   }
@@ -400,12 +400,12 @@ auto SaveStorage::deleteSlot(const QString &slotName,
   QSqlQuery query(m_database);
   query.prepare(
       QStringLiteral("DELETE FROM saves WHERE slot_name = :slot_name"));
-  query.bindValue(QStringLiteral(":slot_name"), slotName);
+  query.bindValue(QStringLiteral(":slot_name"), slot_name);
 
   if (!query.exec()) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to delete save slot: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     transaction.rollback();
     return false;
@@ -413,7 +413,7 @@ auto SaveStorage::deleteSlot(const QString &slotName,
 
   if (query.numRowsAffected() == 0) {
     if (out_error != nullptr) {
-      *out_error = QStringLiteral("Save slot '%1' not found").arg(slotName);
+      *out_error = QStringLiteral("Save slot '%1' not found").arg(slot_name);
     }
     transaction.rollback();
     return false;
@@ -440,7 +440,7 @@ auto SaveStorage::open(QString *out_error) const -> bool {
   if (!m_database.open()) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to open save database: %1")
-                       .arg(lastErrorString(m_database.lastError()));
+                       .arg(last_error_string(m_database.lastError()));
     }
     return false;
   }
@@ -454,8 +454,8 @@ auto SaveStorage::open(QString *out_error) const -> bool {
   return true;
 }
 
-auto SaveStorage::ensureSchema(QString *out_error) const -> bool {
-  const int current_version = schemaVersion(out_error);
+auto SaveStorage::ensure_schema(QString *out_error) const -> bool {
+  const int current_version = schema_version(out_error);
   if (current_version < 0) {
     return false;
   }
@@ -497,12 +497,12 @@ auto SaveStorage::ensureSchema(QString *out_error) const -> bool {
   return true;
 }
 
-auto SaveStorage::schemaVersion(QString *out_error) const -> int {
+auto SaveStorage::schema_version(QString *out_error) const -> int {
   QSqlQuery pragma_query(m_database);
   if (!pragma_query.exec(QStringLiteral("PRAGMA user_version"))) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to read schema version: %1")
-                       .arg(lastErrorString(pragma_query.lastError()));
+                       .arg(last_error_string(pragma_query.lastError()));
     }
     return -1;
   }
@@ -521,14 +521,14 @@ auto SaveStorage::set_schema_version(int version,
           QStringLiteral("PRAGMA user_version = %1").arg(version))) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to update schema version: %1")
-                       .arg(lastErrorString(pragma_query.lastError()));
+                       .arg(last_error_string(pragma_query.lastError()));
     }
     return false;
   }
   return true;
 }
 
-auto SaveStorage::createBaseSchema(QString *out_error) const -> bool {
+auto SaveStorage::create_base_schema(QString *out_error) const -> bool {
   QSqlQuery query(m_database);
   const QString create_sql =
       QStringLiteral("CREATE TABLE IF NOT EXISTS saves ("
@@ -547,7 +547,7 @@ auto SaveStorage::createBaseSchema(QString *out_error) const -> bool {
   if (!query.exec(create_sql)) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to create save schema: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return false;
   }
@@ -558,7 +558,7 @@ auto SaveStorage::createBaseSchema(QString *out_error) const -> bool {
           "(updated_at DESC)"))) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to build save index: %1")
-                       .arg(lastErrorString(index_query.lastError()));
+                       .arg(last_error_string(index_query.lastError()));
     }
     return false;
   }
@@ -573,7 +573,7 @@ auto SaveStorage::migrate_schema(int fromVersion,
   while (version < k_current_schema_version) {
     switch (version) {
     case 0:
-      if (!createBaseSchema(out_error)) {
+      if (!create_base_schema(out_error)) {
         return false;
       }
       version = 1;
@@ -611,7 +611,7 @@ auto SaveStorage::migrate_to_2(QString *out_error) const -> bool {
   if (!query.exec(create_campaigns_sql)) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to create campaigns table: %1")
-                       .arg(lastErrorString(query.lastError()));
+                       .arg(last_error_string(query.lastError()));
     }
     return false;
   }
@@ -630,7 +630,7 @@ auto SaveStorage::migrate_to_2(QString *out_error) const -> bool {
     if (out_error != nullptr) {
       *out_error =
           QStringLiteral("Failed to create campaign_progress table: %1")
-              .arg(lastErrorString(progress_query.lastError()));
+              .arg(last_error_string(progress_query.lastError()));
     }
     return false;
   }
@@ -646,7 +646,7 @@ auto SaveStorage::migrate_to_2(QString *out_error) const -> bool {
   if (!insert_query.exec(insert_campaign_sql)) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to insert initial campaign: %1")
-                       .arg(lastErrorString(insert_query.lastError()));
+                       .arg(last_error_string(insert_query.lastError()));
     }
     return false;
   }
@@ -659,7 +659,7 @@ auto SaveStorage::migrate_to_2(QString *out_error) const -> bool {
   if (!progress_insert_query.exec(insert_progress_sql)) {
     if (out_error != nullptr) {
       *out_error = QStringLiteral("Failed to initialize campaign progress: %1")
-                       .arg(lastErrorString(progress_insert_query.lastError()));
+                       .arg(last_error_string(progress_insert_query.lastError()));
     }
     return false;
   }

game/systems/save_storage.h

@@ -17,19 +17,19 @@ public:
 
   auto initialize(QString *out_error = nullptr) -> bool;
 
-  auto saveSlot(const QString &slotName, const QString &title,
-                const QJsonObject &metadata, const QByteArray &worldState,
-                const QByteArray &screenshot,
-                QString *out_error = nullptr) -> bool;
+  auto save_slot(const QString &slot_name, const QString &title,
+                 const QJsonObject &metadata, const QByteArray &world_state,
+                 const QByteArray &screenshot,
+                 QString *out_error = nullptr) -> bool;
 
-  auto loadSlot(const QString &slotName, QByteArray &worldState,
-                QJsonObject &metadata, QByteArray &screenshot, QString &title,
-                QString *out_error = nullptr) -> bool;
+  auto load_slot(const QString &slot_name, QByteArray &world_state,
+                 QJsonObject &metadata, QByteArray &screenshot, QString &title,
+                 QString *out_error = nullptr) -> bool;
 
-  auto listSlots(QString *out_error = nullptr) const -> QVariantList;
+  auto list_slots(QString *out_error = nullptr) const -> QVariantList;
 
-  auto deleteSlot(const QString &slotName,
-                  QString *out_error = nullptr) -> bool;
+  auto delete_slot(const QString &slot_name,
+                   QString *out_error = nullptr) -> bool;
 
   auto list_campaigns(QString *out_error = nullptr) const -> QVariantList;
   auto get_campaign_progress(const QString &campaign_id,
@@ -39,11 +39,11 @@ public:
 
 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 migrate_schema(int fromVersion,
+  auto ensure_schema(QString *out_error = nullptr) const -> bool;
+  auto create_base_schema(QString *out_error = nullptr) const -> bool;
+  auto migrate_schema(int from_version,
                       QString *out_error = nullptr) const -> bool;
-  auto schemaVersion(QString *out_error = nullptr) const -> int;
+  auto schema_version(QString *out_error = nullptr) const -> int;
   auto set_schema_version(int version,
                           QString *out_error = nullptr) const -> bool;
   auto migrate_to_2(QString *out_error = nullptr) const -> bool;

tests/core/serialization_test.cpp

@@ -29,7 +29,7 @@ TEST_F(SerializationTest, EntitySerializationBasic) {
 
   auto entity_id = entity->get_id();
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   EXPECT_TRUE(json.contains("id"));
   EXPECT_EQ(json["id"].toVariant().toULongLong(),
@@ -52,7 +52,7 @@ TEST_F(SerializationTest, TransformComponentSerialization) {
   transform->has_desired_yaw = true;
   transform->desired_yaw = 45.0F;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("transform"));
   QJsonObject transform_obj = json["transform"].toObject();
@@ -85,10 +85,10 @@ TEST_F(SerializationTest, TransformComponentRoundTrip) {
   transform->has_desired_yaw = true;
   transform->desired_yaw = 90.0F;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<TransformComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -117,7 +117,7 @@ TEST_F(SerializationTest, UnitComponentSerialization) {
   unit->owner_id = 1;
   unit->nation_id = Game::Systems::NationID::RomanRepublic;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("unit"));
   QJsonObject unit_obj = json["unit"].toObject();
@@ -142,10 +142,10 @@ TEST_F(SerializationTest, UnitComponentRoundTrip) {
   unit->owner_id = 2;
   unit->nation_id = Game::Systems::NationID::Carthage;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<UnitComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -179,7 +179,7 @@ TEST_F(SerializationTest, MovementComponentSerialization) {
   movement->path.emplace_back(10.0F, 20.0F);
   movement->path.emplace_back(30.0F, 40.0F);
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("movement"));
   QJsonObject movement_obj = json["movement"].toObject();
@@ -227,7 +227,7 @@ TEST_F(SerializationTest, AttackComponentSerialization) {
   attack->in_melee_lock = false;
   attack->melee_lock_target_id = 0;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("attack"));
   QJsonObject attack_obj = json["attack"].toObject();
@@ -259,10 +259,10 @@ TEST_F(SerializationTest, EntityDeserializationRoundTrip) {
   unit->max_health = 100;
   unit->speed = 6.0F;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized_transform =
       new_entity->get_component<TransformComponent>();
@@ -287,7 +287,7 @@ TEST_F(SerializationTest, DeserializationWithMissingFields) {
   json["unit"] = unit_obj;
 
   auto *entity = world->create_entity();
-  Serialization::deserializeEntity(entity, json);
+  Serialization::deserialize_entity(entity, json);
 
   auto *unit = entity->get_component<UnitComponent>();
   ASSERT_NE(unit, nullptr);
@@ -305,7 +305,7 @@ TEST_F(SerializationTest, DeserializationWithMalformedJSON) {
 
   auto *entity = world->create_entity();
 
-  EXPECT_NO_THROW({ Serialization::deserializeEntity(entity, json); });
+  EXPECT_NO_THROW({ Serialization::deserialize_entity(entity, json); });
 
   auto *transform = entity->get_component<TransformComponent>();
   ASSERT_NE(transform, nullptr);
@@ -321,7 +321,7 @@ TEST_F(SerializationTest, WorldSerializationRoundTrip) {
   auto *transform2 = entity2->add_component<TransformComponent>();
   transform2->position.x = 20.0F;
 
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
 
   ASSERT_TRUE(doc.isObject());
   QJsonObject world_obj = doc.object();
@@ -330,7 +330,7 @@ TEST_F(SerializationTest, WorldSerializationRoundTrip) {
   EXPECT_TRUE(world_obj.contains("schemaVersion"));
 
   auto new_world = std::make_unique<World>();
-  Serialization::deserializeWorld(new_world.get(), doc);
+  Serialization::deserialize_world(new_world.get(), doc);
 
   const auto &entities = new_world->get_entities();
   EXPECT_EQ(entities.size(), 2UL);
@@ -343,20 +343,20 @@ TEST_F(SerializationTest, SaveAndLoadFromFile) {
   transform->position.y = 43.0F;
   transform->position.z = 44.0F;
 
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
 
   QTemporaryFile temp_file;
   ASSERT_TRUE(temp_file.open());
   QString filename = temp_file.fileName();
   temp_file.close();
 
-  EXPECT_TRUE(Serialization::saveToFile(filename, doc));
+  EXPECT_TRUE(Serialization::save_to_file(filename, doc));
 
   QJsonDocument loaded_doc = Serialization::load_from_file(filename);
   EXPECT_FALSE(loaded_doc.isNull());
 
   auto new_world = std::make_unique<World>();
-  Serialization::deserializeWorld(new_world.get(), loaded_doc);
+  Serialization::deserialize_world(new_world.get(), loaded_doc);
 
   const auto &entities = new_world->get_entities();
   EXPECT_EQ(entities.size(), 1UL);
@@ -388,7 +388,7 @@ TEST_F(SerializationTest, ProductionComponentSerialization) {
   production->production_queue.push_back(Game::Units::TroopType::Spearman);
   production->production_queue.push_back(Game::Units::TroopType::Archer);
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("production"));
   QJsonObject prod_obj = json["production"].toObject();
@@ -421,7 +421,7 @@ TEST_F(SerializationTest, PatrolComponentSerialization) {
   patrol->waypoints.emplace_back(30.0F, 40.0F);
   patrol->waypoints.emplace_back(50.0F, 60.0F);
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("patrol"));
   QJsonObject patrol_obj = json["patrol"].toObject();
@@ -446,10 +446,10 @@ TEST_F(SerializationTest, PatrolComponentRoundTrip) {
   patrol->waypoints.emplace_back(15.0F, 25.0F);
   patrol->waypoints.emplace_back(35.0F, 45.0F);
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<PatrolComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -473,10 +473,10 @@ TEST_F(SerializationTest, MovementComponentRoundTrip) {
   movement->path.emplace_back(10.0F, 20.0F);
   movement->path.emplace_back(30.0F, 40.0F);
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<MovementComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -505,10 +505,10 @@ TEST_F(SerializationTest, AttackComponentRoundTrip) {
   attack->in_melee_lock = true;
   attack->melee_lock_target_id = 42;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<AttackComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -540,10 +540,10 @@ TEST_F(SerializationTest, ProductionComponentRoundTrip) {
   production->villager_cost = 3;
   production->production_queue.push_back(Game::Units::TroopType::Archer);
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<ProductionComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -573,7 +573,7 @@ TEST_F(SerializationTest, RenderableComponentSerialization) {
   renderable->mesh = RenderableComponent::MeshKind::Capsule;
   renderable->color = {0.8F, 0.2F, 0.5F};
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("renderable"));
   QJsonObject renderable_obj = json["renderable"].toObject();
@@ -606,10 +606,10 @@ TEST_F(SerializationTest, RenderableComponentRoundTrip) {
   renderable->mesh = RenderableComponent::MeshKind::Quad;
   renderable->color = {1.0F, 0.5F, 0.25F};
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<RenderableComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -629,7 +629,7 @@ TEST_F(SerializationTest, AttackTargetComponentSerialization) {
   attack_target->target_id = 42;
   attack_target->should_chase = true;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("attack_target"));
   QJsonObject attack_target_obj = json["attack_target"].toObject();
@@ -644,10 +644,10 @@ TEST_F(SerializationTest, AttackTargetComponentRoundTrip) {
   attack_target->target_id = 123;
   attack_target->should_chase = false;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<AttackTargetComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -659,7 +659,7 @@ TEST_F(SerializationTest, BuildingComponentSerialization) {
   auto *entity = world->create_entity();
   entity->add_component<BuildingComponent>();
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("building"));
   EXPECT_TRUE(json["building"].toBool());
@@ -669,10 +669,10 @@ TEST_F(SerializationTest, BuildingComponentRoundTrip) {
   auto *original_entity = world->create_entity();
   original_entity->add_component<BuildingComponent>();
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<BuildingComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -682,7 +682,7 @@ TEST_F(SerializationTest, AIControlledComponentSerialization) {
   auto *entity = world->create_entity();
   entity->add_component<AIControlledComponent>();
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("aiControlled"));
   EXPECT_TRUE(json["aiControlled"].toBool());
@@ -692,10 +692,10 @@ TEST_F(SerializationTest, AIControlledComponentRoundTrip) {
   auto *original_entity = world->create_entity();
   original_entity->add_component<AIControlledComponent>();
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<AIControlledComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -710,7 +710,7 @@ TEST_F(SerializationTest, CaptureComponentSerialization) {
   capture->required_time = 15.0F;
   capture->is_being_captured = true;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("capture"));
   QJsonObject capture_obj = json["capture"].toObject();
@@ -729,10 +729,10 @@ TEST_F(SerializationTest, CaptureComponentRoundTrip) {
   capture->required_time = 20.0F;
   capture->is_being_captured = false;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<CaptureComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -787,7 +787,7 @@ TEST_F(SerializationTest, CompleteEntityWithAllComponents) {
   auto *catapult = entity->add_component<CatapultLoadingComponent>();
   catapult->state = CatapultLoadingComponent::LoadingState::Idle;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   EXPECT_TRUE(json.contains("transform"));
   EXPECT_TRUE(json.contains("renderable"));
@@ -804,7 +804,7 @@ TEST_F(SerializationTest, CompleteEntityWithAllComponents) {
   EXPECT_TRUE(json.contains("catapult_loading"));
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   EXPECT_NE(new_entity->get_component<TransformComponent>(), nullptr);
   EXPECT_NE(new_entity->get_component<RenderableComponent>(), nullptr);
@@ -822,7 +822,7 @@ TEST_F(SerializationTest, CompleteEntityWithAllComponents) {
 }
 
 TEST_F(SerializationTest, EmptyWorldSerialization) {
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
 
   ASSERT_TRUE(doc.isObject());
   QJsonObject world_obj = doc.object();
@@ -840,7 +840,7 @@ TEST_F(SerializationTest, HoldModeComponentSerialization) {
   hold_mode->exit_cooldown = 1.5F;
   hold_mode->stand_up_duration = 3.0F;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("hold_mode"));
   QJsonObject hold_mode_obj = json["hold_mode"].toObject();
@@ -857,10 +857,10 @@ TEST_F(SerializationTest, HoldModeComponentRoundTrip) {
   hold_mode->exit_cooldown = 2.5F;
   hold_mode->stand_up_duration = 4.0F;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<HoldModeComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -878,7 +878,7 @@ TEST_F(SerializationTest, HealerComponentSerialization) {
   healer->healing_cooldown = 3.0F;
   healer->time_since_last_heal = 1.0F;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("healer"));
   QJsonObject healer_obj = json["healer"].toObject();
@@ -897,10 +897,10 @@ TEST_F(SerializationTest, HealerComponentRoundTrip) {
   healer->healing_cooldown = 4.0F;
   healer->time_since_last_heal = 2.0F;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<HealerComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -925,7 +925,7 @@ TEST_F(SerializationTest, CatapultLoadingComponentSerialization) {
   catapult->target_locked_z = 200.0F;
   catapult->target_position_locked = true;
 
-  QJsonObject json = Serialization::serializeEntity(entity);
+  QJsonObject json = Serialization::serialize_entity(entity);
 
   ASSERT_TRUE(json.contains("catapult_loading"));
   QJsonObject catapult_obj = json["catapult_loading"].toObject();
@@ -957,10 +957,10 @@ TEST_F(SerializationTest, CatapultLoadingComponentRoundTrip) {
   catapult->target_locked_z = 250.0F;
   catapult->target_position_locked = false;
 
-  QJsonObject json = Serialization::serializeEntity(original_entity);
+  QJsonObject json = Serialization::serialize_entity(original_entity);
 
   auto *new_entity = world->create_entity();
-  Serialization::deserializeEntity(new_entity, json);
+  Serialization::deserialize_entity(new_entity, json);
 
   auto *deserialized = new_entity->get_component<CatapultLoadingComponent>();
   ASSERT_NE(deserialized, nullptr);
@@ -1017,9 +1017,9 @@ TEST_F(SerializationTest, MultipleUnitsPositionsAndHealthPreserved) {
   }
 
   // Serialize and deserialize the world
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
   auto restored_world = std::make_unique<World>();
-  Serialization::deserializeWorld(restored_world.get(), doc);
+  Serialization::deserialize_world(restored_world.get(), doc);
 
   // Verify all units are restored with exact positions and health
   const auto &entities = restored_world->get_entities();
@@ -1086,12 +1086,12 @@ TEST_F(SerializationTest, OwnerRegistryTeamsAndColorsPreserved) {
   }
 
   // Serialize world (includes owner_registry)
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
 
   // Clear registry and restore
   registry.clear();
   auto restored_world = std::make_unique<World>();
-  Serialization::deserializeWorld(restored_world.get(), doc);
+  Serialization::deserialize_world(restored_world.get(), doc);
 
   // Verify owner registry state is preserved
   EXPECT_EQ(registry.get_local_player_id(), player1);
@@ -1174,9 +1174,9 @@ TEST_F(SerializationTest, BuildingOwnershipAndCaptureStatePreserved) {
   }
 
   // Serialize and restore
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
   auto restored_world = std::make_unique<World>();
-  Serialization::deserializeWorld(restored_world.get(), doc);
+  Serialization::deserialize_world(restored_world.get(), doc);
 
   // Verify all buildings are restored with correct ownership and capture state
   for (size_t i = 0; i < building_ids.size(); ++i) {
@@ -1237,9 +1237,9 @@ TEST_F(SerializationTest, UnitMovementStatePreserved) {
   const size_t expected_path_size = movement->path.size();
 
   // Serialize and restore
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
   auto restored_world = std::make_unique<World>();
-  Serialization::deserializeWorld(restored_world.get(), doc);
+  Serialization::deserialize_world(restored_world.get(), doc);
 
   // Verify movement state is preserved
   auto *restored_entity = restored_world->get_entity(entity_id);
@@ -1308,9 +1308,9 @@ TEST_F(SerializationTest, CombatStatePreserved) {
   defender_attack->melee_lock_target_id = attacker_id;
 
   // Serialize and restore
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
   auto restored_world = std::make_unique<World>();
-  Serialization::deserializeWorld(restored_world.get(), doc);
+  Serialization::deserialize_world(restored_world.get(), doc);
 
   // Verify combat state is preserved
   auto *restored_attacker = restored_world->get_entity(attacker_id);
@@ -1363,9 +1363,9 @@ TEST_F(SerializationTest, NationIdentityPreserved) {
   carthage_unit_comp->spawn_type = Game::Units::SpawnType::Archer;
 
   // Serialize and restore
-  QJsonDocument doc = Serialization::serializeWorld(world.get());
+  QJsonDocument doc = Serialization::serialize_world(world.get());
   auto restored_world = std::make_unique<World>();
-  Serialization::deserializeWorld(restored_world.get(), doc);
+  Serialization::deserialize_world(restored_world.get(), doc);
 
   // Verify nation IDs are preserved
   auto *restored_roman = restored_world->get_entity(roman_id);

tests/db/save_storage_test.cpp

@@ -35,7 +35,7 @@ TEST_F(SaveStorageTest, SaveSlotBasic) {
   QByteArray screenshot("screenshot_data");
 
   QString error;
-  bool saved = storage->saveSlot(slot_name, title, metadata, world_state,
+  bool saved = storage->save_slot(slot_name, title, metadata, world_state,
                                  screenshot, &error);
 
   EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
@@ -55,7 +55,7 @@ TEST_F(SaveStorageTest, SaveAndLoadSlot) {
 
   QString error;
   bool saved =
-      storage->saveSlot(slot_name, original_title, original_metadata,
+      storage->save_slot(slot_name, original_title, original_metadata,
                         original_world_state, original_screenshot, &error);
   ASSERT_TRUE(saved) << "Save failed: " << error.toStdString();
 
@@ -65,7 +65,7 @@ TEST_F(SaveStorageTest, SaveAndLoadSlot) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   ASSERT_TRUE(loaded) << "Load failed: " << error.toStdString();
@@ -95,11 +95,11 @@ TEST_F(SaveStorageTest, OverwriteExistingSlot) {
 
   QString error;
 
-  bool saved1 = storage->saveSlot(slot_name, title1, metadata1, world_state1,
+  bool saved1 = storage->save_slot(slot_name, title1, metadata1, world_state1,
                                   QByteArray(), &error);
   ASSERT_TRUE(saved1) << "First save failed: " << error.toStdString();
 
-  bool saved2 = storage->saveSlot(slot_name, title2, metadata2, world_state2,
+  bool saved2 = storage->save_slot(slot_name, title2, metadata2, world_state2,
                                   QByteArray(), &error);
   ASSERT_TRUE(saved2) << "Second save failed: " << error.toStdString();
 
@@ -109,7 +109,7 @@ TEST_F(SaveStorageTest, OverwriteExistingSlot) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   ASSERT_TRUE(loaded) << "Load failed: " << error.toStdString();
@@ -129,7 +129,7 @@ TEST_F(SaveStorageTest, LoadNonExistentSlot) {
   QString error;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   EXPECT_FALSE(loaded);
@@ -140,14 +140,14 @@ TEST_F(SaveStorageTest, ListSlots) {
   QString error;
 
   QByteArray non_empty_data("test_data");
-  storage->saveSlot("slot1", "Title 1", QJsonObject(), non_empty_data,
+  storage->save_slot("slot1", "Title 1", QJsonObject(), non_empty_data,
                     QByteArray(), &error);
-  storage->saveSlot("slot2", "Title 2", QJsonObject(), non_empty_data,
+  storage->save_slot("slot2", "Title 2", QJsonObject(), non_empty_data,
                     QByteArray(), &error);
-  storage->saveSlot("slot3", "Title 3", QJsonObject(), non_empty_data,
+  storage->save_slot("slot3", "Title 3", QJsonObject(), non_empty_data,
                     QByteArray(), &error);
 
-  QVariantList slot_list = storage->listSlots(&error);
+  QVariantList slot_list = storage->list_slots(&error);
 
   EXPECT_TRUE(error.isEmpty()) << "List failed: " << error.toStdString();
   EXPECT_EQ(slot_list.size(), 3);
@@ -182,16 +182,16 @@ TEST_F(SaveStorageTest, DeleteSlot) {
   QString error;
 
   QByteArray non_empty_data("test_data");
-  storage->saveSlot(slot_name, "Title", QJsonObject(), non_empty_data,
+  storage->save_slot(slot_name, "Title", QJsonObject(), non_empty_data,
                     QByteArray(), &error);
 
-  QVariantList slots_before = storage->listSlots(&error);
+  QVariantList slots_before = storage->list_slots(&error);
   EXPECT_EQ(slots_before.size(), 1);
 
-  bool deleted = storage->deleteSlot(slot_name, &error);
+  bool deleted = storage->delete_slot(slot_name, &error);
   EXPECT_TRUE(deleted) << "Delete failed: " << error.toStdString();
 
-  QVariantList slots_after = storage->listSlots(&error);
+  QVariantList slots_after = storage->list_slots(&error);
   EXPECT_EQ(slots_after.size(), 0);
 }
 
@@ -199,7 +199,7 @@ TEST_F(SaveStorageTest, DeleteNonExistentSlot) {
   QString slot_name = "nonexistent_delete";
   QString error;
 
-  bool deleted = storage->deleteSlot(slot_name, &error);
+  bool deleted = storage->delete_slot(slot_name, &error);
 
   EXPECT_FALSE(deleted);
   EXPECT_FALSE(error.isEmpty());
@@ -210,7 +210,7 @@ TEST_F(SaveStorageTest, EmptyMetadataSave) {
   QJsonObject empty_metadata;
 
   QString error;
-  bool saved = storage->saveSlot(slot_name, "Title", empty_metadata,
+  bool saved = storage->save_slot(slot_name, "Title", empty_metadata,
                                  QByteArray("data"), QByteArray(), &error);
 
   EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
@@ -221,7 +221,7 @@ TEST_F(SaveStorageTest, EmptyMetadataSave) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
@@ -232,7 +232,7 @@ TEST_F(SaveStorageTest, EmptyWorldStateSave) {
   QByteArray minimal_world_state(" ");
 
   QString error;
-  bool saved = storage->saveSlot(slot_name, "Title", QJsonObject(),
+  bool saved = storage->save_slot(slot_name, "Title", QJsonObject(),
                                  minimal_world_state, QByteArray(), &error);
 
   EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
@@ -243,7 +243,7 @@ TEST_F(SaveStorageTest, EmptyWorldStateSave) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
@@ -260,7 +260,7 @@ TEST_F(SaveStorageTest, LargeDataSave) {
   metadata["size"] = "large";
 
   QString error;
-  bool saved = storage->saveSlot(slot_name, "Large Data Test", metadata,
+  bool saved = storage->save_slot(slot_name, "Large Data Test", metadata,
                                  large_world_state, large_screenshot, &error);
 
   EXPECT_TRUE(saved) << "Failed to save large data: " << error.toStdString();
@@ -271,7 +271,7 @@ TEST_F(SaveStorageTest, LargeDataSave) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   EXPECT_TRUE(loaded) << "Failed to load large data: " << error.toStdString();
@@ -287,7 +287,7 @@ TEST_F(SaveStorageTest, SpecialCharactersInSlotName) {
   metadata["description"] = "Test with special characters: <>&\"'";
 
   QString error;
-  bool saved = storage->saveSlot(slot_name, title, metadata, QByteArray("data"),
+  bool saved = storage->save_slot(slot_name, title, metadata, QByteArray("data"),
                                  QByteArray(), &error);
 
   EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
@@ -298,7 +298,7 @@ TEST_F(SaveStorageTest, SpecialCharactersInSlotName) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
@@ -325,7 +325,7 @@ TEST_F(SaveStorageTest, ComplexMetadataSave) {
   metadata["array"] = array;
 
   QString error;
-  bool saved = storage->saveSlot(slot_name, "Complex Metadata Test", metadata,
+  bool saved = storage->save_slot(slot_name, "Complex Metadata Test", metadata,
                                  QByteArray("data"), QByteArray(), &error);
 
   EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
@@ -336,7 +336,7 @@ TEST_F(SaveStorageTest, ComplexMetadataSave) {
   QString loaded_title;
 
   bool loaded =
-      storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+      storage->load_slot(slot_name, loaded_world_state, loaded_metadata,
                         loaded_screenshot, loaded_title, &error);
 
   EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
@@ -361,19 +361,19 @@ TEST_F(SaveStorageTest, MultipleSavesAndDeletes) {
 
   for (int i = 0; i < 10; i++) {
     QString slot_name = QString("slot_%1").arg(i);
-    storage->saveSlot(slot_name, QString("Title %1").arg(i), QJsonObject(),
+    storage->save_slot(slot_name, QString("Title %1").arg(i), QJsonObject(),
                       QByteArray("data"), QByteArray(), &error);
   }
 
-  QVariantList slot_list = storage->listSlots(&error);
+  QVariantList slot_list = storage->list_slots(&error);
   EXPECT_EQ(slot_list.size(), 10);
 
   for (int i = 0; i < 5; i++) {
     QString slot_name = QString("slot_%1").arg(i);
-    storage->deleteSlot(slot_name, &error);
+    storage->delete_slot(slot_name, &error);
   }
 
-  slot_list = storage->listSlots(&error);
+  slot_list = storage->list_slots(&error);
   EXPECT_EQ(slot_list.size(), 5);
 
   for (const QVariant &slot_variant : slot_list) {