Major Directory Refactoring (#5118)

* refactored cardzone.cpp, added doc and changed if to switch case * started moving every files into different folders * remove undercase to match with other files naming convention * refactored dialog files * ran format.sh * refactored client/tabs folder * refactored client/tabs folder * refactored client/tabs folder * refactored client folder * refactored carddbparser * refactored dialogs * Create sonar-project.properties temporary file for lint * Create build.yml temporary file for lint * removed all files from root directory * removed all files from root directory * added current branch to workflow * fixed most broken import * fixed issues while renaming files * fixed oracle importer * fixed dbconverter * updated translations * made sub-folders for client * removed linter * removed linter folder * fixed oracle import * revert card_zone documentation * renamed db parser files name and deck_view imports * fixed dlg file issue * ran format file and fixed test file * fixed carddb test files * moved player folder in game * updated translations and format files * fixed peglib import * format cmake files * removing vcpkg to try to add it back later * tried fixing vcpkg file * renamed filter to filters and moved database parser to cards folder * reverted translation files * reverted oracle translated * Update cockatrice/src/dialogs/dlg_register.cpp Co-authored-by: tooomm <tooomm@users.noreply.github.com> * Update cockatrice/src/client/ui/window_main.cpp Co-authored-by: tooomm <tooomm@users.noreply.github.com> * removed empty line at file start * removed useless include from tab_supervisor.cpp * refactored cardzone.cpp, added doc and changed if to switch case * started moving every files into different folders * remove undercase to match with other files naming convention * refactored dialog files * ran format.sh * refactored client/tabs folder * refactored client folder * refactored carddbparser * refactored dialogs * removed all files from root directory * Create sonar-project.properties temporary file for lint * Create build.yml temporary file for lint * added current branch to workflow * fixed most broken import * fixed issues while renaming files * fixed oracle importer * fixed dbconverter * updated translations * made sub-folders for client * removed linter * removed linter folder * fixed oracle import * revert card_zone documentation * renamed db parser files name and deck_view imports * fixed dlg file issue * ran format file and fixed test file * fixed carddb test files * moved player folder in game * updated translations and format files * fixed peglib import * reverted translation files * format cmake files * removing vcpkg to try to add it back later * tried fixing vcpkg file * pre-updating of cockatrice changes * removed empty line at file start * reverted oracle translated * Update cockatrice/src/dialogs/dlg_register.cpp Co-authored-by: tooomm <tooomm@users.noreply.github.com> * Update cockatrice/src/client/ui/window_main.cpp Co-authored-by: tooomm <tooomm@users.noreply.github.com> * removed useless include from tab_supervisor.cpp --------- Co-authored-by: tooomm <tooomm@users.noreply.github.com>
2026-06-12 00:54:53 -07:00 · 2024-10-20 16:11:35 +02:00 · 2024-10-20 16:11:35 +02:00 · fa999880ee
commit fa999880ee
parent d1e0f9dfc5
261 changed files with 735 additions and 729 deletions
--- a/cockatrice/src/client/network/release_channel.cpp
+++ b/cockatrice/src/client/network/release_channel.cpp
@ -0,0 +1,304 @@
+#include "release_channel.h"
+
+#include "version_string.h"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QMessageBox>
+#include <QNetworkReply>
+#include <QRegularExpression>
+#include <QSysInfo>
+#include <QtGlobal>
+
+#define STABLERELEASE_URL "https://api.github.com/repos/Cockatrice/Cockatrice/releases/latest"
+#define STABLEMANUALDOWNLOAD_URL "https://github.com/Cockatrice/Cockatrice/releases/latest"
+#define STABLETAG_URL "https://api.github.com/repos/Cockatrice/Cockatrice/git/refs/tags/"
+
+#define BETARELEASE_URL "https://api.github.com/repos/Cockatrice/Cockatrice/releases"
+#define BETAMANUALDOWNLOAD_URL "https://github.com/Cockatrice/Cockatrice/releases/"
+#define BETARELEASE_CHANGESURL "https://github.com/Cockatrice/Cockatrice/compare/%1...%2"
+
+#define GIT_SHORT_HASH_LEN 7
+
+int ReleaseChannel::sharedIndex = 0;
+
+ReleaseChannel::ReleaseChannel() : netMan(new QNetworkAccessManager(this)), response(nullptr), lastRelease(nullptr)
+{
+    index = sharedIndex++;
+}
+
+ReleaseChannel::~ReleaseChannel()
+{
+    netMan->deleteLater();
+}
+
+void ReleaseChannel::checkForUpdates()
+{
+    QString releaseChannelUrl = getReleaseChannelUrl();
+    qDebug() << "Searching for updates on the channel: " << releaseChannelUrl;
+    response = netMan->get(QNetworkRequest(releaseChannelUrl));
+    connect(response, SIGNAL(finished()), this, SLOT(releaseListFinished()));
+}
+
+// Different release channel checking functions for different operating systems
+#if defined(Q_OS_MACOS)
+bool ReleaseChannel::downloadMatchesCurrentOS(const QString &fileName)
+{
+    static QRegularExpression version_regex("macOS-(\\d+)\\.(\\d+)");
+    auto match = version_regex.match(fileName);
+    if (!match.hasMatch()) {
+        return false;
+    }
+
+    // older(smaller) releases are compatible with a newer or the same system version
+    int sys_maj = QSysInfo::productVersion().split(".")[0].toInt();
+    int sys_min = QSysInfo::productVersion().split(".")[1].toInt();
+    int rel_maj = match.captured(1).toInt();
+    int rel_min = match.captured(2).toInt();
+    return rel_maj < sys_maj || (rel_maj == sys_maj && rel_min <= sys_min);
+}
+#elif defined(Q_OS_WIN)
+bool ReleaseChannel::downloadMatchesCurrentOS(const QString &fileName)
+{
+#if Q_PROCESSOR_WORDSIZE == 4
+    return fileName.contains("32bit");
+#elif Q_PROCESSOR_WORDSIZE == 8
+    const QString &version = QSysInfo::productVersion();
+    if (version.startsWith("7") || version.startsWith("8")) {
+        return fileName.contains("Win7");
+    } else {
+        return fileName.contains("Win10");
+    }
+#else
+    return false;
+#endif
+}
+#else
+bool ReleaseChannel::downloadMatchesCurrentOS(const QString &)
+{
+    // If the OS doesn't fit one of the above #defines, then it will never match
+    return false;
+}
+#endif
+
+QString StableReleaseChannel::getManualDownloadUrl() const
+{
+    return QString(STABLEMANUALDOWNLOAD_URL);
+}
+
+QString StableReleaseChannel::getName() const
+{
+    return tr("Stable Releases");
+}
+
+QString StableReleaseChannel::getReleaseChannelUrl() const
+{
+    return QString(STABLERELEASE_URL);
+}
+
+void StableReleaseChannel::releaseListFinished()
+{
+    auto *reply = static_cast<QNetworkReply *>(sender());
+    QJsonParseError parseError{};
+    QJsonDocument jsonResponse = QJsonDocument::fromJson(reply->readAll(), &parseError);
+    reply->deleteLater();
+    if (parseError.error != QJsonParseError::NoError) {
+        qWarning() << "No reply received from the release update server.";
+        emit error(tr("No reply received from the release update server."));
+        return;
+    }
+
+    QVariantMap resultMap = jsonResponse.toVariant().toMap();
+    if (!(resultMap.contains("name") && resultMap.contains("html_url") && resultMap.contains("tag_name") &&
+          resultMap.contains("published_at"))) {
+        qWarning() << "Invalid received from the release update server.";
+        emit error(tr("Invalid reply received from the release update server."));
+        return;
+    }
+
+    if (!lastRelease)
+        lastRelease = new Release;
+
+    lastRelease->setName(resultMap["name"].toString());
+    lastRelease->setDescriptionUrl(resultMap["html_url"].toString());
+    lastRelease->setPublishDate(resultMap["published_at"].toDate());
+
+    if (resultMap.contains("assets")) {
+        auto rawAssets = resultMap["assets"].toList();
+        // [(name, url)]
+        QVector<std::pair<QString, QString>> assets;
+        std::transform(rawAssets.begin(), rawAssets.end(), std::back_inserter(assets), [](QVariant _asset) {
+            QVariantMap asset = _asset.toMap();
+            QString name = asset["name"].toString();
+            QString url = asset["browser_download_url"].toString();
+            return std::make_pair(name, url);
+        });
+
+        auto _releaseAsset = std::find_if(assets.begin(), assets.end(), [](std::pair<QString, QString> nameAndUrl) {
+            return downloadMatchesCurrentOS(nameAndUrl.first);
+        });
+
+        if (_releaseAsset != assets.end()) {
+            std::pair<QString, QString> releaseAsset = *_releaseAsset;
+            auto releaseUrl = releaseAsset.second;
+            lastRelease->setDownloadUrl(releaseUrl);
+        }
+    }
+
+    QString shortHash = lastRelease->getCommitHash().left(GIT_SHORT_HASH_LEN);
+    QString myHash = QString(VERSION_COMMIT);
+    qDebug() << "Current hash=" << myHash << "update hash=" << shortHash;
+
+    qDebug() << "Got reply from release server, name=" << lastRelease->getName()
+             << "desc=" << lastRelease->getDescriptionUrl() << "date=" << lastRelease->getPublishDate()
+             << "url=" << lastRelease->getDownloadUrl();
+
+    const QString &tagName = resultMap["tag_name"].toString();
+    QString url = QString(STABLETAG_URL) + tagName;
+    qDebug() << "Searching for commit hash corresponding to stable channel tag: " << tagName;
+    response = netMan->get(QNetworkRequest(url));
+    connect(response, SIGNAL(finished()), this, SLOT(tagListFinished()));
+}
+
+void StableReleaseChannel::tagListFinished()
+{
+    auto *reply = static_cast<QNetworkReply *>(sender());
+    QJsonParseError parseError{};
+    QJsonDocument jsonResponse = QJsonDocument::fromJson(reply->readAll(), &parseError);
+    reply->deleteLater();
+    if (parseError.error != QJsonParseError::NoError) {
+        qWarning() << "No reply received from the tag update server.";
+        emit error(tr("No reply received from the tag update server."));
+        return;
+    }
+
+    QVariantMap resultMap = jsonResponse.toVariant().toMap();
+    if (!(resultMap.contains("object") && resultMap["object"].toMap().contains("sha"))) {
+        qWarning() << "Invalid received from the tag update server.";
+        emit error(tr("Invalid reply received from the tag update server."));
+        return;
+    }
+
+    lastRelease->setCommitHash(resultMap["object"].toMap()["sha"].toString());
+    qDebug() << "Got reply from tag server, commit=" << lastRelease->getCommitHash();
+
+    QString shortHash = lastRelease->getCommitHash().left(GIT_SHORT_HASH_LEN);
+    QString myHash = QString(VERSION_COMMIT);
+    qDebug() << "Current hash=" << myHash << "update hash=" << shortHash;
+    const bool needToUpdate = (QString::compare(shortHash, myHash, Qt::CaseInsensitive) != 0);
+
+    emit finishedCheck(needToUpdate, lastRelease->isCompatibleVersionFound(), lastRelease);
+}
+
+void StableReleaseChannel::fileListFinished()
+{
+    // Only implemented to satisfy interface
+}
+
+QString BetaReleaseChannel::getManualDownloadUrl() const
+{
+    return QString(BETAMANUALDOWNLOAD_URL);
+}
+
+QString BetaReleaseChannel::getName() const
+{
+    return tr("Beta Releases");
+}
+
+QString BetaReleaseChannel::getReleaseChannelUrl() const
+{
+    return QString(BETARELEASE_URL);
+}
+
+void BetaReleaseChannel::releaseListFinished()
+{
+    auto *reply = static_cast<QNetworkReply *>(sender());
+    QByteArray jsonData = reply->readAll();
+    reply->deleteLater();
+
+    QJsonDocument doc = QJsonDocument::fromJson(jsonData);
+    QJsonArray array = doc.array();
+
+    /*
+     * Get the latest release on GitHub
+     * This can be either a pre-release or a published release
+     * depending on timing. Both are acceptable.
+     */
+    QVariantMap resultMap = array.at(0).toObject().toVariantMap();
+
+    if (array.empty() || resultMap.empty()) {
+        qWarning() << "No reply received from the release update server:" << QString(jsonData);
+        emit error(tr("No reply received from the release update server."));
+        return;
+    }
+
+    // Make sure resultMap has all elements we'll need
+    if (!resultMap.contains("assets") || !resultMap.contains("author") || !resultMap.contains("tag_name") ||
+        !resultMap.contains("target_commitish") || !resultMap.contains("assets_url") ||
+        !resultMap.contains("published_at")) {
+        qWarning() << "Invalid received from the release update server:" << resultMap;
+        emit error(tr("Invalid reply received from the release update server."));
+        return;
+    }
+
+    if (lastRelease == nullptr)
+        lastRelease = new Release;
+
+    lastRelease->setCommitHash(resultMap["target_commitish"].toString());
+    lastRelease->setPublishDate(resultMap["published_at"].toDate());
+
+    QString shortHash = lastRelease->getCommitHash().left(GIT_SHORT_HASH_LEN);
+    lastRelease->setName(QString("%1 (%2)").arg(resultMap["tag_name"].toString()).arg(shortHash));
+    lastRelease->setDescriptionUrl(QString(BETARELEASE_CHANGESURL).arg(VERSION_COMMIT, shortHash));
+
+    qDebug() << "Got reply from release server, size=" << resultMap.size() << "name=" << lastRelease->getName()
+             << "desc=" << lastRelease->getDescriptionUrl() << "commit=" << lastRelease->getCommitHash()
+             << "date=" << lastRelease->getPublishDate();
+
+    QString betaBuildDownloadUrl = resultMap["assets_url"].toString();
+
+    qDebug() << "Searching for a corresponding file on the beta channel: " << betaBuildDownloadUrl;
+    response = netMan->get(QNetworkRequest(betaBuildDownloadUrl));
+    connect(response, SIGNAL(finished()), this, SLOT(fileListFinished()));
+}
+
+void BetaReleaseChannel::fileListFinished()
+{
+    auto *reply = static_cast<QNetworkReply *>(sender());
+    QJsonParseError parseError{};
+    QJsonDocument jsonResponse = QJsonDocument::fromJson(reply->readAll(), &parseError);
+    reply->deleteLater();
+    if (parseError.error != QJsonParseError::NoError) {
+        qWarning() << "No reply received from the file update server.";
+        emit error(tr("No reply received from the file update server."));
+        return;
+    }
+
+    QVariantList resultList = jsonResponse.toVariant().toList();
+    QString shortHash = lastRelease->getCommitHash().left(GIT_SHORT_HASH_LEN);
+    QString myHash = QString(VERSION_COMMIT);
+    qDebug() << "Current hash=" << myHash << "update hash=" << shortHash;
+
+    bool needToUpdate = (QString::compare(shortHash, myHash, Qt::CaseInsensitive) != 0);
+    bool compatibleVersion = false;
+
+    QStringList resultUrlList{};
+    for (QVariant file : resultList) {
+        QVariantMap map = file.toMap();
+        resultUrlList << map["browser_download_url"].toString();
+    }
+
+    resultUrlList.sort();
+    // iterate in reverse so the first item is the latest os version
+    for (auto url = resultUrlList.rbegin(); url < resultUrlList.rend(); ++url) {
+        if (downloadMatchesCurrentOS(*url)) {
+            compatibleVersion = true;
+            lastRelease->setDownloadUrl(*url);
+            qDebug() << "Found compatible version url=" << *url;
+            break;
+        }
+    }
+
+    emit finishedCheck(needToUpdate, compatibleVersion, lastRelease);
+}
--- a/cockatrice/src/client/network/release_channel.h
+++ b/cockatrice/src/client/network/release_channel.h
@ -0,0 +1,157 @@
+#ifndef RELEASECHANNEL_H
+#define RELEASECHANNEL_H
+
+#include <QDate>
+#include <QObject>
+#include <QString>
+#include <QVariantMap>
+#include <utility>
+
+class QNetworkReply;
+class QNetworkAccessManager;
+
+class Release
+{
+    friend class StableReleaseChannel;
+    friend class BetaReleaseChannel;
+
+public:
+    Release() = default;
+    ~Release() = default;
+
+private:
+    QString name, descriptionUrl, downloadUrl, commitHash;
+    QDate publishDate;
+    bool compatibleVersionFound = false;
+
+protected:
+    void setName(QString _name)
+    {
+        name = std::move(_name);
+    }
+    void setDescriptionUrl(QString _descriptionUrl)
+    {
+        descriptionUrl = std::move(_descriptionUrl);
+    }
+    void setDownloadUrl(QString _downloadUrl)
+    {
+        downloadUrl = std::move(_downloadUrl);
+        compatibleVersionFound = true;
+    }
+    void setCommitHash(QString _commitHash)
+    {
+        commitHash = std::move(_commitHash);
+    }
+    void setPublishDate(QDate _publishDate)
+    {
+        publishDate = _publishDate;
+    }
+
+public:
+    QString getName() const
+    {
+        return name;
+    }
+    QString getDescriptionUrl() const
+    {
+        return descriptionUrl;
+    }
+    QString getDownloadUrl() const
+    {
+        return downloadUrl;
+    }
+    QString getCommitHash() const
+    {
+        return commitHash;
+    }
+    QDate getPublishDate() const
+    {
+        return publishDate;
+    }
+    bool isCompatibleVersionFound() const
+    {
+        return compatibleVersionFound;
+    }
+};
+
+class ReleaseChannel : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ReleaseChannel();
+    ~ReleaseChannel() override;
+
+protected:
+    // shared by all instances
+    static int sharedIndex;
+    int index;
+    QNetworkAccessManager *netMan;
+    QNetworkReply *response;
+    Release *lastRelease;
+
+protected:
+    static bool downloadMatchesCurrentOS(const QString &fileName);
+    virtual QString getReleaseChannelUrl() const = 0;
+
+public:
+    int getIndex() const
+    {
+        return index;
+    }
+    Release *getLastRelease()
+    {
+        return lastRelease;
+    }
+    virtual QString getManualDownloadUrl() const = 0;
+    virtual QString getName() const = 0;
+    void checkForUpdates();
+signals:
+    void finishedCheck(bool needToUpdate, bool isCompatible, Release *release);
+    void error(QString errorString);
+protected slots:
+    virtual void releaseListFinished() = 0;
+    virtual void fileListFinished() = 0;
+};
+
+class StableReleaseChannel : public ReleaseChannel
+{
+    Q_OBJECT
+public:
+    explicit StableReleaseChannel() = default;
+    ~StableReleaseChannel() override = default;
+
+    QString getManualDownloadUrl() const override;
+
+    QString getName() const override;
+
+protected:
+    QString getReleaseChannelUrl() const override;
+protected slots:
+
+    void releaseListFinished() override;
+    void tagListFinished();
+
+    void fileListFinished() override;
+};
+
+class BetaReleaseChannel : public ReleaseChannel
+{
+    Q_OBJECT
+public:
+    BetaReleaseChannel() = default;
+    ~BetaReleaseChannel() override = default;
+
+    QString getManualDownloadUrl() const override;
+
+    QString getName() const override;
+
+protected:
+    QString getReleaseChannelUrl() const override;
+protected slots:
+
+    void releaseListFinished() override;
+
+    void fileListFinished() override;
+};
+
+#endif
--- a/cockatrice/src/client/network/replay_timeline_widget.cpp
+++ b/cockatrice/src/client/network/replay_timeline_widget.cpp
@ -0,0 +1,121 @@
+#include "replay_timeline_widget.h"
+
+#include <QPainter>
+#include <QPainterPath>
+#include <QPalette>
+#include <QTimer>
+
+ReplayTimelineWidget::ReplayTimelineWidget(QWidget *parent)
+    : QWidget(parent), maxBinValue(1), maxTime(1), timeScaleFactor(1.0), currentTime(0), currentEvent(0)
+{
+    replayTimer = new QTimer(this);
+    connect(replayTimer, SIGNAL(timeout()), this, SLOT(replayTimerTimeout()));
+}
+
+const int ReplayTimelineWidget::binLength = 5000;
+
+void ReplayTimelineWidget::setTimeline(const QList<int> &_replayTimeline)
+{
+    replayTimeline = _replayTimeline;
+    histogram.clear();
+    int binEndTime = binLength - 1;
+    int binValue = 0;
+    for (int i : replayTimeline) {
+        if (i > binEndTime) {
+            histogram.append(binValue);
+            if (binValue > maxBinValue)
+                maxBinValue = binValue;
+            while (i > binEndTime + binLength) {
+                histogram.append(0);
+                binEndTime += binLength;
+            }
+            binValue = 1;
+            binEndTime += binLength;
+        } else
+            ++binValue;
+    }
+    histogram.append(binValue);
+    if (!replayTimeline.isEmpty())
+        maxTime = replayTimeline.last();
+
+    update();
+}
+
+void ReplayTimelineWidget::paintEvent(QPaintEvent * /* event */)
+{
+    QPainter painter(this);
+    painter.drawRect(0, 0, width() - 1, height() - 1);
+
+    qreal binWidth = (qreal)width() / histogram.size();
+    QPainterPath path;
+    path.moveTo(0, height() - 1);
+    for (int i = 0; i < histogram.size(); ++i)
+        path.lineTo(qRound(i * binWidth), (height() - 1) * (1.0 - (qreal)histogram[i] / maxBinValue));
+    path.lineTo(width() - 1, height() - 1);
+    path.lineTo(0, height() - 1);
+    painter.fillPath(path, Qt::black);
+
+    const QColor barColor = QColor::fromHsv(120, 255, 255, 100);
+    quint64 w = (quint64)(width() - 1) * (quint64)currentTime / maxTime;
+    painter.fillRect(0, 0, static_cast<int>(w), height() - 1, barColor);
+}
+
+void ReplayTimelineWidget::mousePressEvent(QMouseEvent *event)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+    int newTime = static_cast<int>((qint64)maxTime * (qint64)event->position().x() / width());
+#else
+    int newTime = static_cast<int>((qint64)maxTime * (qint64)event->x() / width());
+#endif
+    newTime -= newTime % 200; // Time should always be a multiple of 200
+    if (newTime < currentTime) {
+        currentTime = 0;
+        currentEvent = 0;
+        emit rewound();
+    }
+    currentTime = newTime - 200; // 200 is added back in replayTimerTimeout
+    replayTimerTimeout();
+    update();
+}
+
+QSize ReplayTimelineWidget::sizeHint() const
+{
+    return {-1, 50};
+}
+
+QSize ReplayTimelineWidget::minimumSizeHint() const
+{
+    return {400, 50};
+}
+
+void ReplayTimelineWidget::replayTimerTimeout()
+{
+    currentTime += 200;
+    while ((currentEvent < replayTimeline.size()) && (replayTimeline[currentEvent] < currentTime)) {
+        emit processNextEvent();
+        ++currentEvent;
+    }
+    if (currentEvent == replayTimeline.size()) {
+        emit replayFinished();
+        replayTimer->stop();
+    }
+
+    if (!(currentTime % 1000))
+        update();
+}
+
+void ReplayTimelineWidget::setTimeScaleFactor(qreal _timeScaleFactor)
+{
+    timeScaleFactor = _timeScaleFactor;
+    replayTimer->setInterval(static_cast<int>(200 / timeScaleFactor));
+}
+
+void ReplayTimelineWidget::startReplay()
+{
+    replayTimer->start(static_cast<int>(200 / timeScaleFactor));
+}
+
+void ReplayTimelineWidget::stopReplay()
+{
+    replayTimer->stop();
+}
--- a/cockatrice/src/client/network/replay_timeline_widget.h
+++ b/cockatrice/src/client/network/replay_timeline_widget.h
@ -0,0 +1,50 @@
+#ifndef REPLAY_TIMELINE_WIDGET
+#define REPLAY_TIMELINE_WIDGET
+
+#include <QList>
+#include <QMouseEvent>
+#include <QWidget>
+
+class QPaintEvent;
+class QTimer;
+
+class ReplayTimelineWidget : public QWidget
+{
+    Q_OBJECT
+signals:
+    void processNextEvent();
+    void replayFinished();
+    void rewound();
+
+private:
+    QTimer *replayTimer;
+    QList<int> replayTimeline;
+    QList<int> histogram;
+    static const int binLength;
+    int maxBinValue, maxTime;
+    qreal timeScaleFactor;
+    int currentTime;
+    int currentEvent;
+private slots:
+    void replayTimerTimeout();
+
+public:
+    explicit ReplayTimelineWidget(QWidget *parent = nullptr);
+    void setTimeline(const QList<int> &_replayTimeline);
+    QSize sizeHint() const override;
+    QSize minimumSizeHint() const override;
+    void setTimeScaleFactor(qreal _timeScaleFactor);
+    int getCurrentEvent() const
+    {
+        return currentEvent;
+    }
+public slots:
+    void startReplay();
+    void stopReplay();
+
+protected:
+    void paintEvent(QPaintEvent *event) override;
+    void mousePressEvent(QMouseEvent *event) override;
+};
+
+#endif
--- a/cockatrice/src/client/network/sets_model.cpp
+++ b/cockatrice/src/client/network/sets_model.cpp
@ -0,0 +1,296 @@
+#include "sets_model.h"
+
+#include <QSortFilterProxyModel>
+
+SetsModel::SetsModel(CardDatabase *_db, QObject *parent) : QAbstractTableModel(parent), sets(_db->getSetList())
+{
+    sets.sortByKey();
+    for (const CardSetPtr &set : sets) {
+        if (set->getEnabled())
+            enabledSets.insert(set);
+    }
+}
+
+SetsModel::~SetsModel() = default;
+
+int SetsModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid())
+        return 0;
+    else
+        return sets.size();
+}
+
+QVariant SetsModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || (index.column() >= NUM_COLS) || (index.row() >= rowCount()))
+        return QVariant();
+
+    CardSetPtr set = sets[index.row()];
+
+    if (index.column() == EnabledCol) {
+        switch (role) {
+            case SortRole:
+                return enabledSets.contains(set) ? "1" : "0";
+            case Qt::CheckStateRole:
+                return static_cast<int>(enabledSets.contains(set) ? Qt::Checked : Qt::Unchecked);
+            case Qt::DisplayRole:
+            default:
+                return QVariant();
+        }
+    }
+
+    if (role != Qt::DisplayRole && role != SortRole)
+        return QVariant();
+
+    switch (index.column()) {
+        case SortKeyCol:
+            return QString("%1").arg(set->getSortKey(), 8, 10, QChar('0'));
+        case IsKnownCol:
+            return set->getIsKnown();
+        case SetTypeCol:
+            return set->getSetType();
+        case ShortNameCol:
+            return set->getShortName();
+        case LongNameCol:
+            return set->getLongName();
+        case ReleaseDateCol:
+            return set->getReleaseDate().toString(Qt::ISODate);
+        default:
+            return QVariant();
+    }
+}
+
+bool SetsModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+    if (role == Qt::CheckStateRole && index.column() == EnabledCol) {
+        toggleRow(index.row(), value == Qt::Checked);
+        return true;
+    }
+    return false;
+}
+
+QVariant SetsModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if ((role != Qt::DisplayRole) || (orientation != Qt::Horizontal))
+        return QVariant();
+    switch (section) {
+        case SortKeyCol:
+            return QString("Key"); /* no tr() for translations needed, column just used for sorting --> hidden */
+        case IsKnownCol:
+            return QString(
+                "Is known"); /* no tr() for translations needed, column is just used for sorting --> hidden */
+        case EnabledCol:
+            return tr("Enabled");
+        case SetTypeCol:
+            return tr("Set type");
+        case ShortNameCol:
+            return tr("Set code");
+        case LongNameCol:
+            return tr("Long name");
+        case ReleaseDateCol:
+            return tr("Release date");
+        default:
+            return QVariant();
+    }
+}
+
+Qt::ItemFlags SetsModel::flags(const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return Qt::NoItemFlags;
+
+    Qt::ItemFlags flags = QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
+
+    if (index.column() == EnabledCol)
+        flags |= Qt::ItemIsUserCheckable;
+
+    return flags;
+}
+
+Qt::DropActions SetsModel::supportedDropActions() const
+{
+    return Qt::MoveAction;
+}
+
+QMimeData *SetsModel::mimeData(const QModelIndexList &indexes) const
+{
+    if (indexes.isEmpty())
+        return 0;
+
+    SetsMimeData *result = new SetsMimeData(indexes[0].row());
+    return qobject_cast<QMimeData *>(result);
+}
+
+bool SetsModel::dropMimeData(const QMimeData *data,
+                             Qt::DropAction action,
+                             int row,
+                             int /*column*/,
+                             const QModelIndex &parent)
+{
+    if (action != Qt::MoveAction)
+        return false;
+    if (row == -1) {
+        if (!parent.isValid())
+            return false;
+        row = parent.row();
+    }
+    int oldRow = qobject_cast<const SetsMimeData *>(data)->getOldRow();
+    if (oldRow < row)
+        row--;
+
+    swapRows(oldRow, row);
+
+    return true;
+}
+
+void SetsModel::toggleRow(int row, bool enable)
+{
+    CardSetPtr temp = sets.at(row);
+
+    if (enable)
+        enabledSets.insert(temp);
+    else
+        enabledSets.remove(temp);
+
+    emit dataChanged(index(row, EnabledCol), index(row, EnabledCol));
+}
+
+void SetsModel::toggleRow(int row)
+{
+    CardSetPtr tmp = sets.at(row);
+
+    if (tmp == nullptr)
+        return;
+
+    if (enabledSets.contains(tmp))
+        enabledSets.remove(tmp);
+    else
+        enabledSets.insert(tmp);
+
+    emit dataChanged(index(row, EnabledCol), index(row, EnabledCol));
+}
+
+void SetsModel::toggleAll(bool enabled)
+{
+    enabledSets.clear();
+
+    if (enabled)
+        for (CardSetPtr set : sets)
+            enabledSets.insert(set);
+
+    emit dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
+}
+
+void SetsModel::swapRows(int oldRow, int newRow)
+{
+    beginRemoveRows(QModelIndex(), oldRow, oldRow);
+    CardSetPtr temp = sets.takeAt(oldRow);
+    endRemoveRows();
+
+    beginInsertRows(QModelIndex(), newRow, newRow);
+    sets.insert(newRow, temp);
+    endInsertRows();
+
+    emit dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
+}
+
+void SetsModel::sort(int column, Qt::SortOrder order)
+{
+    QMultiMap<QString, CardSetPtr> setMap;
+    int numRows = rowCount();
+    int row;
+
+    for (row = 0; row < numRows; ++row)
+        setMap.insert(index(row, column).data(SetsModel::SortRole).toString(), sets.at(row));
+
+    QList<CardSetPtr> tmp = setMap.values();
+    sets.clear();
+    if (order == Qt::AscendingOrder) {
+        for (row = 0; row < tmp.size(); row++) {
+            sets.append(tmp.at(row));
+        }
+    } else {
+        for (row = tmp.size() - 1; row >= 0; row--) {
+            sets.append(tmp.at(row));
+        }
+    }
+
+    emit dataChanged(index(0, 0), index(numRows - 1, columnCount() - 1));
+}
+
+void SetsModel::save(CardDatabase *db)
+{
+    // order
+    for (int i = 0; i < sets.size(); i++)
+        sets[i]->setSortKey(static_cast<unsigned int>(i + 1));
+
+    // enabled sets
+    for (const CardSetPtr &set : sets)
+        set->setEnabled(enabledSets.contains(set));
+
+    sets.sortByKey();
+
+    db->notifyEnabledSetsChanged();
+}
+
+void SetsModel::restore(CardDatabase *db)
+{
+    // order
+    sets = db->getSetList();
+    sets.sortByKey();
+
+    // enabled sets
+    enabledSets.clear();
+    for (const CardSetPtr &set : sets) {
+        if (set->getEnabled())
+            enabledSets.insert(set);
+    }
+
+    emit dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
+}
+
+QStringList SetsModel::mimeTypes() const
+{
+    return QStringList() << "application/x-cockatricecardset";
+}
+
+SetsDisplayModel::SetsDisplayModel(QObject *parent) : QSortFilterProxyModel(parent)
+{
+    setFilterCaseSensitivity(Qt::CaseInsensitive);
+    setSortCaseSensitivity(Qt::CaseInsensitive);
+}
+
+void SetsDisplayModel::fetchMore(const QModelIndex &index)
+{
+    int itemsToFetch = sourceModel()->rowCount(index);
+
+    beginInsertRows(QModelIndex(), 0, itemsToFetch - 1);
+
+    endInsertRows();
+}
+
+bool SetsDisplayModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    auto typeIndex = sourceModel()->index(sourceRow, SetsModel::SetTypeCol, sourceParent);
+    auto nameIndex = sourceModel()->index(sourceRow, SetsModel::LongNameCol, sourceParent);
+    auto shortNameIndex = sourceModel()->index(sourceRow, SetsModel::ShortNameCol, sourceParent);
+
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
+    const auto filter = filterRegularExpression();
+#else
+    const auto filter = filterRegExp();
+#endif
+
+    return (sourceModel()->data(typeIndex).toString().contains(filter) ||
+            sourceModel()->data(nameIndex).toString().contains(filter) ||
+            sourceModel()->data(shortNameIndex).toString().contains(filter));
+}
+
+bool SetsDisplayModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
+{
+    QString leftString = sourceModel()->data(left, SetsModel::SortRole).toString();
+    QString rightString = sourceModel()->data(right, SetsModel::SortRole).toString();
+
+    return QString::localeAwareCompare(leftString, rightString) < 0;
+}
--- a/cockatrice/src/client/network/sets_model.h
+++ b/cockatrice/src/client/network/sets_model.h
@ -0,0 +1,97 @@
+#ifndef SETSMODEL_H
+#define SETSMODEL_H
+
+#include "../../game/cards/card_database.h"
+
+#include <QAbstractTableModel>
+#include <QMimeData>
+#include <QSet>
+#include <QSortFilterProxyModel>
+
+class SetsProxyModel;
+
+class SetsMimeData : public QMimeData
+{
+    Q_OBJECT
+private:
+    int oldRow;
+
+public:
+    SetsMimeData(int _oldRow) : oldRow(_oldRow)
+    {
+    }
+    int getOldRow() const
+    {
+        return oldRow;
+    }
+    QStringList formats() const
+    {
+        return QStringList() << "application/x-cockatricecardset";
+    }
+};
+
+class SetsModel : public QAbstractTableModel
+{
+    Q_OBJECT
+    friend class SetsProxyModel;
+
+private:
+    static const int NUM_COLS = 7;
+    SetList sets;
+    QSet<CardSetPtr> enabledSets;
+
+public:
+    enum SetsColumns
+    {
+        SortKeyCol,
+        IsKnownCol,
+        EnabledCol,
+        LongNameCol,
+        ShortNameCol,
+        SetTypeCol,
+        ReleaseDateCol
+    };
+    enum Role
+    {
+        SortRole = Qt::UserRole
+    };
+
+    SetsModel(CardDatabase *_db, QObject *parent = nullptr);
+    ~SetsModel();
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const
+    {
+        Q_UNUSED(parent);
+        return NUM_COLS;
+    }
+    QVariant data(const QModelIndex &index, int role) const;
+    bool setData(const QModelIndex &index, const QVariant &value, int role);
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+    Qt::DropActions supportedDropActions() const;
+
+    QMimeData *mimeData(const QModelIndexList &indexes) const;
+    bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
+    QStringList mimeTypes() const;
+    void swapRows(int oldRow, int newRow);
+    void toggleRow(int row, bool enable);
+    void toggleRow(int row);
+    void toggleAll(bool);
+    void sort(int column, Qt::SortOrder order = Qt::AscendingOrder);
+    void save(CardDatabase *db);
+    void restore(CardDatabase *db);
+};
+
+class SetsDisplayModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    SetsDisplayModel(QObject *parent = NULL);
+
+protected:
+    bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+    void fetchMore(const QModelIndex &index) override;
+};
+
+#endif
--- a/cockatrice/src/client/network/spoiler_background_updater.cpp
+++ b/cockatrice/src/client/network/spoiler_background_updater.cpp
@ -0,0 +1,222 @@
+#include "spoiler_background_updater.h"
+
+#include "../../game/cards/card_database.h"
+#include "../../main.h"
+#include "../../settings/cache_settings.h"
+#include "../ui/window_main.h"
+
+#include <QApplication>
+#include <QCryptographicHash>
+#include <QDateTime>
+#include <QDebug>
+#include <QFile>
+#include <QLocale>
+#include <QMessageBox>
+#include <QNetworkReply>
+#include <QUrl>
+#include <QtConcurrent>
+
+#define SPOILERS_STATUS_URL "https://raw.githubusercontent.com/Cockatrice/Magic-Spoiler/files/SpoilerSeasonEnabled"
+#define SPOILERS_URL "https://raw.githubusercontent.com/Cockatrice/Magic-Spoiler/files/spoiler.xml"
+
+SpoilerBackgroundUpdater::SpoilerBackgroundUpdater(QObject *apParent) : QObject(apParent), cardUpdateProcess(nullptr)
+{
+    isSpoilerDownloadEnabled = SettingsCache::instance().getDownloadSpoilersStatus();
+    if (isSpoilerDownloadEnabled) {
+        // Start the process of checking if we're in spoiler season
+        // File exists means we're in spoiler season
+        startSpoilerDownloadProcess(SPOILERS_STATUS_URL, false);
+    } else {
+        qDebug() << "Spoilers Disabled";
+    }
+}
+
+void SpoilerBackgroundUpdater::startSpoilerDownloadProcess(QString url, bool saveResults)
+{
+    auto spoilerURL = QUrl(url);
+    downloadFromURL(spoilerURL, saveResults);
+}
+
+void SpoilerBackgroundUpdater::downloadFromURL(QUrl url, bool saveResults)
+{
+    auto *nam = new QNetworkAccessManager(this);
+    QNetworkReply *reply = nam->get(QNetworkRequest(url));
+
+    if (saveResults) {
+        // This will write out to the file (used for spoiler.xml)
+        connect(reply, SIGNAL(finished()), this, SLOT(actDownloadFinishedSpoilersFile()));
+    } else {
+        // This will check the status (used to see if we're in spoiler season or not)
+        connect(reply, SIGNAL(finished()), this, SLOT(actCheckIfSpoilerSeasonEnabled()));
+    }
+}
+
+void SpoilerBackgroundUpdater::actDownloadFinishedSpoilersFile()
+{
+    // Check for server reply
+    auto *reply = dynamic_cast<QNetworkReply *>(sender());
+    QNetworkReply::NetworkError errorCode = reply->error();
+
+    if (errorCode == QNetworkReply::NoError) {
+        spoilerData = reply->readAll();
+
+        // Save the spoiler.xml file to the disk
+        saveDownloadedFile(spoilerData);
+
+        reply->deleteLater();
+        emit spoilerCheckerDone();
+    } else {
+        qDebug() << "Error downloading spoilers file" << errorCode;
+        emit spoilerCheckerDone();
+    }
+}
+
+bool SpoilerBackgroundUpdater::deleteSpoilerFile()
+{
+    QString fileName = SettingsCache::instance().getSpoilerCardDatabasePath();
+    QFileInfo fi(fileName);
+    QDir fileDir(fi.path());
+    QFile file(fileName);
+
+    // Delete the spoiler.xml file
+    if (file.exists() && file.remove()) {
+        qDebug() << "Deleting spoiler.xml";
+        return true;
+    }
+
+    qDebug() << "Error: Spoiler.xml not found or not deleted";
+    return false;
+}
+
+void SpoilerBackgroundUpdater::actCheckIfSpoilerSeasonEnabled()
+{
+    auto *response = dynamic_cast<QNetworkReply *>(sender());
+    QNetworkReply::NetworkError errorCode = response->error();
+
+    if (errorCode == QNetworkReply::ContentNotFoundError) {
+        // Spoiler season is offline at this point, so the spoiler.xml file can be safely deleted
+        // The user should run Oracle to get the latest card information
+        if (deleteSpoilerFile() && trayIcon) {
+            trayIcon->showMessage(tr("Spoilers season has ended"), tr("Deleting spoiler.xml. Please run Oracle"));
+        }
+
+        qDebug() << "Spoiler Season Offline";
+        emit spoilerCheckerDone();
+    } else if (errorCode == QNetworkReply::NoError) {
+        qDebug() << "Spoiler Service Online";
+        startSpoilerDownloadProcess(SPOILERS_URL, true);
+    } else if (errorCode == QNetworkReply::HostNotFoundError) {
+        if (trayIcon) {
+            trayIcon->showMessage(tr("Spoilers download failed"), tr("No internet connection"));
+        }
+
+        qDebug() << "Spoiler download failed due to no internet connection";
+        emit spoilerCheckerDone();
+    } else {
+        if (trayIcon) {
+            trayIcon->showMessage(tr("Spoilers download failed"), tr("Error") + " " + (short)errorCode);
+        }
+
+        qDebug() << "Spoiler download failed with reason" << errorCode;
+        emit spoilerCheckerDone();
+    }
+}
+
+bool SpoilerBackgroundUpdater::saveDownloadedFile(QByteArray data)
+{
+    QString fileName = SettingsCache::instance().getSpoilerCardDatabasePath();
+    QFileInfo fi(fileName);
+    QDir fileDir(fi.path());
+
+    if (!fileDir.exists() && !fileDir.mkpath(fileDir.absolutePath())) {
+        return false;
+    }
+
+    // Check if the data matches. If it does, then spoilers are up to date.
+    if (getHash(fileName) == getHash(data)) {
+        if (trayIcon) {
+            trayIcon->showMessage(tr("Spoilers already up to date"), tr("No new spoilers added"));
+        }
+
+        qDebug() << "Spoilers Up to Date";
+        return false;
+    }
+
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly)) {
+        qDebug() << "Spoiler Service Error: File open (w) failed for" << fileName;
+        file.close();
+        return false;
+    }
+
+    if (file.write(data) == -1) {
+        qDebug() << "Spoiler Service Error: File write (w) failed for" << fileName;
+        file.close();
+        return false;
+    }
+
+    file.close();
+
+    // Data written, so reload the card database
+    qDebug() << "Spoiler Service Data Written";
+    const auto reloadOk = QtConcurrent::run([] { db->loadCardDatabases(); });
+
+    // If the user has notifications enabled, let them know
+    // when the database was last updated
+    if (trayIcon) {
+        QList<QByteArray> lines = data.split('\n');
+
+        foreach (QByteArray line, lines) {
+            if (line.contains("Created At:")) {
+                QString timeStamp = QString(line).replace("Created At:", "").trimmed();
+                timeStamp.chop(6); // Remove " (UTC)"
+
+                auto utcTime = QLocale().toDateTime(timeStamp, "ddd, MMM dd yyyy, hh:mm:ss");
+                utcTime.setTimeSpec(Qt::UTC);
+
+                QString localTime = utcTime.toLocalTime().toString("MMM d, hh:mm");
+
+                trayIcon->showMessage(tr("Spoilers have been updated!"), tr("Last change:") + " " + localTime);
+                emit spoilersUpdatedSuccessfully();
+                return true;
+            }
+        }
+    }
+
+    return true;
+}
+
+QByteArray SpoilerBackgroundUpdater::getHash(const QString fileName)
+{
+    QFile file(fileName);
+
+    if (file.open(QFile::ReadOnly)) {
+        // Only read the first 512 bytes (enough to get the "created" tag)
+        const QByteArray bytes = file.read(512);
+
+        QCryptographicHash hash(QCryptographicHash::Algorithm::Md5);
+        hash.addData(bytes);
+
+        qDebug() << "File Hash =" << hash.result();
+
+        file.close();
+        return hash.result();
+    } else {
+        qDebug() << "getHash ReadOnly failed!";
+        file.close();
+        return QByteArray();
+    }
+}
+
+QByteArray SpoilerBackgroundUpdater::getHash(QByteArray data)
+{
+    // Only read the first 512 bytes (enough to get the "created" tag)
+    const QByteArray bytes = data.left(512);
+
+    QCryptographicHash hash(QCryptographicHash::Algorithm::Md5);
+    hash.addData(bytes);
+
+    qDebug() << "Data Hash =" << hash.result();
+
+    return hash.result();
+}
--- a/cockatrice/src/client/network/spoiler_background_updater.h
+++ b/cockatrice/src/client/network/spoiler_background_updater.h
@ -0,0 +1,38 @@
+#ifndef COCKATRICE_SPOILER_DOWNLOADER_H
+#define COCKATRICE_SPOILER_DOWNLOADER_H
+
+#include <QByteArray>
+#include <QObject>
+#include <QProcess>
+
+class SpoilerBackgroundUpdater : public QObject
+{
+    Q_OBJECT
+public:
+    explicit SpoilerBackgroundUpdater(QObject *apParent = nullptr);
+    inline QString getCardUpdaterBinaryName()
+    {
+        return "oracle";
+    };
+    QByteArray getHash(const QString fileName);
+    QByteArray getHash(QByteArray data);
+    static bool deleteSpoilerFile();
+
+private slots:
+    void actDownloadFinishedSpoilersFile();
+    void actCheckIfSpoilerSeasonEnabled();
+
+private:
+    bool isSpoilerDownloadEnabled;
+    QProcess *cardUpdateProcess;
+    QByteArray spoilerData;
+    void startSpoilerDownloadProcess(QString url, bool saveResults);
+    void downloadFromURL(QUrl url, bool saveResults);
+    bool saveDownloadedFile(QByteArray data);
+
+signals:
+    void spoilersUpdatedSuccessfully();
+    void spoilerCheckerDone();
+};
+
+#endif // COCKATRICE_SPOILER_DOWNLOADER_H