revert af4230500e

revert add launcher folder and some checks to it
2026-08-22 23:39:46 +00:00
parent af4230500e
commit 2c51c4736a
13 changed files with 169 additions and 328 deletions
@@ -18,8 +18,6 @@ qt_add_qml_module(appMinecraft_launcher
    SOURCES
        launcherbackend.h
        launcherbackend.cpp
-        launcherpaths.h
-        launcherpaths.cpp
        minecraftversion.h
        minecraftversion.cpp
        javalocator.h
@@ -13,8 +13,7 @@
 namespace {

 const QString kAuthServer = QStringLiteral("https://authserver.ely.by");
-const QString kInjectorManifest = QStringLiteral(
-    "https://authlib-injector.yushi.moe/artifact/latest.json");
+const QString kInjectorManifest = QStringLiteral("https://authlib-injector.yushi.moe/artifact/latest.json");
 const QString kInjectorFileName = QStringLiteral("authlib-injector.jar");

 // Ely.by отдаёт UUID без дефисов, вручную введённый мог прийти и с ними.
@@ -39,7 +38,8 @@ QString describeElyError(const QJsonObject &response, int status)
 AuthService::AuthService(QObject *parent)
    : QObject(parent)
    , m_network(new QNetworkAccessManager(this))
-{}
+{
+}

 AuthResult AuthService::offline(const QString &nickname)
 {
@@ -49,11 +49,10 @@ AuthResult AuthService::offline(const QString &nickname)
        return result;
    }

-    QByteArray digest
-        = QCryptographicHash::hash(QStringLiteral("OfflinePlayer:%1").arg(nickname).toUtf8(),
-                                   QCryptographicHash::Md5);
-    digest[6] = static_cast<char>((digest[6] & 0x0f) | 0x30); // версия UUID = 3
-    digest[8] = static_cast<char>((digest[8] & 0x3f) | 0x80); // вариант RFC 4122
+    QByteArray digest = QCryptographicHash::hash(
+        QStringLiteral("OfflinePlayer:%1").arg(nickname).toUtf8(), QCryptographicHash::Md5);
+    digest[6] = static_cast<char>((digest[6] & 0x0f) | 0x30);   // версия UUID = 3
+    digest[8] = static_cast<char>((digest[8] & 0x3f) | 0x80);   // вариант RFC 4122

    result.ok = true;
    result.playerName = nickname;
@@ -69,17 +68,17 @@ QString AuthService::generateClientToken()
    return QUuid::createUuid().toString(QUuid::WithoutBraces);
 }

-void AuthService::postJson(const QString &endpoint,
-                           const QJsonObject &body,
-                           std::function<void(int, const QJsonObject &, const QString &)> handler)
+void AuthService::postJson(
+    const QString &endpoint,
+    const QJsonObject &body,
+    std::function<void(int, const QJsonObject &, const QString &)> handler)
 {
    QNetworkRequest request{QUrl(kAuthServer + endpoint)};
    request.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/json"));
    request.setAttribute(QNetworkRequest::RedirectPolicyAttribute,
                         QNetworkRequest::NoLessSafeRedirectPolicy);

-    QNetworkReply *reply = m_network->post(request,
-                                           QJsonDocument(body).toJson(QJsonDocument::Compact));
+    QNetworkReply *reply = m_network->post(request, QJsonDocument(body).toJson(QJsonDocument::Compact));
    connect(reply, &QNetworkReply::finished, this, [reply, handler = std::move(handler)]() {
        reply->deleteLater();

@@ -119,9 +118,8 @@ void AuthService::loginElyBy(const QString &login,
    emit progress(tr("Проверка сохранённого токена Ely.by…"));
    postJson(QStringLiteral("/auth/validate"),
             {{QStringLiteral("accessToken"), accessToken}},
-             [this, login, password, token, accessToken, callback](int status,
-                                                                   const QJsonObject &,
-                                                                   const QString &transportError) {
+             [this, login, password, token, accessToken, callback](
+                 int status, const QJsonObject &, const QString &transportError) {
                 if (!transportError.isEmpty()) {
                     AuthResult result;
                     result.error = tr("Нет связи с authserver.ely.by: %1").arg(transportError);
@@ -145,21 +143,17 @@ void AuthService::loginElyBy(const QString &login,
                          {{QStringLiteral("accessToken"), accessToken},
                           {QStringLiteral("clientToken"), token},
                           {QStringLiteral("requestUser"), true}},
-                          [this, login, password, token, callback](int refreshStatus,
-                                                                   const QJsonObject &response,
-                                                                   const QString &error) {
+                          [this, login, password, token, callback](
+                              int refreshStatus, const QJsonObject &response, const QString &error) {
                              if (error.isEmpty() && refreshStatus == 200) {
                                  AuthResult result;
                                  result.ok = true;
-                                  result.accessToken = response.value(QStringLiteral("accessToken"))
-                                                           .toString();
+                                  result.accessToken = response.value(QStringLiteral("accessToken")).toString();
                                  result.clientToken = token;
-                                  const QJsonObject profile
-                                      = response.value(QStringLiteral("selectedProfile")).toObject();
-                                  result.playerName = profile.value(QStringLiteral("name"))
-                                                          .toString();
-                                  result.uuid = normalizeUuid(
-                                      profile.value(QStringLiteral("id")).toString());
+                                  const QJsonObject profile =
+                                      response.value(QStringLiteral("selectedProfile")).toObject();
+                                  result.playerName = profile.value(QStringLiteral("name")).toString();
+                                  result.uuid = normalizeUuid(profile.value(QStringLiteral("id")).toString());
                                  result.userType = QStringLiteral("ELYBY");
                                  callback(result);
                                  return;
@@ -200,14 +194,12 @@ void AuthService::authenticate(const QString &login,
              {QStringLiteral("password"), password},
              {QStringLiteral("clientToken"), clientToken},
              {QStringLiteral("requestUser"), true}},
-             [clientToken,
-              callback](int status, const QJsonObject &response, const QString &transportError) {
+             [clientToken, callback](int status, const QJsonObject &response, const QString &transportError) {
                 AuthResult result;
                 result.clientToken = clientToken;

                 if (!transportError.isEmpty()) {
-                     result.error = AuthService::tr("Нет связи с authserver.ely.by: %1")
-                                        .arg(transportError);
+                     result.error = AuthService::tr("Нет связи с authserver.ely.by: %1").arg(transportError);
                     callback(result);
                     return;
                 }
@@ -218,29 +210,27 @@ void AuthService::authenticate(const QString &login,
                     result.twoFactorRequired = message.contains(QStringLiteral("two factor"),
                                                                 Qt::CaseInsensitive);
                     result.error = result.twoFactorRequired
-                                        ? AuthService::tr(
-                                              "Аккаунт защищён двухфакторной аутентификацией")
+                                        ? AuthService::tr("Аккаунт защищён двухфакторной аутентификацией")
                                        : message;
                     callback(result);
                     return;
                 }

-                 const QJsonObject profile = response.value(QStringLiteral("selectedProfile"))
-                                                 .toObject();
+                 const QJsonObject profile = response.value(QStringLiteral("selectedProfile")).toObject();
                 result.playerName = profile.value(QStringLiteral("name")).toString();
                 result.uuid = normalizeUuid(profile.value(QStringLiteral("id")).toString());
                 result.accessToken = response.value(QStringLiteral("accessToken")).toString();
                 result.userType = QStringLiteral("ELYBY");
                 result.ok = !result.accessToken.isEmpty() && !result.playerName.isEmpty();
                 if (!result.ok)
-                     result.error = AuthService::tr(
-                         "Ely.by не вернул игровой профиль для этого аккаунта");
+                     result.error = AuthService::tr("Ely.by не вернул игровой профиль для этого аккаунта");
                 callback(result);
             });
 }

 void AuthService::ensureAuthlibInjector(
-    const QString &targetDir, std::function<void(const QString &, const QString &)> callback)
+    const QString &targetDir,
+    std::function<void(const QString &, const QString &)> callback)
 {
    QDir().mkpath(targetDir);
    const QString jarPath = targetDir + u'/' + kInjectorFileName;
@@ -258,9 +248,8 @@ void AuthService::ensureAuthlibInjector(
    connect(manifestReply, &QNetworkReply::finished, this, [this, manifestReply, jarPath, callback]() {
        manifestReply->deleteLater();
        if (manifestReply->error() != QNetworkReply::NoError) {
-            callback({},
-                     tr("Не удалось получить сведения об authlib-injector: %1")
-                         .arg(manifestReply->errorString()));
+            callback({}, tr("Не удалось получить сведения об authlib-injector: %1")
+                             .arg(manifestReply->errorString()));
            return;
        }

@@ -279,39 +268,30 @@ void AuthService::ensureAuthlibInjector(
        jarRequest.setAttribute(QNetworkRequest::RedirectPolicyAttribute,
                                QNetworkRequest::NoLessSafeRedirectPolicy);
        QNetworkReply *jarReply = m_network->get(jarRequest);
-        connect(jarReply,
-                &QNetworkReply::finished,
-                this,
-                [jarReply, jarPath, expectedSha256, callback]() {
-                    jarReply->deleteLater();
-                    if (jarReply->error() != QNetworkReply::NoError) {
-                        callback({},
-                                 AuthService::tr("Не удалось скачать authlib-injector: %1")
-                                     .arg(jarReply->errorString()));
-                        return;
-                    }
+        connect(jarReply, &QNetworkReply::finished, this, [jarReply, jarPath, expectedSha256, callback]() {
+            jarReply->deleteLater();
+            if (jarReply->error() != QNetworkReply::NoError) {
+                callback({}, AuthService::tr("Не удалось скачать authlib-injector: %1").arg(jarReply->errorString()));
+                return;
+            }

-                    const QByteArray payload = jarReply->readAll();
-                    if (!expectedSha256.isEmpty()) {
-                        const QString actual = QString::fromLatin1(
-                            QCryptographicHash::hash(payload, QCryptographicHash::Sha256).toHex());
-                        if (actual != expectedSha256) {
-                            callback({},
-                                     AuthService::tr(
-                                         "Контрольная сумма authlib-injector не совпала"));
-                            return;
-                        }
-                    }
+            const QByteArray payload = jarReply->readAll();
+            if (!expectedSha256.isEmpty()) {
+                const QString actual = QString::fromLatin1(
+                    QCryptographicHash::hash(payload, QCryptographicHash::Sha256).toHex());
+                if (actual != expectedSha256) {
+                    callback({}, AuthService::tr("Контрольная сумма authlib-injector не совпала"));
+                    return;
+                }
+            }

-                    QFile file(jarPath);
-                    if (!file.open(QIODevice::WriteOnly) || file.write(payload) != payload.size()) {
-                        callback({},
-                                 AuthService::tr("Не удалось сохранить %1")
-                                     .arg(QDir::toNativeSeparators(jarPath)));
-                        return;
-                    }
-                    file.close();
-                    callback(jarPath, {});
-                });
+            QFile file(jarPath);
+            if (!file.open(QIODevice::WriteOnly) || file.write(payload) != payload.size()) {
+                callback({}, AuthService::tr("Не удалось сохранить %1").arg(QDir::toNativeSeparators(jarPath)));
+                return;
+            }
+            file.close();
+            callback(jarPath, {});
+        });
    });
 }
@@ -14,11 +14,11 @@ struct AuthResult
    bool twoFactorRequired = false;
    QString error;

-    QString playerName;  // ${auth_player_name}
-    QString uuid;        // ${auth_uuid}, hex без дефисов
-    QString accessToken; // ${auth_access_token}
-    QString clientToken; // ${clientid}
-    QString userType;    // ${user_type}: legacy / msa / ELYBY
+    QString playerName;     // ${auth_player_name}
+    QString uuid;           // ${auth_uuid}, hex без дефисов
+    QString accessToken;    // ${auth_access_token}
+    QString clientToken;    // ${clientid}
+    QString userType;       // ${user_type}: legacy / msa / ELYBY
 };

 // Yggdrasil-клиент Ely.by плюс офлайн-режим. Все сетевые методы асинхронные:
@@ -56,19 +56,16 @@ public:

    // Скачивает authlib-injector в targetDir, если его там ещё нет.
    // Колбэк получает путь к jar либо текст ошибки.
-    void ensureAuthlibInjector(
-        const QString &targetDir,
-        std::function<void(const QString &path, const QString &error)> callback);
+    void ensureAuthlibInjector(const QString &targetDir,
+                               std::function<void(const QString &path, const QString &error)> callback);

 signals:
    void progress(const QString &message);

 private:
-    void postJson(
-        const QString &endpoint,
-        const QJsonObject &body,
-        std::function<void(int status, const QJsonObject &response, const QString &transportError)>
-            handler);
+    void postJson(const QString &endpoint,
+                  const QJsonObject &body,
+                  std::function<void(int status, const QJsonObject &response, const QString &transportError)> handler);

    void authenticate(const QString &login,
                      const QString &password,
@@ -45,14 +45,15 @@ bool isNativeLibraryFile(const QString &fileName)
    for (const QString &suffix : suffixes)
        if (fileName.endsWith(suffix, Qt::CaseInsensitive))
            return true;
-    return fileName.contains(QStringLiteral(".so.")); // libfoo.so.1
+    return fileName.contains(QStringLiteral(".so."));   // libfoo.so.1
 }

 } // namespace

 GameLauncher::GameLauncher(QObject *parent)
    : QObject(parent)
-{}
+{
+}

 bool GameLauncher::isRunning() const
 {
@@ -100,7 +101,7 @@ QStringList GameLauncher::buildArguments(const LaunchOptions &options,
    QStringList classpath;
    for (const MinecraftLibrary &library : version.libraries) {
        if (library.native)
-            continue; // натив-библиотеки только распаковываются
+            continue;   // натив-библиотеки только распаковываются
        classpath << nativeToken(libraryPath(options.gameDir, library));
    }
    classpath << nativeToken(version.clientJarPath);
@@ -113,11 +114,11 @@ QStringList GameLauncher::buildArguments(const LaunchOptions &options,
    variables[QStringLiteral("auth_player_name")] = options.playerName;
    variables[QStringLiteral("auth_uuid")] = options.uuid;
    variables[QStringLiteral("auth_access_token")] = options.accessToken;
-    variables[QStringLiteral("auth_session")] = QStringLiteral("token:%1:%2")
-                                                    .arg(options.accessToken, options.uuid);
+    variables[QStringLiteral("auth_session")] =
+        QStringLiteral("token:%1:%2").arg(options.accessToken, options.uuid);
    variables[QStringLiteral("auth_xuid")] = QStringLiteral("0");
-    variables[QStringLiteral("clientid")] = options.clientToken.isEmpty() ? QStringLiteral("0")
-                                                                          : options.clientToken;
+    variables[QStringLiteral("clientid")] =
+        options.clientToken.isEmpty() ? QStringLiteral("0") : options.clientToken;
    variables[QStringLiteral("user_type")] = options.userType;
    variables[QStringLiteral("user_properties")] = QStringLiteral("{}");
    variables[QStringLiteral("version_name")] = version.id;
@@ -125,11 +126,11 @@ QStringList GameLauncher::buildArguments(const LaunchOptions &options,
    variables[QStringLiteral("game_directory")] = nativeToken(options.gameDir);
    variables[QStringLiteral("assets_root")] = nativeToken(assetsRoot);
    variables[QStringLiteral("assets_index_name")] = version.assetIndexId;
-    variables[QStringLiteral("game_assets")] = nativeToken(
-        legacyAssets ? assetsRoot + QStringLiteral("/virtual/legacy") : assetsRoot);
+    variables[QStringLiteral("game_assets")] =
+        nativeToken(legacyAssets ? assetsRoot + QStringLiteral("/virtual/legacy") : assetsRoot);
    variables[QStringLiteral("natives_directory")] = nativeToken(nativesDir);
-    variables[QStringLiteral("library_directory")] = nativeToken(options.gameDir
-                                                                 + QStringLiteral("/libraries"));
+    variables[QStringLiteral("library_directory")] =
+        nativeToken(options.gameDir + QStringLiteral("/libraries"));
    variables[QStringLiteral("classpath")] = classpath.join(kClasspathSeparator);
    variables[QStringLiteral("classpath_separator")] = QString(kClasspathSeparator);
    variables[QStringLiteral("primary_jar")] = nativeToken(version.clientJarPath);
@@ -173,8 +174,8 @@ QStringList GameLauncher::buildArguments(const LaunchOptions &options,
    }

    // Разрешение окна: у старых версий фич-флага нет, аргументы всё равно понимаются.
-    if (options.windowWidth > 0 && options.windowHeight > 0 && !version.hasCustomResolutionArgs
-        && !arguments.contains(QStringLiteral("--width"))) {
+    if (options.windowWidth > 0 && options.windowHeight > 0
+        && !version.hasCustomResolutionArgs && !arguments.contains(QStringLiteral("--width"))) {
        arguments << QStringLiteral("--width") << QString::number(options.windowWidth)
                  << QStringLiteral("--height") << QString::number(options.windowHeight);
    }
@@ -186,8 +187,7 @@ QStringList GameLauncher::buildArguments(const LaunchOptions &options,
            arguments << QStringLiteral("--quickPlayMultiplayer") << options.serverAddress;
        } else {
            const int colon = options.serverAddress.lastIndexOf(u':');
-            const QString host = colon > 0 ? options.serverAddress.left(colon)
-                                           : options.serverAddress;
+            const QString host = colon > 0 ? options.serverAddress.left(colon) : options.serverAddress;
            const QString port = colon > 0 ? options.serverAddress.mid(colon + 1)
                                           : QStringLiteral("25565");
            arguments << QStringLiteral("--server") << host << QStringLiteral("--port") << port;
@@ -247,7 +247,7 @@ bool GameLauncher::extractNatives(const LaunchOptions &options,
            const QString target = nativesDir + u'/' + fileName;
            const QByteArray data = reader.fileData(entry.filePath);
            if (QFileInfo(target).size() == data.size() && QFile::exists(target))
-                continue; // уже распаковано этим же лаунчером
+                continue;   // уже распаковано этим же лаунчером

            QFile file(target);
            if (!file.open(QIODevice::WriteOnly) || file.write(data) != data.size()) {
@@ -289,10 +289,7 @@ bool GameLauncher::launch(const LaunchOptions &options,
        return false;

    emit progress(tr("Поиск Java %1…").arg(version.javaMajor));
-    const QString java = JavaLocator::select(options.gameDir,
-                                             version.javaMajor,
-                                             options.javaPath,
-                                             error);
+    const QString java = JavaLocator::select(options.gameDir, version.javaMajor, options.javaPath, error);
    if (java.isEmpty())
        return false;

@@ -10,8 +10,8 @@ class QProcess;
 // Всё, что лаунчер знает к моменту нажатия PLAY.
 struct LaunchOptions
 {
-    QString gameDir;   // .minecraft
-    QString versionId; // Папка в versions
+    QString gameDir;            // .minecraft
+    QString versionId;          // Папка в versions

    QString playerName;
    QString uuid;
@@ -19,17 +19,17 @@ struct LaunchOptions
    QString userType;
    QString clientToken;

-    QString javaPath; // Пусто — ищем сами
+    QString javaPath;           // Пусто — ищем сами
    int minMemoryMb = 512;
    int maxMemoryMb = 4096;
    QStringList extraJvmArgs;

-    int windowWidth = 0; // 0 — не передавать --width/--height
+    int windowWidth = 0;        // 0 — не передавать --width/--height
    int windowHeight = 0;
    bool fullscreen = false;

-    QString serverAddress;       // host[:port] — автозаход на сервер
-    QString authlibInjectorPath; // Пусто — не подключаем
+    QString serverAddress;      // host[:port] — автозаход на сервер
+    QString authlibInjectorPath;                            // Пусто — не подключаем
    QString authlibInjectorApi = QStringLiteral("ely.by");

    QString launcherName = QStringLiteral("KishkaLauncher");
@@ -4,9 +4,9 @@
 #include <QDirIterator>
 #include <QFileInfo>
 #include <QHash>
-#include <QObject>
 #include <QProcess>
 #include <QProcessEnvironment>
+#include <QObject>
 #include <QRegularExpression>
 #include <QStandardPaths>
 #include <utility>
@@ -75,10 +75,8 @@ QStringList JavaLocator::findAll(const QString &gameDir)
    // 1. Рантайм, скачанный самим Minecraft: .minecraft/runtime/<component>/<os>/<component>/bin
    const QString runtime = gameDir + QStringLiteral("/runtime");
    if (QDir(runtime).exists()) {
-        QDirIterator it(runtime,
-                        QStringList{QString::fromLatin1(kExecutable)},
-                        QDir::Files | QDir::Executable,
-                        QDirIterator::Subdirectories);
+        QDirIterator it(runtime, QStringList{QString::fromLatin1(kExecutable)},
+                        QDir::Files | QDir::Executable, QDirIterator::Subdirectories);
        while (it.hasNext()) {
            it.next();
            appendIfExecutable(result, it.fileInfo().absolutePath());
@@ -105,7 +103,7 @@ QStringList JavaLocator::findAll(const QString &gameDir)
        for (const QString &entry : entries) {
            const QString home = dir.absoluteFilePath(entry);
            appendIfExecutable(result, home + QStringLiteral("/bin"));
-            appendIfExecutable(result, home + QStringLiteral("/Contents/Home/bin")); // macOS
+            appendIfExecutable(result, home + QStringLiteral("/Contents/Home/bin"));   // macOS
            appendIfExecutable(result, home + QStringLiteral("/jre/bin"));
        }
    }
@@ -174,8 +172,7 @@ QString JavaLocator::select(const QString &gameDir,

    if (candidates.isEmpty()) {
        if (error)
-            *error = QObject::tr(
-                         "Java не найдена. Установите JDK %1 или укажите путь в настройках.")
+            *error = QObject::tr("Java не найдена. Установите JDK %1 или укажите путь в настройках.")
                         .arg(requiredMajor);
        return {};
    }
@@ -194,8 +191,7 @@ QString JavaLocator::select(const QString &gameDir,

    if (error) {
        *error = bestBelowMajor > 0
-                     ? QObject::tr(
-                           "Для этой версии нужна Java %1 или новее, найдена только Java %2 (%3).")
+                     ? QObject::tr("Для этой версии нужна Java %1 или новее, найдена только Java %2 (%3).")
                           .arg(requiredMajor)
                           .arg(bestBelowMajor)
                           .arg(QDir::toNativeSeparators(bestBelow))
@@ -17,6 +17,9 @@ QString windowlessVariant(const QString &javaPath);

 // Выбирает java не ниже requiredMajor. preferred, если задан, проверяется первым.
 // При неудаче возвращает пустую строку и заполняет error.
-QString select(const QString &gameDir, int requiredMajor, const QString &preferred, QString *error);
+QString select(const QString &gameDir,
+               int requiredMajor,
+               const QString &preferred,
+               QString *error);

 } // namespace JavaLocator
@@ -3,7 +3,6 @@
 #include "authservice.h"
 #include "gamelauncher.h"
 #include "javalocator.h"
-#include "launcherpaths.h"

 #include <QDesktopServices>
 #include <QDir>
@@ -12,7 +11,7 @@
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QRegularExpression>
-#include <QTimer>
+#include <QStandardPaths>
 #include <QUrl>
 #include <algorithm>

@@ -33,16 +32,13 @@ int settingInt(const QVariantMap &settings, const QString &key, int fallback)

 LauncherBackend::LauncherBackend(QObject *parent)
    : QObject(parent)
+    , m_dataDir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation))
    , m_auth(new AuthService(this))
    , m_launcher(new GameLauncher(this))
 {
-    // Папка лаунчера создаётся при первом запуске и проверяется при каждом
-    // следующем — если её удалили, она появится снова.
-    LauncherPaths::ensureRootExists(&m_storageError);
-
+    QDir().mkpath(m_dataDir);
    loadSettings();
    loadData();
-    ensureDataFiles();

    connect(m_auth, &AuthService::progress, this, &LauncherBackend::launchProgress);
    connect(m_launcher, &GameLauncher::progress, this, &LauncherBackend::launchProgress);
@@ -55,13 +51,6 @@ LauncherBackend::LauncherBackend(QObject *parent)
        emit gameRunningChanged();
        emit gameFinished(exitCode, crashed);
    });
-
-    // Интерфейс подключается к сигналам уже после конструктора — сообщаем отложенно.
-    if (!m_storageError.isEmpty()) {
-        QTimer::singleShot(0, this, [this] {
-            emit launchError(tr("Не удалось создать папку лаунчера: %1").arg(m_storageError));
-        });
-    }
 }

 LauncherBackend::~LauncherBackend() = default;
@@ -109,9 +98,7 @@ void LauncherBackend::addProfile(const QString &name,
    emit profilesChanged();
 }

-void LauncherBackend::addVersion(const QString &name,
-                                 const QString &serverUrl,
-                                 const QString &versionId)
+void LauncherBackend::addVersion(const QString &name, const QString &serverUrl, const QString &versionId)
 {
    m_versions.append({m_nextVersionId++, name, serverUrl, versionId});
    saveVersions();
@@ -247,11 +234,11 @@ void LauncherBackend::launchGame(int profileIndex, int versionIndex)
    const QString id = versionIdOf(m_versions[versionIndex]);
    const QStringList installed = VersionLoader::installedVersions(directory);
    if (!installed.contains(id)) {
-        emit launchError(installed.isEmpty() ? tr("В %1 нет ни одной установленной версии")
-                                                   .arg(QDir::toNativeSeparators(
-                                                       directory + QStringLiteral("/versions")))
-                                             : tr("Версия «%1» не установлена. Доступны: %2")
-                                                   .arg(id, installed.join(QStringLiteral(", "))));
+        emit launchError(installed.isEmpty()
+                             ? tr("В %1 нет ни одной установленной версии")
+                                   .arg(QDir::toNativeSeparators(directory + QStringLiteral("/versions")))
+                             : tr("Версия «%1» не установлена. Доступны: %2")
+                                   .arg(id, installed.join(QStringLiteral(", "))));
        return;
    }

@@ -304,10 +291,9 @@ void LauncherBackend::beginAuthentication()

    // Ely.by работает только вместе с authlib-injector — без него игра пойдёт
    // в сессионный сервер Mojang и токен окажется недействительным.
-    m_auth->ensureAuthlibInjector(LauncherPaths::runtimeDir(),
-                                  [this](const QString &path, const QString &error) {
+    m_auth->ensureAuthlibInjector(m_dataDir, [this](const QString &path, const QString &error) {
        if (m_pendingProfile < 0)
-            return; // запуск отменили, пока качался инжектор
+            return;   // запуск отменили, пока качался инжектор
        if (!error.isEmpty()) {
            failLaunch(error);
            return;
@@ -459,11 +445,21 @@ void LauncherBackend::setBusy(bool busy)
    emit busyChanged();
 }

+QString LauncherBackend::defaultMinecraftDir() const
+{
+#if defined(Q_OS_WIN)
+    return QDir::homePath() + QStringLiteral("/AppData/Roaming/.minecraft");
+#elif defined(Q_OS_MACOS)
+    return QDir::homePath() + QStringLiteral("/Library/Application Support/minecraft");
+#else // Linux и прочие Unix-системы
+    return QDir::homePath() + QStringLiteral("/.minecraft");
+#endif
+}
+
 QString LauncherBackend::gameDir() const
 {
    const QString configured = m_settings.value(QStringLiteral("gameDir")).toString().trimmed();
-    return configured.isEmpty() ? LauncherPaths::defaultMinecraftDir()
-                                : QDir::fromNativeSeparators(configured);
+    return configured.isEmpty() ? defaultMinecraftDir() : QDir::fromNativeSeparators(configured);
 }

 QVariantMap LauncherBackend::settings() const
@@ -526,7 +522,7 @@ void LauncherBackend::loadData()
            handler(val.toObject());
    };

-    loadFile(LauncherPaths::profilesFile(), [this](const QJsonObject &o) {
+    loadFile(m_dataDir + "/profiles.json", [this](const QJsonObject &o) {
        Profile profile;
        profile.id = o["id"].toInt();
        profile.name = o["name"].toString();
@@ -544,32 +540,18 @@ void LauncherBackend::loadData()
        if (profile.id >= m_nextProfileId)
            m_nextProfileId = profile.id + 1;
    });
-    std::sort(m_profiles.begin(), m_profiles.end(), [](const Profile &a, const Profile &b) {
-        return a.id < b.id;
-    });
+    std::sort(m_profiles.begin(), m_profiles.end(),
+              [](const Profile &a, const Profile &b) { return a.id < b.id; });

-    loadFile(LauncherPaths::versionsFile(), [this](const QJsonObject &o) {
+    loadFile(m_dataDir + "/versions.json", [this](const QJsonObject &o) {
        const int id = o["id"].toInt();
-        m_versions.append(
-            {id, o["name"].toString(), o["serverUrl"].toString(), o.value("versionId").toString()});
+        m_versions.append({id, o["name"].toString(), o["serverUrl"].toString(),
+                           o.value("versionId").toString()});
        if (id >= m_nextVersionId)
            m_nextVersionId = id + 1;
    });
-    std::sort(m_versions.begin(), m_versions.end(), [](const Version &a, const Version &b) {
-        return a.id < b.id;
-    });
-}
-
-// Файлы могли не появиться при первом запуске или быть удалены — создаём заново,
-// чтобы папка лаунчера всегда была укомплектована.
-void LauncherBackend::ensureDataFiles()
-{
-    if (!QFile::exists(LauncherPaths::settingsFile()))
-        saveSettings();
-    if (!QFile::exists(LauncherPaths::profilesFile()))
-        saveProfiles();
-    if (!QFile::exists(LauncherPaths::versionsFile()))
-        saveVersions();
+    std::sort(m_versions.begin(), m_versions.end(),
+              [](const Version &a, const Version &b) { return a.id < b.id; });
 }

 void LauncherBackend::saveProfiles()
@@ -587,7 +569,7 @@ void LauncherBackend::saveProfiles()
                               {"resolvedName", p.resolvedName},
                               {"userType", p.userType}});

-    QFile f(LauncherPaths::profilesFile());
+    QFile f(m_dataDir + "/profiles.json");
    if (f.open(QIODevice::WriteOnly))
        f.write(QJsonDocument(arr).toJson());
 }
@@ -601,7 +583,7 @@ void LauncherBackend::saveVersions()
                               {"serverUrl", v.serverUrl},
                               {"versionId", v.versionId}});

-    QFile f(LauncherPaths::versionsFile());
+    QFile f(m_dataDir + "/versions.json");
    if (f.open(QIODevice::WriteOnly))
        f.write(QJsonDocument(arr).toJson());
 }
@@ -619,7 +601,7 @@ void LauncherBackend::loadSettings()
                  {QStringLiteral("launcherName"), QStringLiteral("KishkaLauncher")},
                  {QStringLiteral("launcherVersion"), QStringLiteral("1.0")}};

-    QFile f(LauncherPaths::settingsFile());
+    QFile f(m_dataDir + "/settings.json");
    if (!f.open(QIODevice::ReadOnly))
        return;

@@ -630,7 +612,7 @@ void LauncherBackend::loadSettings()

 void LauncherBackend::saveSettings()
 {
-    QFile f(LauncherPaths::settingsFile());
+    QFile f(m_dataDir + "/settings.json");
    if (f.open(QIODevice::WriteOnly))
        f.write(QJsonDocument(QJsonObject::fromVariantMap(m_settings)).toJson());
 }
@@ -90,7 +90,7 @@ private:
    {
        int id = 0;
        QString name, login, password;
-        QString authType = QStringLiteral("offline"); // offline | elyby
+        QString authType = QStringLiteral("offline");   // offline | elyby
        QString clientToken, accessToken, uuid, resolvedName, userType;
    };
    struct Version
@@ -101,11 +101,11 @@ private:

    void loadData();
    void loadSettings();
-    void ensureDataFiles();
    void saveProfiles();
    void saveVersions();
    void saveSettings();

+    QString defaultMinecraftDir() const;
    QString gameDir() const;
    QString versionIdOf(const Version &version) const;

@@ -117,7 +117,7 @@ private:
    QList<Profile> m_profiles;
    QList<Version> m_versions;
    QVariantMap m_settings;
-    QString m_storageError;
+    QString m_dataDir;
    int m_nextProfileId = 1;
    int m_nextVersionId = 1;

@@ -1,73 +0,0 @@
-#include "launcherpaths.h"
-
-#include <QCoreApplication>
-#include <QDir>
-
-namespace {
-
-const QString kFolderName = QStringLiteral("galeonLauncher");
-
-} // namespace
-
-QString LauncherPaths::containerDir()
-{
-#if defined(Q_OS_WIN)
-    return QDir::homePath() + QStringLiteral("/AppData/Roaming");
-#elif defined(Q_OS_MACOS)
-    return QDir::homePath() + QStringLiteral("/Library/Application Support");
-#else // Linux и прочие Unix-системы
-    return QDir::homePath();
-#endif
-}
-
-QString LauncherPaths::rootDir()
-{
-    return containerDir() + u'/' + kFolderName;
-}
-
-QString LauncherPaths::defaultMinecraftDir()
-{
-#if defined(Q_OS_MACOS)
-    // На macOS папка игры исторически без точки.
-    return containerDir() + QStringLiteral("/minecraft");
-#else
-    return containerDir() + QStringLiteral("/.minecraft");
-#endif
-}
-
-QString LauncherPaths::settingsFile()
-{
-    return rootDir() + QStringLiteral("/settings.json");
-}
-
-QString LauncherPaths::profilesFile()
-{
-    return rootDir() + QStringLiteral("/profiles.json");
-}
-
-QString LauncherPaths::versionsFile()
-{
-    return rootDir() + QStringLiteral("/versions.json");
-}
-
-QString LauncherPaths::runtimeDir()
-{
-    return rootDir() + QStringLiteral("/runtime");
-}
-
-bool LauncherPaths::ensureRootExists(QString *error)
-{
-    const QStringList required{rootDir(), runtimeDir()};
-    for (const QString &path : required) {
-        if (QDir().mkpath(path))
-            continue;
-
-        if (error) {
-            *error = QCoreApplication::translate("LauncherPaths",
-                                                 "не удалось создать %1")
-                         .arg(QDir::toNativeSeparators(path));
-        }
-        return false;
-    }
-    return true;
-}
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <QString>
-
-// Пути к данным лаунчера. Собственная папка galeonLauncher лежит рядом со
-// стандартной .minecraft, а не в системном каталоге приложения.
-namespace LauncherPaths {
-
-// Родительская папка, в которой лежит .minecraft (и наша galeonLauncher).
-QString containerDir();
-
-// <containerDir>/galeonLauncher — корень данных лаунчера.
-QString rootDir();
-
-// Стандартная папка игры.
-QString defaultMinecraftDir();
-
-QString settingsFile();
-QString profilesFile();
-QString versionsFile();
-
-// Сюда качается authlib-injector.
-QString runtimeDir();
-
-// Создаёт папку лаунчера, если её нет. Вызывается при каждом запуске.
-// false и текст в error, если создать не удалось.
-bool ensureRootExists(QString *error = nullptr);
-
-} // namespace LauncherPaths
@@ -47,8 +47,8 @@ QString mavenToPath(const QString &name)
    if (parts.size() > 3)
        file += u'-' + parts[3];

-    return QString(parts[0]).replace(u'.', u'/') + u'/' + parts[1] + u'/' + parts[2] + u'/' + file
-           + u'.' + extension;
+    return QString(parts[0]).replace(u'.', u'/') + u'/' + parts[1] + u'/' + parts[2]
+           + u'/' + file + u'.' + extension;
 }

 // Ключ для дедупликации: у наследника и родителя одна и та же библиотека часто
@@ -163,12 +163,9 @@ void parseLibraries(const QJsonObject &root,

        // Основной артефакт. В новом формате (1.19+) натив-библиотеки — это
        // отдельные записи с классификатором natives-*, у них тоже есть artifact.
-        if (downloads.contains(QStringLiteral("artifact"))
-            || !downloads.contains(QStringLiteral("classifiers"))) {
-            MinecraftLibrary library
-                = libraryFromDownload(name,
-                                      downloads.value(QStringLiteral("artifact")).toObject(),
-                                      relativePath);
+        if (downloads.contains(QStringLiteral("artifact")) || !downloads.contains(QStringLiteral("classifiers"))) {
+            MinecraftLibrary library = libraryFromDownload(
+                name, downloads.value(QStringLiteral("artifact")).toObject(), relativePath);

            // У Fabric у части библиотек нет блока downloads вообще — только
            // name и адрес Maven-репозитория, путь собираем из координат.
@@ -196,12 +193,13 @@ void parseLibraries(const QJsonObject &root,
            continue;
        classifier.replace(QStringLiteral("${arch}"),
                           VersionLoader::osArch() == QStringLiteral("x86") ? QStringLiteral("32")
-                                                                            : QStringLiteral("64"));
+                                                                           : QStringLiteral("64"));

        const QJsonObject classifiers = downloads.value(QStringLiteral("classifiers")).toObject();
-        MinecraftLibrary library = libraryFromDownload(name + u':' + classifier,
-                                                       classifiers.value(classifier).toObject(),
-                                                       mavenToPath(name + u':' + classifier));
+        MinecraftLibrary library = libraryFromDownload(
+            name + u':' + classifier,
+            classifiers.value(classifier).toObject(),
+            mavenToPath(name + u':' + classifier));
        if (library.path.isEmpty())
            continue;

@@ -221,7 +219,7 @@ void pickNativesForCurrentArch(QList<MinecraftLibrary> &libraries)
                               : VersionLoader::osName();
    const QString base = QStringLiteral("natives-") + osPart;

-    QHash<QString, QString> chosen; // group:artifact -> классификатор
+    QHash<QString, QString> chosen;   // group:artifact -> классификатор
    for (const MinecraftLibrary &library : libraries) {
        if (!library.native)
            continue;
@@ -265,7 +263,7 @@ QString VersionLoader::osArch()
    const QString arch = QSysInfo::currentCpuArchitecture();
    if (arch == QLatin1String("i386") || arch == QLatin1String("i686"))
        return QStringLiteral("x86");
-    return arch; // x86_64 / arm64 — совпадают с тем, что пишет Mojang
+    return arch;   // x86_64 / arm64 — совпадают с тем, что пишет Mojang
 }

 QString VersionLoader::nativeClassifier()
@@ -328,14 +326,12 @@ MinecraftVersion VersionLoader::load(const QString &gameDir,
    while (!currentId.isEmpty()) {
        if (chainIds.contains(currentId)) {
            if (error)
-                *error = QObject::tr("Циклическая зависимость inheritsFrom в версии «%1»")
-                             .arg(currentId);
+                *error = QObject::tr("Циклическая зависимость inheritsFrom в версии «%1»").arg(currentId);
            return version;
        }
        if (chain.size() >= kMaxInheritanceDepth) {
            if (error)
-                *error = QObject::tr("Слишком длинная цепочка inheritsFrom у версии «%1»")
-                             .arg(versionId);
+                *error = QObject::tr("Слишком длинная цепочка inheritsFrom у версии «%1»").arg(versionId);
            return version;
        }

@@ -396,8 +392,7 @@ MinecraftVersion VersionLoader::load(const QString &gameDir,
                                       .value(QStringLiteral("id"))
                                       .toString();
            if (!fileId.isEmpty())
-                version.loggingConfigPath = gameDir + QStringLiteral("/assets/log_configs/")
-                                            + fileId;
+                version.loggingConfigPath = gameDir + QStringLiteral("/assets/log_configs/") + fileId;
        }

        // minecraftArguments (до 1.13) заменяет список целиком, arguments.game — дополняет.
@@ -410,12 +405,9 @@ MinecraftVersion VersionLoader::load(const QString &gameDir,

        const QJsonObject arguments = object.value(QStringLiteral("arguments")).toObject();
        appendArguments(arguments.value(QStringLiteral("jvm")).toArray(), version.jvmArgs, features);
-        appendArguments(arguments.value(QStringLiteral("game")).toArray(),
-                        version.gameArgs,
-                        features);
+        appendArguments(arguments.value(QStringLiteral("game")).toArray(), version.gameArgs, features);

-        const QByteArray raw = QJsonDocument(arguments.value(QStringLiteral("game")).toArray())
-                                   .toJson();
+        const QByteArray raw = QJsonDocument(arguments.value(QStringLiteral("game")).toArray()).toJson();
        if (raw.contains("quickPlayMultiplayer"))
            version.supportsQuickPlay = true;
        if (raw.contains("resolution_width"))
@@ -445,12 +437,10 @@ MinecraftVersion VersionLoader::load(const QString &gameDir,
    pickNativesForCurrentArch(version.libraries);

    // До 1.13 jvm-аргументов в json нет — собираем их сами.
-    const bool hasClasspathArg = std::any_of(version.jvmArgs.cbegin(),
-                                             version.jvmArgs.cend(),
-                                             [](const QString &argument) {
-                                                 return argument == QLatin1String("-cp")
-                                                        || argument == QLatin1String("-classpath");
-                                             });
+    const bool hasClasspathArg = std::any_of(
+        version.jvmArgs.cbegin(), version.jvmArgs.cend(), [](const QString &argument) {
+            return argument == QLatin1String("-cp") || argument == QLatin1String("-classpath");
+        });
    if (!hasClasspathArg) {
        version.jvmArgs << QStringLiteral("-Djava.library.path=${natives_directory}")
                        << QStringLiteral("-Dminecraft.launcher.brand=${launcher_name}")
@@ -9,34 +9,34 @@
 // Одна библиотека из client.json уже с разрешёнными правилами.
 struct MinecraftLibrary
 {
-    QString name; // Maven-координаты: org.lwjgl:lwjgl:3.3.1:natives-windows
-    QString path; // Путь относительно .minecraft/libraries
-    QString url;  // Откуда качать, если файла нет (может быть пустым)
+    QString name;                 // Maven-координаты: org.lwjgl:lwjgl:3.3.1:natives-windows
+    QString path;                 // Путь относительно .minecraft/libraries
+    QString url;                  // Откуда качать, если файла нет (может быть пустым)
    QString sha1;
    qint64 size = 0;
-    bool native = false;        // Распаковывается в natives, а не кладётся в classpath
-    QStringList extractExclude; // Префиксы, которые не распаковываем
+    bool native = false;          // Распаковывается в natives, а не кладётся в classpath
+    QStringList extractExclude;   // Префиксы, которые не распаковываем
 };

 // client.json, «схлопнутый» по всей цепочке inheritsFrom.
 struct MinecraftVersion
 {
-    QString id; // Имя папки в versions, оно же --version
+    QString id;                   // Имя папки в versions, оно же --version
    QString mainClass;
-    QString type;          // release / snapshot / modified — идёт в --versionType
-    QString assetIndexId;  // --assetIndex
-    QString assetsKind;    // Поле "assets": legacy, pre-1.6 либо тот же id
-    QString clientJarPath; // Абсолютный путь к <id>.jar (может лежать у родителя)
+    QString type;                 // release / snapshot / modified — идёт в --versionType
+    QString assetIndexId;         // --assetIndex
+    QString assetsKind;           // Поле "assets": legacy, pre-1.6 либо тот же id
+    QString clientJarPath;        // Абсолютный путь к <id>.jar (может лежать у родителя)
    int javaMajor = 8;

-    QStringList jvmArgs; // Ещё с неподставленными ${...}
+    QStringList jvmArgs;          // Ещё с неподставленными ${...}
    QStringList gameArgs;
    QList<MinecraftLibrary> libraries;

-    QString loggingArgument;   // -Dlog4j.configurationFile=${path}
-    QString loggingConfigPath; // Абсолютный путь к xml, пустой если конфига нет
+    QString loggingArgument;      // -Dlog4j.configurationFile=${path}
+    QString loggingConfigPath;    // Абсолютный путь к xml, пустой если конфига нет

-    bool supportsQuickPlay = false; // 1.20+ понимает --quickPlayMultiplayer
+    bool supportsQuickPlay = false;   // 1.20+ понимает --quickPlayMultiplayer
    bool hasCustomResolutionArgs = false;

    bool isValid() const { return !id.isEmpty() && !mainClass.isEmpty(); }