Initial commit of mtgonline project

C++/cockatrice/src/client/network/connection_controller/remote_connection_controller.cpp

@@ -0,0 +1,587 @@
+#include "remote_connection_controller.h"
+
+#include "../../settings/cache_settings.h"
+#include "../interface/widgets/dialogs/dlg_connect.h"
+#include "../interface/widgets/dialogs/dlg_forgot_password_challenge.h"
+#include "../interface/widgets/dialogs/dlg_forgot_password_request.h"
+#include "../interface/widgets/dialogs/dlg_forgot_password_reset.h"
+#include "../interface/widgets/dialogs/dlg_register.h"
+#include "../interface/widgets/utility/get_text_with_max.h"
+
+#include <QDateTime>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QThread>
+#include <libcockatrice/network/client/remote/remote_client.h>
+#include <libcockatrice/protocol/pb/response.pb.h>
+
+ConnectionController::ConnectionController(QWidget *dialogParent, QObject *parent)
+    : QObject(parent), dialogParent(dialogParent)
+{
+    remoteClient = new RemoteClient(nullptr, &SettingsCache::instance());
+
+    clientThread = new QThread(this);
+    remoteClient->moveToThread(clientThread);
+    clientThread->start();
+
+    wireClientSignals();
+}
+
+ConnectionController::~ConnectionController()
+{
+    remoteClient->deleteLater();
+    clientThread->wait();
+}
+
+void ConnectionController::wireClientSignals()
+{
+    connect(remoteClient, &RemoteClient::connectionClosedEventReceived, this,
+            &ConnectionController::onConnectionClosedEvent);
+
+    connect(remoteClient, &RemoteClient::serverShutdownEventReceived, this,
+            &ConnectionController::onServerShutdownEvent);
+
+    connect(remoteClient, &RemoteClient::statusChanged, this, &ConnectionController::onStatusChanged);
+
+    connect(remoteClient, &RemoteClient::userInfoChanged, this, &ConnectionController::onUserInfoReceived,
+            Qt::BlockingQueuedConnection);
+
+    connect(remoteClient, &RemoteClient::loginError, this,
+            [this](Response::ResponseCode r, QString rs, quint32 et, QList<QString> mf) {
+                onLoginError(static_cast<int>(r), rs, et, mf);
+            });
+
+    connect(remoteClient, &RemoteClient::registerError, this,
+            [this](Response::ResponseCode r, QString rs, quint32 et) { onRegisterError(static_cast<int>(r), rs, et); });
+
+    connect(remoteClient, &RemoteClient::activateError, this, &ConnectionController::onActivateError);
+    connect(remoteClient, &RemoteClient::socketError, this, &ConnectionController::onSocketError);
+    connect(remoteClient, &RemoteClient::serverTimeout, this, &ConnectionController::onServerTimeout);
+
+    connect(remoteClient, &RemoteClient::protocolVersionMismatch, this,
+            &ConnectionController::onProtocolVersionMismatch);
+
+    connect(remoteClient, &RemoteClient::registerAccepted, this, &ConnectionController::onRegisterAccepted);
+
+    connect(remoteClient, &RemoteClient::registerAcceptedNeedsActivate, this,
+            &ConnectionController::onRegisterAcceptedNeedsActivate);
+
+    connect(remoteClient, &RemoteClient::activateAccepted, this, &ConnectionController::onActivateAccepted);
+
+    connect(remoteClient, &RemoteClient::notifyUserAboutUpdate, this, &ConnectionController::onNotifyUserAboutUpdate);
+
+    connect(remoteClient, &RemoteClient::sigForgotPasswordSuccess, this,
+            &ConnectionController::onForgotPasswordSuccess);
+
+    connect(remoteClient, &RemoteClient::sigForgotPasswordError, this, &ConnectionController::onForgotPasswordError);
+
+    connect(remoteClient, &RemoteClient::sigPromptForForgotPasswordReset, this,
+            &ConnectionController::onPromptForgotPasswordReset);
+
+    connect(remoteClient, &RemoteClient::sigPromptForForgotPasswordChallenge, this,
+            &ConnectionController::onPromptForgotPasswordChallenge);
+}
+
+void ConnectionController::connectToServer()
+{
+    dlgConnect = new DlgConnect(dialogParent);
+    connect(dlgConnect, &DlgConnect::sigStartForgotPasswordRequest, this, &ConnectionController::forgotPasswordRequest);
+
+    if (dlgConnect->exec()) {
+        remoteClient->connectToServer(dlgConnect->getHost(), static_cast<unsigned int>(dlgConnect->getPort()),
+                                      dlgConnect->getPlayerName(), dlgConnect->getPassword());
+    }
+}
+
+void ConnectionController::connectToServerDirect(const QString &host,
+                                                 unsigned int port,
+                                                 const QString &playerName,
+                                                 const QString &password)
+{
+    remoteClient->connectToServer(host, port, playerName, password);
+}
+
+void ConnectionController::disconnectFromServer()
+{
+    remoteClient->disconnectFromServer();
+}
+
+void ConnectionController::registerToServer()
+{
+    DlgRegister dlg(dialogParent);
+    if (dlg.exec()) {
+        remoteClient->registerToServer(dlg.getHost(), static_cast<unsigned int>(dlg.getPort()), dlg.getPlayerName(),
+                                       dlg.getPassword(), dlg.getEmail(), dlg.getCountry(), dlg.getRealName());
+    }
+}
+
+void ConnectionController::forgotPasswordRequest()
+{
+    DlgForgotPasswordRequest dlg(dialogParent);
+    if (dlg.exec()) {
+        remoteClient->requestForgotPasswordToServer(dlg.getHost(), static_cast<unsigned int>(dlg.getPort()),
+                                                    dlg.getPlayerName());
+    }
+}
+
+void ConnectionController::onConnectionClosedEvent(const Event_ConnectionClosed &event)
+{
+    remoteClient->disconnectFromServer();
+
+    QString reasonStr;
+    switch (event.reason()) {
+        case Event_ConnectionClosed::USER_LIMIT_REACHED: {
+            reasonStr = tr("The server has reached its maximum user capacity, please check back later.");
+            break;
+        }
+        case Event_ConnectionClosed::TOO_MANY_CONNECTIONS: {
+            reasonStr = tr("There are too many concurrent connections from your address.");
+            break;
+        }
+        case Event_ConnectionClosed::BANNED: {
+            reasonStr = tr("Banned by moderator");
+            if (event.has_end_time()) {
+                reasonStr.append(
+                    "\n" + tr("Expected end time: %1").arg(QDateTime::fromSecsSinceEpoch(event.end_time()).toString()));
+            } else {
+                reasonStr.append("\n" + tr("This ban lasts indefinitely."));
+            }
+            if (event.has_reason_str()) {
+                reasonStr.append("\n\n" + QString::fromStdString(event.reason_str()));
+            }
+            break;
+        }
+        case Event_ConnectionClosed::SERVER_SHUTDOWN: {
+            reasonStr = tr("Scheduled server shutdown.");
+            break;
+        }
+        case Event_ConnectionClosed::USERNAMEINVALID: {
+            reasonStr = tr("Invalid username.");
+            break;
+        }
+        case Event_ConnectionClosed::LOGGEDINELSEWERE: {
+            reasonStr = tr("You have been logged out due to logging in at another location.");
+            break;
+        }
+        default:
+            reasonStr = QString::fromStdString(event.reason_str());
+    }
+
+    QMessageBox::critical(dialogParent, tr("Connection closed"),
+                          tr("The server has terminated your connection.\nReason: %1").arg(reasonStr));
+}
+
+void ConnectionController::onServerShutdownEvent(const Event_ServerShutdown &event)
+{
+    serverShutdownMessageBox.setInformativeText(tr("The server is going to be restarted in %n minute(s).\nAll running "
+                                                   "games will be lost.\nReason for shutdown: %1",
+                                                   "", event.minutes())
+                                                    .arg(QString::fromStdString(event.reason())));
+    serverShutdownMessageBox.setIconPixmap(QPixmap("theme:cockatrice").scaled(64, 64));
+    serverShutdownMessageBox.setText(tr("Scheduled server shutdown"));
+    serverShutdownMessageBox.setWindowModality(Qt::ApplicationModal);
+    serverShutdownMessageBox.setVisible(true);
+}
+
+void ConnectionController::onStatusChanged(ClientStatus status)
+{
+    // Update the window title first, then let MainWindow handle its own UI
+    // state via the forwarded signal
+    updateWindowTitle();
+    emit statusChanged(status);
+
+    // TabSupervisor::stop() needs calling on disconnect; start() is driven by
+    // onUserInfoReceived → tabSupervisorStartRequested.
+    if (status == StatusDisconnected) {
+        emit tabSupervisorStopRequested();
+    }
+}
+
+void ConnectionController::onUserInfoReceived(const ServerInfo_User &info)
+{
+    emit tabSupervisorStartRequested(info);
+}
+
+void ConnectionController::onLoginError(int r,
+                                        QString reasonStr,
+                                        quint32 endTime,
+                                        const QList<QString> &missingFeatures)
+{
+    switch (static_cast<Response::ResponseCode>(r)) {
+        case Response::RespClientUpdateRequired: {
+            QString formatted = "Missing Features: ";
+            for (int i = 0; i < missingFeatures.size(); ++i) {
+                formatted.append(QString("\n     %1").arg(QChar(0x2022)) + " " + missingFeatures.value(i));
+            }
+
+            QMessageBox msgBox(dialogParent);
+            msgBox.setIcon(QMessageBox::Critical);
+            msgBox.setWindowTitle(tr("Failed Login"));
+            msgBox.setText(tr("Your client seems to be missing features this server requires for connection.") +
+                           "\n\n" + tr("To update your client, go to 'Help -> Check for Client Updates'."));
+            msgBox.setDetailedText(formatted);
+            msgBox.exec();
+            break;
+        }
+
+        case Response::RespWrongPassword: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("Incorrect username or password. "
+                                     "Please check your authentication information and try again."));
+            break;
+        }
+
+        case Response::RespWouldOverwriteOldSession: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("There is already an active session using this user name.\n"
+                                     "Please close that session first and re-login."));
+            break;
+        }
+
+        case Response::RespUserIsBanned: {
+            QString bannedStr =
+                endTime ? tr("You are banned until %1.").arg(QDateTime::fromSecsSinceEpoch(endTime).toString())
+                        : tr("You are banned indefinitely.");
+            if (!reasonStr.isEmpty()) {
+                bannedStr.append("\n\n" + reasonStr);
+            }
+            QMessageBox::critical(dialogParent, tr("Error"), bannedStr);
+            break;
+        }
+
+        case Response::RespUsernameInvalid: {
+            QMessageBox::critical(dialogParent, tr("Error"), extractInvalidUsernameMessage(reasonStr));
+            break;
+        }
+
+        case Response::RespRegistrationRequired: {
+            if (QMessageBox::question(dialogParent, tr("Error"),
+                                      tr("This server requires user registration. Do you want to register now?"),
+                                      QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
+                registerToServer();
+            }
+            return; // don't re-prompt connect
+        }
+
+        case Response::RespClientIdRequired: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("This server requires client IDs. Your client is either failing to generate an "
+                                     "ID or you are running a modified client.\n"
+                                     "Please close and reopen your client to try again."));
+            break;
+        }
+
+        case Response::RespContextError: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("An internal error has occurred, please close and reopen Cockatrice before "
+                                     "trying again.\nIf the error persists, ensure you are running the latest "
+                                     "version of the software and if needed contact the software developers."));
+            break;
+        }
+
+        case Response::RespAccountNotActivated: {
+            bool ok = false;
+            QString token =
+                getTextWithMax(dialogParent, tr("Account activation"),
+                               tr("Your account has not been activated yet.\n"
+                                  "You need to provide the activation token received in the activation email."),
+                               QLineEdit::Normal, QString(), &ok);
+
+            if (ok && !token.isEmpty()) {
+                remoteClient->activateToServer(token);
+                return;
+            }
+            remoteClient->disconnectFromServer();
+            return;
+        }
+
+        case Response::RespServerFull: {
+            QMessageBox::critical(dialogParent, tr("Server Full"),
+                                  tr("The server has reached its maximum user capacity, please check back later."));
+            break;
+        }
+
+        default: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("Unknown login error: %1").arg(r) +
+                                      tr("\nThis usually means that your client version is out of date, and the server "
+                                         "sent a reply your client doesn't understand."));
+            break;
+        }
+    }
+
+    // Re-open the connect dialog after any handled error
+    connectToServer();
+}
+
+void ConnectionController::onRegisterError(int r, QString reasonStr, quint32 endTime)
+{
+    switch (static_cast<Response::ResponseCode>(r)) {
+        case Response::RespRegistrationDisabled: {
+            QMessageBox::critical(dialogParent, tr("Registration denied"),
+                                  tr("Registration is currently disabled on this server"));
+            break;
+        }
+        case Response::RespUserAlreadyExists: {
+            QMessageBox::critical(dialogParent, tr("Registration denied"),
+                                  tr("There is already an existing account with the same user name."));
+            break;
+        }
+        case Response::RespEmailRequiredToRegister: {
+            QMessageBox::critical(dialogParent, tr("Registration denied"),
+                                  tr("It's mandatory to specify a valid email address when registering."));
+            break;
+        }
+        case Response::RespEmailBlackListed: {
+            if (reasonStr.isEmpty()) {
+                reasonStr =
+                    "The email address provider used during registration has been blocked from use on this server.";
+            }
+            QMessageBox::critical(dialogParent, tr("Registration denied"), reasonStr);
+            break;
+        }
+        case Response::RespTooManyRequests: {
+            QMessageBox::critical(dialogParent, tr("Registration denied"),
+                                  tr("It appears you are attempting to register a new account on this server yet you "
+                                     "already have an account registered with the email provided. This server "
+                                     "restricts the number of accounts a user can register per address. Please "
+                                     "contact the server operator for further assistance or to obtain your "
+                                     "credential information."));
+            break;
+        }
+        case Response::RespPasswordTooShort: {
+            QMessageBox::critical(dialogParent, tr("Registration denied"), tr("Password too short."));
+            break;
+        }
+        case Response::RespUserIsBanned: {
+            QString bannedStr =
+                endTime ? tr("You are banned until %1.").arg(QDateTime::fromSecsSinceEpoch(endTime).toString())
+                        : tr("You are banned indefinitely.");
+            if (!reasonStr.isEmpty()) {
+                bannedStr.append("\n\n" + reasonStr);
+            }
+            QMessageBox::critical(dialogParent, tr("Error"), bannedStr);
+            break;
+        }
+        case Response::RespUsernameInvalid: {
+            QMessageBox::critical(dialogParent, tr("Error"), extractInvalidUsernameMessage(reasonStr));
+            break;
+        }
+        case Response::RespRegistrationFailed: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("Registration failed for a technical problem on the server."));
+            break;
+        }
+        case Response::RespNotConnected: {
+            QMessageBox::critical(dialogParent, tr("Error"), tr("The connection to the server has been lost."));
+            break;
+        }
+        default: {
+            QMessageBox::critical(dialogParent, tr("Error"),
+                                  tr("Unknown registration error: %1").arg(r) +
+                                      tr("\nThis usually means that your client version is out of date, and the server "
+                                         "sent a reply your client doesn't understand."));
+            break;
+        }
+    }
+
+    registerToServer();
+}
+
+void ConnectionController::onActivateError()
+{
+    QMessageBox::critical(dialogParent, tr("Error"), tr("Account activation failed"));
+    remoteClient->disconnectFromServer();
+    connectToServer();
+}
+
+void ConnectionController::onSocketError(const QString &errorStr)
+{
+    QMessageBox::critical(dialogParent, tr("Error"), tr("Socket error: %1").arg(errorStr));
+    connectToServer();
+}
+
+void ConnectionController::onServerTimeout()
+{
+    QMessageBox::critical(dialogParent, tr("Error"), tr("Server timeout"));
+    connectToServer();
+}
+
+void ConnectionController::onProtocolVersionMismatch(int localVersion, int remoteVersion)
+{
+    if (localVersion > remoteVersion) {
+        QMessageBox::critical(dialogParent, tr("Error"),
+                              tr("You are trying to connect to an obsolete server. Please downgrade your Cockatrice "
+                                 "version or connect to a suitable server.\n"
+                                 "Local version is %1, remote version is %2.")
+                                  .arg(localVersion)
+                                  .arg(remoteVersion));
+    } else {
+        QMessageBox::critical(dialogParent, tr("Error"),
+                              tr("Your Cockatrice client is obsolete. Please update your Cockatrice version.\n"
+                                 "Local version is %1, remote version is %2.")
+                                  .arg(localVersion)
+                                  .arg(remoteVersion));
+    }
+}
+
+void ConnectionController::onRegisterAccepted()
+{
+    QMessageBox::information(dialogParent, tr("Success"), tr("Registration accepted.\nWill now login."));
+}
+
+void ConnectionController::onRegisterAcceptedNeedsActivate()
+{
+    // Server will send activation email; nothing to display here.
+}
+
+void ConnectionController::onActivateAccepted()
+{
+    QMessageBox::information(dialogParent, tr("Success"), tr("Account activation accepted.\nWill now login."));
+}
+
+void ConnectionController::onNotifyUserAboutUpdate()
+{
+    QMessageBox::information(
+        dialogParent, tr("Information"),
+        tr("This server supports additional features that your client doesn't have.\n"
+           "This is most likely not a problem, but this message might mean there is a new version of "
+           "Cockatrice available or this server is running a custom or pre-release version.\n\n"
+           "To update your client, go to Help -> Check for Updates."));
+}
+
+void ConnectionController::onForgotPasswordSuccess()
+{
+    QMessageBox::information(
+        dialogParent, tr("Reset Password"),
+        tr("Your password has been reset successfully, you can now log in using the new credentials."));
+    SettingsCache::instance().servers().setFPHostName("");
+    SettingsCache::instance().servers().setFPPort("");
+    SettingsCache::instance().servers().setFPPlayerName("");
+}
+
+void ConnectionController::onForgotPasswordError()
+{
+    QMessageBox::warning(
+        dialogParent, tr("Reset Password"),
+        tr("Failed to reset user account password, please contact the server operator to reset your password."));
+    SettingsCache::instance().servers().setFPHostName("");
+    SettingsCache::instance().servers().setFPPort("");
+    SettingsCache::instance().servers().setFPPlayerName("");
+}
+
+void ConnectionController::onPromptForgotPasswordReset()
+{
+    QMessageBox::information(dialogParent, tr("Reset Password"),
+                             tr("Activation request received, please check your email for an activation token."));
+    DlgForgotPasswordReset dlg(dialogParent);
+    if (dlg.exec()) {
+        remoteClient->submitForgotPasswordResetToServer(dlg.getHost(), static_cast<unsigned int>(dlg.getPort()),
+                                                        dlg.getPlayerName(), dlg.getToken(), dlg.getPassword());
+    }
+}
+
+void ConnectionController::onPromptForgotPasswordChallenge()
+{
+    DlgForgotPasswordChallenge dlg(dialogParent);
+    if (dlg.exec()) {
+        remoteClient->submitForgotPasswordChallengeToServer(dlg.getHost(), static_cast<unsigned int>(dlg.getPort()),
+                                                            dlg.getPlayerName(), dlg.getEmail());
+    }
+}
+
+void ConnectionController::updateWindowTitle()
+{
+    const QString appName = QStringLiteral("Cockatrice");
+    QString title;
+
+    switch (remoteClient->getStatus()) {
+        case StatusConnecting: {
+            title = appName + " - " + tr("Connecting to %1...").arg(remoteClient->peerName());
+            break;
+        }
+        case StatusRegistering: {
+            title = appName + " - " +
+                    tr("Registering to %1 as %2...").arg(remoteClient->peerName()).arg(remoteClient->getUserName());
+            break;
+        }
+        case StatusDisconnected: {
+            title = appName + " - " + tr("Disconnected");
+            break;
+        }
+        case StatusLoggingIn: {
+            title = appName + " - " + tr("Connected, logging in at %1").arg(remoteClient->peerName());
+            break;
+        }
+        case StatusLoggedIn: {
+            title = remoteClient->getUserName() + "@" + remoteClient->peerName();
+            break;
+        }
+        case StatusRequestingForgotPassword:
+        case StatusSubmitForgotPasswordChallenge:
+        case StatusSubmitForgotPasswordReset:
+            title = appName + " - " +
+                    tr("Requesting forgotten password to %1 as %2...")
+                        .arg(remoteClient->peerName())
+                        .arg(remoteClient->getUserName());
+            break;
+        default:
+            title = appName;
+    }
+
+    emit windowTitleChanged(title);
+}
+
+// static
+QString ConnectionController::extractInvalidUsernameMessage(QString &in)
+{
+    QString out = tr("Invalid username.") + "<br/>";
+    QStringList rules = in.split(QChar('|'));
+
+    if (rules.size() == 7 || rules.size() == 9) {
+        out += tr("Your username must respect these rules:") + "<ul>";
+
+        out += "<li>" + tr("is %1 - %2 characters long").arg(rules.at(0)).arg(rules.at(1)) + "</li>";
+        out += "<li>" + tr("can %1 contain lowercase characters").arg((rules.at(2).toInt() > 0) ? "" : tr("NOT")) +
+               "</li>";
+        out += "<li>" + tr("can %1 contain uppercase characters").arg((rules.at(3).toInt() > 0) ? "" : tr("NOT")) +
+               "</li>";
+        out +=
+            "<li>" + tr("can %1 contain numeric characters").arg((rules.at(4).toInt() > 0) ? "" : tr("NOT")) + "</li>";
+
+        if (rules.at(6).size() > 0) {
+            out += "<li>" + tr("can contain the following punctuation: %1").arg(rules.at(6).toHtmlEscaped()) + "</li>";
+        }
+
+        out += "<li>" +
+               tr("first character can %1 be a punctuation mark").arg((rules.at(5).toInt() > 0) ? "" : tr("NOT")) +
+               "</li>";
+
+        if (rules.size() == 9) {
+            if (rules.at(7).size() > 0) {
+                QString words = rules.at(7).toHtmlEscaped();
+                if (words.startsWith("\n")) {
+                    out += tr("no unacceptable language as specified by these server rules:",
+                              "note that the following lines will not be translated");
+                    for (QString &line : words.split("\n", Qt::SkipEmptyParts)) {
+                        out += "<li>" + line + "</li>";
+                    }
+                } else {
+                    out += "<li>" + tr("can not contain any of the following words: %1").arg(words) + "</li>";
+                }
+            }
+
+            if (rules.at(8).size() > 0) {
+                out += "<li>" +
+                       tr("can not match any of the following expressions: %1").arg(rules.at(8).toHtmlEscaped()) +
+                       "</li>";
+            }
+        }
+
+        out += "</ul>";
+    } else {
+        out += tr("You may only use A-Z, a-z, 0-9, _, ., and - in your username.");
+    }
+
+    return out;
+}

C++/cockatrice/src/client/network/connection_controller/remote_connection_controller.h

@@ -0,0 +1,98 @@
+#ifndef COCKATRICE_REMOTE_CONNECTION_CONTROLLER_H
+#define COCKATRICE_REMOTE_CONNECTION_CONTROLLER_H
+
+#include "abstract_client.h"
+
+#include <QMessageBox>
+#include <QObject>
+#include <QString>
+#include <QThread>
+#include <libcockatrice/protocol/pb/event_connection_closed.pb.h>
+#include <libcockatrice/protocol/pb/event_server_shutdown.pb.h>
+
+class RemoteClient;
+class ServerInfo_User;
+class DlgConnect;
+
+/**
+ * Owns the RemoteClient and its worker thread.
+ * Encapsulates all connection, authentication, and registration logic so that
+ * MainWindow only needs to react to high-level signals.
+ */
+class ConnectionController : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ConnectionController(QWidget *dialogParent, QObject *parent = nullptr);
+    ~ConnectionController() override;
+
+    RemoteClient *client() const
+    {
+        return remoteClient;
+    }
+
+    void registerToServer();
+    void forgotPasswordRequest();
+    void connectToServer();
+    void
+    connectToServerDirect(const QString &host, unsigned int port, const QString &playerName, const QString &password);
+    void disconnectFromServer();
+
+    void refreshWindowTitle()
+    {
+        updateWindowTitle();
+    }
+
+signals:
+    void windowTitleChanged(const QString &title);
+
+    void tabSupervisorStartRequested(const ServerInfo_User &info);
+    void tabSupervisorStopRequested();
+
+    // Passes the raw ClientStatus through so MainWindow can drive its own
+    // action enable/disable logic
+    void statusChanged(ClientStatus status);
+
+private slots:
+    // Slots wired directly to RemoteClient signals
+    void onStatusChanged(ClientStatus status);
+    void onUserInfoReceived(const ServerInfo_User &info);
+    void onLoginError(int r, QString reasonStr, quint32 endTime, const QList<QString> &missingFeatures);
+    void onRegisterAccepted();
+    void onRegisterAcceptedNeedsActivate();
+    void onRegisterError(int r, QString reasonStr, quint32 endTime);
+    void onActivateAccepted();
+    void onActivateError();
+    void onProtocolVersionMismatch(int localVersion, int remoteVersion);
+    void onNotifyUserAboutUpdate();
+    void onConnectionClosedEvent(const Event_ConnectionClosed &event);
+    void onServerShutdownEvent(const Event_ServerShutdown &event);
+    void onSocketError(const QString &errorStr);
+    void onServerTimeout();
+
+    // Forgot-password flow
+    void onForgotPasswordSuccess();
+    void onForgotPasswordError();
+    void onPromptForgotPasswordReset();
+    void onPromptForgotPasswordChallenge();
+
+private:
+    void wireClientSignals();
+    void updateWindowTitle();
+
+    /** Parse the server's pipe-delimited username-rule string into HTML. */
+    static QString extractInvalidUsernameMessage(QString &in);
+
+    RemoteClient *remoteClient{nullptr};
+    QThread *clientThread{nullptr};
+    QWidget *dialogParent{nullptr}; // used as parent for QMessageBox / dialog calls
+
+    // Persistent so it can be updated in-place by onServerShutdownEvent
+    QMessageBox serverShutdownMessageBox;
+
+    // Kept as a member so the forgot-password signal can be wired to it
+    DlgConnect *dlgConnect{nullptr};
+};
+
+#endif // COCKATRICE_REMOTE_CONNECTION_CONTROLLER_H

C++/cockatrice/src/client/network/interfaces/deck_stats_interface.cpp

@@ -0,0 +1,82 @@
+#include "deck_stats_interface.h"
+
+#include <QDesktopServices>
+#include <QMessageBox>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QRegularExpression>
+#include <QUrlQuery>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <libcockatrice/deck_list/deck_list.h>
+#include <libcockatrice/deck_list/tree/deck_list_card_node.h>
+#include <version_string.h>
+
+DeckStatsInterface::DeckStatsInterface(QObject *parent) : QObject(parent)
+{
+    manager = new QNetworkAccessManager(this);
+    connect(manager, &QNetworkAccessManager::finished, this, &DeckStatsInterface::queryFinished);
+}
+
+void DeckStatsInterface::queryFinished(QNetworkReply *reply)
+{
+    if (reply->error() != QNetworkReply::NoError) {
+        QMessageBox::critical(nullptr, tr("Error"), reply->errorString());
+        reply->deleteLater();
+        deleteLater();
+        return;
+    }
+
+    QString data(reply->readAll());
+    reply->deleteLater();
+
+    static const QRegularExpression rx("<meta property=\"og:url\" content=\"([^\"]+)\"");
+    auto match = rx.match(data);
+    if (!match.hasMatch()) {
+        QMessageBox::critical(nullptr, tr("Error"), tr("The reply from the server could not be parsed."));
+        deleteLater();
+        return;
+    }
+
+    QString deckUrl = match.captured(1);
+    QDesktopServices::openUrl(deckUrl);
+
+    deleteLater();
+}
+
+void DeckStatsInterface::getAnalyzeRequestData(const DeckList &deck, QByteArray &data)
+{
+    DeckList deckWithoutTokens;
+    copyDeckWithoutTokens(deck, deckWithoutTokens);
+
+    QUrl params;
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("deck", deckWithoutTokens.writeToString_Plain());
+    urlQuery.addQueryItem("decktitle", deck.getName());
+    params.setQuery(urlQuery);
+    data.append(params.query(QUrl::EncodeReserved).toUtf8());
+}
+
+void DeckStatsInterface::analyzeDeck(const DeckList &deck)
+{
+    QByteArray data;
+    getAnalyzeRequestData(deck, data);
+
+    QNetworkRequest request(QUrl("https://deckstats.net/index.php"));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+    request.setHeader(QNetworkRequest::UserAgentHeader, QString("Cockatrice %1").arg(VERSION_STRING));
+
+    manager->post(request, data);
+}
+
+void DeckStatsInterface::copyDeckWithoutTokens(const DeckList &source, DeckList &destination)
+{
+    auto copyIfNotAToken = [&destination](const auto node, const auto card) {
+        CardInfoPtr dbCard = CardDatabaseManager::query()->getCardInfo(card->getName());
+        if (dbCard && !dbCard->getIsToken()) {
+            DecklistCardNode *addedCard = destination.addCard(card->getName(), node->getName(), -1);
+            addedCard->setNumber(card->getNumber());
+        }
+    };
+
+    source.forEachCard(copyIfNotAToken);
+}

C++/cockatrice/src/client/network/interfaces/deck_stats_interface.h

@@ -0,0 +1,39 @@
+/**
+ * @file deck_stats_interface.h
+ * @ingroup ApiInterfaces
+ */
+//! \todo Document this file.
+
+#ifndef DECKSTATS_INTERFACE_H
+#define DECKSTATS_INTERFACE_H
+
+#include <libcockatrice/deck_list/deck_list.h>
+
+class QByteArray;
+class QNetworkAccessManager;
+class QNetworkReply;
+class DeckList;
+
+class DeckStatsInterface : public QObject
+{
+    Q_OBJECT
+private:
+    QNetworkAccessManager *manager;
+
+    /**
+     * Deckstats doesn't recognize token cards, and instead tries to find the
+     * closest non-token card instead. So we construct a new deck which has no
+     * tokens.
+     */
+    void copyDeckWithoutTokens(const DeckList &source, DeckList &destination);
+
+private slots:
+    void queryFinished(QNetworkReply *reply);
+    void getAnalyzeRequestData(const DeckList &deck, QByteArray &data);
+
+public:
+    explicit DeckStatsInterface(QObject *parent = nullptr);
+    void analyzeDeck(const DeckList &deck);
+};
+
+#endif

C++/cockatrice/src/client/network/interfaces/tapped_out_interface.cpp

@@ -0,0 +1,116 @@
+#include "tapped_out_interface.h"
+
+#include <QDesktopServices>
+#include <QMessageBox>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QRegularExpression>
+#include <QUrlQuery>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <libcockatrice/deck_list/deck_list.h>
+#include <libcockatrice/deck_list/tree/deck_list_card_node.h>
+#include <version_string.h>
+
+TappedOutInterface::TappedOutInterface(QObject *parent) : QObject(parent)
+{
+    manager = new QNetworkAccessManager(this);
+    connect(manager, &QNetworkAccessManager::finished, this, &TappedOutInterface::queryFinished);
+}
+
+void TappedOutInterface::queryFinished(QNetworkReply *reply)
+{
+    if (reply->error() != QNetworkReply::NoError) {
+        QMessageBox::critical(nullptr, tr("Error"), reply->errorString());
+        reply->deleteLater();
+        deleteLater();
+        return;
+    }
+
+    int httpStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    if (reply->hasRawHeader("Location")) {
+        /*
+         * If the reply contains a "Location" header, a relative URL to the deck on TappedOut
+         * can be extracted from the header. The http status is a 302 "redirect".
+         */
+        QString deckUrl = reply->rawHeader("Location");
+        qCInfo(TappedOutInterfaceLog) << "Tappedout: good reply, http status" << httpStatus << "location" << deckUrl;
+        QDesktopServices::openUrl("https://tappedout.net" + deckUrl);
+    } else {
+        /*
+         * Otherwise, the deck has not been parsed correctly. Error messages can be extracted
+         * from the html. Css pseudo selector for errors: $("div.alert-danger > ul > li")
+         */
+        QString data(reply->readAll());
+        QStringList errorMessageList = {tr("Unable to analyze the deck.")};
+
+        static const QRegularExpression rx("<div class=\"alert alert-danger.*?<ul>(.*?)</ul>");
+        auto match = rx.match(data);
+        if (match.hasMatch()) {
+            QString errors = match.captured(1);
+            static const QRegularExpression rx2("<li>(.*?)</li>");
+            static const QRegularExpression rxremove("<[^>]*>");
+            auto matchIterator = rx2.globalMatch(errors);
+            while (matchIterator.hasNext()) {
+                auto match2 = matchIterator.next();
+                errorMessageList.append(match2.captured(1).remove(rxremove).simplified());
+            }
+        }
+
+        QString errorMessage = errorMessageList.join("\n");
+        qCWarning(TappedOutInterfaceLog) << "Tappedout: bad reply, http status" << httpStatus << "size" << data.size()
+                                         << "message" << errorMessage;
+
+        QMessageBox::critical(nullptr, tr("Error"), errorMessage);
+    }
+
+    reply->deleteLater();
+    deleteLater();
+}
+
+void TappedOutInterface::getAnalyzeRequestData(const DeckList &deck, QByteArray &data)
+{
+    DeckList mainboard, sideboard;
+    copyDeckSplitMainAndSide(deck, mainboard, sideboard);
+
+    QUrl params;
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("name", deck.getName());
+    urlQuery.addQueryItem("mainboard", mainboard.writeToString_Plain(false, true));
+    urlQuery.addQueryItem("sideboard", sideboard.writeToString_Plain(false, true));
+    params.setQuery(urlQuery);
+    data.append(params.query(QUrl::EncodeReserved).toUtf8());
+}
+
+void TappedOutInterface::analyzeDeck(const DeckList &deck)
+{
+    QByteArray data;
+    getAnalyzeRequestData(deck, data);
+
+    QNetworkRequest request(QUrl("https://tappedout.net/mtg-decks/paste/"));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+    request.setHeader(QNetworkRequest::UserAgentHeader, QString("Cockatrice %1").arg(VERSION_STRING));
+    // we interpret the redirect and open it in the browser instead, do not follow redirects
+    request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::ManualRedirectPolicy);
+
+    manager->post(request, data);
+}
+
+void TappedOutInterface::copyDeckSplitMainAndSide(const DeckList &source, DeckList &mainboard, DeckList &sideboard)
+{
+    auto copyMainOrSide = [&mainboard, &sideboard](const auto node, const auto card) {
+        CardInfoPtr dbCard = CardDatabaseManager::query()->getCardInfo(card->getName());
+        if (!dbCard || dbCard->getIsToken()) {
+            return;
+        }
+
+        DecklistCardNode *addedCard;
+        if (node->getName() == DECK_ZONE_SIDE) {
+            addedCard = sideboard.addCard(card->getName(), node->getName(), -1);
+        } else {
+            addedCard = mainboard.addCard(card->getName(), node->getName(), -1);
+        }
+        addedCard->setNumber(card->getNumber());
+    };
+
+    source.forEachCard(copyMainOrSide);
+}

C++/cockatrice/src/client/network/interfaces/tapped_out_interface.h

@@ -0,0 +1,42 @@
+/**
+ * @file tapped_out_interface.h
+ * @ingroup ApiInterfaces
+ */
+//! \todo Document this file.
+
+#ifndef TAPPEDOUT_INTERFACE_H
+#define TAPPEDOUT_INTERFACE_H
+
+#include <QLoggingCategory>
+#include <QObject>
+
+inline Q_LOGGING_CATEGORY(TappedOutInterfaceLog, "tapped_out_interface");
+
+class QByteArray;
+class QNetworkAccessManager;
+class QNetworkReply;
+class DeckList;
+
+/**
+ * TappedOutInterface exists in order to support the "Analyze on TappedOut" feature.
+ * An http POST request is sent and the result is retrieved from the reply. Parsing
+ * logic is implemented in TappedOutInterface::queryFinished().
+ */
+
+class TappedOutInterface : public QObject
+{
+    Q_OBJECT
+private:
+    QNetworkAccessManager *manager;
+
+    void copyDeckSplitMainAndSide(const DeckList &source, DeckList &mainboard, DeckList &sideboard);
+private slots:
+    void queryFinished(QNetworkReply *reply);
+    void getAnalyzeRequestData(const DeckList &deck, QByteArray &data);
+
+public:
+    explicit TappedOutInterface(QObject *parent = nullptr);
+    void analyzeDeck(const DeckList &deck);
+};
+
+#endif

C++/cockatrice/src/client/network/parsers/deck_link_to_api_transformer.cpp

@@ -0,0 +1,61 @@
+#include "deck_link_to_api_transformer.h"
+
+#include <QRegularExpression>
+
+namespace DeckLinkToApiTransformer
+{
+
+static const QString TAPPEDOUT_BASE = "https://tappedout.net/mtg-decks/";
+static const QString TAPPEDOUT_SUFFIX = "/?fmt=txt";
+
+static const QString ARCHIDEKT_BASE = "https://archidekt.com/api/decks/";
+static const QString ARCHIDEKT_SUFFIX = "/?format=json";
+
+static const QString MOXFIELD_BASE = "https://api.moxfield.com/v2/decks/all/";
+static const QString MOXFIELD_SUFFIX = "/";
+
+static const QString DECKSTATS_SUFFIX = "?include_comments=1&export_mtgarena=1";
+
+bool parseDeckUrl(const QString &url, ParsedDeckInfo &outInfo)
+{
+    static QRegularExpression rxTappedOut("tappedout\\.net/(?:mtg-decks/)?([^/?#]+)");
+    static QRegularExpression rxArchidekt("archidekt\\.com/decks/(\\d+)");
+    static QRegularExpression rxMoxfield("moxfield\\.com/decks/([a-zA-Z0-9_-]+)");
+    static QRegularExpression rxDeckstats("deckstats\\.net/decks/(\\d+/[a-zA-Z0-9_-]+)");
+
+    QRegularExpressionMatch match;
+
+    if ((match = rxTappedOut.match(url)).hasMatch()) {
+        QString slug = match.captured(1);
+        outInfo = ParsedDeckInfo{.baseUrl = TAPPEDOUT_BASE,
+                                 .deckID = slug,
+                                 .fullUrl = TAPPEDOUT_BASE + slug + TAPPEDOUT_SUFFIX,
+                                 .provider = DeckProvider::TappedOut};
+        return true;
+    } else if ((match = rxArchidekt.match(url)).hasMatch()) {
+        QString deckID = match.captured(1);
+        outInfo = ParsedDeckInfo{.baseUrl = ARCHIDEKT_BASE,
+                                 .deckID = deckID,
+                                 .fullUrl = ARCHIDEKT_BASE + deckID + ARCHIDEKT_SUFFIX,
+                                 .provider = DeckProvider::Archidekt};
+        return true;
+    } else if ((match = rxMoxfield.match(url)).hasMatch()) {
+        QString deckID = match.captured(1);
+        outInfo = ParsedDeckInfo{.baseUrl = MOXFIELD_BASE,
+                                 .deckID = deckID,
+                                 .fullUrl = MOXFIELD_BASE + deckID + MOXFIELD_SUFFIX,
+                                 .provider = DeckProvider::Moxfield};
+        return true;
+    } else if ((match = rxDeckstats.match(url)).hasMatch()) {
+        QString deckPath = match.captured(1);
+        outInfo = ParsedDeckInfo{.baseUrl = "https://deckstats.net/decks/",
+                                 .deckID = deckPath,
+                                 .fullUrl = "https://deckstats.net/decks/" + deckPath + DECKSTATS_SUFFIX,
+                                 .provider = DeckProvider::Deckstats};
+        return true;
+    }
+
+    return false;
+}
+
+} // namespace DeckLinkToApiTransformer

C++/cockatrice/src/client/network/parsers/deck_link_to_api_transformer.h

@@ -0,0 +1,37 @@
+/**
+ * @file deck_link_to_api_transformer.h
+ * @ingroup ApiInterfaces
+ */
+//! \todo Document this file.
+
+#ifndef DECK_LINK_TO_API_TRANSFORMER_H
+#define DECK_LINK_TO_API_TRANSFORMER_H
+
+#include <QString>
+
+enum class DeckProvider
+{
+    TappedOut,
+    Archidekt,
+    Moxfield,
+    Deckstats,
+    Unknown
+};
+
+struct ParsedDeckInfo
+{
+    QString baseUrl;
+    QString deckID;
+    QString fullUrl;
+    DeckProvider provider;
+};
+
+namespace DeckLinkToApiTransformer
+{
+
+// Returns true if the input URL is recognized and fills outInfo.
+bool parseDeckUrl(const QString &url, ParsedDeckInfo &outInfo);
+
+} // namespace DeckLinkToApiTransformer
+
+#endif // DECK_LINK_TO_API_TRANSFORMER_H

C++/cockatrice/src/client/network/parsers/interface_json_deck_parser.h

@@ -0,0 +1,121 @@
+/**
+ * @file interface_json_deck_parser.h
+ * @ingroup ApiInterfaces
+ */
+//! \todo Document this file.
+
+#ifndef INTERFACE_JSON_DECK_PARSER_H
+#define INTERFACE_JSON_DECK_PARSER_H
+
+#include "../../../interface/deck_loader/card_node_function.h"
+
+#include <QJsonArray>
+#include <QJsonObject>
+#include <libcockatrice/card/import/card_name_normalizer.h>
+#include <libcockatrice/deck_list/deck_list.h>
+
+class IJsonDeckParser
+{
+public:
+    virtual ~IJsonDeckParser() = default;
+
+    virtual DeckList parse(const QJsonObject &obj) = 0;
+};
+
+class ArchidektJsonParser : public IJsonDeckParser
+{
+public:
+    DeckList parse(const QJsonObject &obj) override
+    {
+        DeckList deckList;
+
+        QString deckName = obj.value("name").toString();
+        QString deckDescription = obj.value("description").toString();
+
+        deckList.setName(deckName);
+        deckList.setComments(deckDescription);
+
+        QString outputText;
+        QTextStream outStream(&outputText);
+
+        for (auto entry : obj.value("cards").toArray()) {
+            auto quantity = entry.toObject().value("quantity").toInt();
+
+            auto card = entry.toObject().value("card").toObject();
+            auto oracleCard = card.value("oracleCard").toObject();
+            QString cardName = oracleCard.value("name").toString();
+            QString setName = card.value("edition").toObject().value("editioncode").toString().toUpper();
+            QString collectorNumber = card.value("collectorNumber").toString();
+
+            outStream << quantity << ' ' << cardName << " (" << setName << ") " << collectorNumber << '\n';
+        }
+
+        deckList.loadFromStream_Plain(outStream, false, CardNameNormalizer());
+        deckList.forEachCard(CardNodeFunction::ResolveProviderId());
+
+        return deckList;
+    }
+};
+
+class MoxfieldJsonParser : public IJsonDeckParser
+{
+public:
+    DeckList parse(const QJsonObject &obj) override
+    {
+        DeckList deckList;
+
+        QString deckName = obj.value("name").toString();
+        QString deckDescription = obj.value("description").toString();
+
+        deckList.setName(deckName);
+        deckList.setComments(deckDescription);
+
+        QString outputText;
+        QTextStream outStream(&outputText);
+
+        for (auto entry : obj.value("mainboard").toObject()) {
+            auto quantity = entry.toObject().value("quantity").toInt();
+
+            auto card = entry.toObject().value("card").toObject();
+            QString cardName = card.value("name").toString();
+            QString setName = card.value("set").toString().toUpper();
+            QString collectorNumber = card.value("cn").toString();
+
+            outStream << quantity << ' ' << cardName << " (" << setName << ") " << collectorNumber << '\n';
+        }
+
+        outStream << '\n';
+
+        for (auto entry : obj.value("sideboard").toObject()) {
+            auto quantity = entry.toObject().value("quantity").toInt();
+
+            auto card = entry.toObject().value("card").toObject();
+            QString cardName = card.value("name").toString();
+            QString setName = card.value("set").toString().toUpper();
+            QString collectorNumber = card.value("cn").toString();
+
+            outStream << quantity << ' ' << cardName << " (" << setName << ") " << collectorNumber << '\n';
+        }
+
+        deckList.loadFromStream_Plain(outStream, false, CardNameNormalizer());
+        deckList.forEachCard(CardNodeFunction::ResolveProviderId());
+
+        QJsonObject commandersObj = obj.value("commanders").toObject();
+        if (!commandersObj.isEmpty()) {
+            for (auto it = commandersObj.begin(); it != commandersObj.end(); ++it) {
+                QJsonObject cardData = it.value().toObject().value("card").toObject();
+                QString commanderName = cardData.value("name").toString();
+                QString setName = cardData.value("set").toString().toUpper();
+                QString collectorNumber = cardData.value("cn").toString();
+                QString providerId = cardData.value("scryfall_id").toString();
+
+                deckList.setBannerCard({commanderName, providerId});
+                deckList.addCard(commanderName, DECK_ZONE_MAIN, -1, setName, collectorNumber, providerId);
+            }
+        }
+
+        return deckList;
+    }
+};
+
+#endif // INTERFACE_JSON_DECK_PARSER_H

C++/cockatrice/src/client/network/update/card_spoiler/spoiler_background_updater.cpp

@@ -0,0 +1,228 @@
+#include "spoiler_background_updater.h"
+
+#include "../../../../interface/window_main.h"
+#include "../../../../main.h"
+#include "../../../settings/cache_settings.h"
+
+#include <QCryptographicHash>
+#include <QDateTime>
+#include <QDebug>
+#include <QFile>
+#include <QLocale>
+#include <QNetworkReply>
+#include <QUrl>
+#include <QtConcurrent>
+#include <libcockatrice/card/database/card_database.h>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <version_string.h>
+
+#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 {
+        qCInfo(SpoilerBackgroundUpdaterLog) << "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);
+    auto request = QNetworkRequest(url);
+    request.setHeader(QNetworkRequest::UserAgentHeader, QString("Cockatrice %1").arg(VERSION_STRING));
+    QNetworkReply *reply = nam->get(request);
+
+    if (saveResults) {
+        // This will write out to the file (used for spoiler.xml)
+        connect(reply, &QNetworkReply::finished, this, &SpoilerBackgroundUpdater::actDownloadFinishedSpoilersFile);
+    } else {
+        // This will check the status (used to see if we're in spoiler season or not)
+        connect(reply, &QNetworkReply::finished, this, &SpoilerBackgroundUpdater::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 {
+        qCWarning(SpoilerBackgroundUpdaterLog) << "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()) {
+        qCInfo(SpoilerBackgroundUpdaterLog) << "Deleting spoiler.xml";
+        return true;
+    }
+
+    qCInfo(SpoilerBackgroundUpdaterLog) << "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"));
+        }
+
+        qCInfo(SpoilerBackgroundUpdaterLog) << "Spoiler Season Offline";
+        emit spoilerCheckerDone();
+    } else if (errorCode == QNetworkReply::NoError) {
+        qCInfo(SpoilerBackgroundUpdaterLog) << "Spoiler Service Online";
+        startSpoilerDownloadProcess(SPOILERS_URL, true);
+    } else if (errorCode == QNetworkReply::HostNotFoundError) {
+        if (trayIcon) {
+            trayIcon->showMessage(tr("Spoilers download failed"), tr("No internet connection"));
+        }
+
+        qCWarning(SpoilerBackgroundUpdaterLog) << "Spoiler download failed due to no internet connection";
+        emit spoilerCheckerDone();
+    } else {
+        if (trayIcon) {
+            trayIcon->showMessage(tr("Spoilers download failed"), tr("Error") + " " + (short)errorCode);
+        }
+
+        qCWarning(SpoilerBackgroundUpdaterLog) << "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"));
+        }
+
+        qCInfo(SpoilerBackgroundUpdaterLog) << "Spoilers Up to Date";
+        return false;
+    }
+
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly)) {
+        qCWarning(SpoilerBackgroundUpdaterLog) << "Spoiler Service Error: File open (w) failed for" << fileName;
+        file.close();
+        return false;
+    }
+
+    if (file.write(data) == -1) {
+        qCWarning(SpoilerBackgroundUpdaterLog) << "Spoiler Service Error: File write (w) failed for" << fileName;
+        file.close();
+        return false;
+    }
+
+    file.close();
+
+    // Data written, so reload the card database
+    qCInfo(SpoilerBackgroundUpdaterLog) << "Spoiler Service Data Written";
+    const auto reloadOk = QtConcurrent::run([] { CardDatabaseManager::getInstance()->loadCardDatabases(); });
+
+    // If the user has notifications enabled, let them know
+    // when the database was last updated
+    if (trayIcon) {
+        QList<QByteArray> lines = data.split('\n');
+
+        for (const 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");
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+                utcTime.setTimeZone(QTimeZone::UTC);
+#else
+                utcTime.setTimeSpec(Qt::UTC);
+#endif
+
+                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);
+
+        qCInfo(SpoilerBackgroundUpdaterLog) << "File Hash =" << hash.result();
+
+        file.close();
+        return hash.result();
+    } else {
+        qCWarning(SpoilerBackgroundUpdaterLog) << "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);
+
+    qCInfo(SpoilerBackgroundUpdaterLog) << "Data Hash =" << hash.result();
+
+    return hash.result();
+}

C++/cockatrice/src/client/network/update/card_spoiler/spoiler_background_updater.h

@@ -0,0 +1,47 @@
+/**
+ * @file spoiler_background_updater.h
+ * @ingroup Client
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_SPOILER_DOWNLOADER_H
+#define COCKATRICE_SPOILER_DOWNLOADER_H
+
+#include <QByteArray>
+#include <QLoggingCategory>
+#include <QObject>
+#include <QProcess>
+
+inline Q_LOGGING_CATEGORY(SpoilerBackgroundUpdaterLog, "spoiler_background_updater");
+
+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

C++/cockatrice/src/client/network/update/client/client_update_checker.cpp

@@ -0,0 +1,35 @@
+#include "client_update_checker.h"
+
+#include "../../../settings/cache_settings.h"
+#include "release_channel.h"
+
+ClientUpdateChecker::ClientUpdateChecker(QObject *parent) : QObject(parent)
+{
+}
+
+void ClientUpdateChecker::check()
+{
+    auto releaseChannel = SettingsCache::instance().getUpdateReleaseChannel();
+
+    finishedCheckConnection =
+        connect(releaseChannel, &ReleaseChannel::finishedCheck, this, &ClientUpdateChecker::actFinishedCheck);
+    errorConnection = connect(releaseChannel, &ReleaseChannel::error, this, &ClientUpdateChecker::actError);
+
+    releaseChannel->checkForUpdates();
+}
+
+void ClientUpdateChecker::actFinishedCheck(bool needToUpdate, bool isCompatible, Release *release)
+{
+    disconnect(finishedCheckConnection);
+    disconnect(errorConnection);
+
+    emit finishedCheck(needToUpdate, isCompatible, release);
+}
+
+void ClientUpdateChecker::actError(const QString &errorString)
+{
+    disconnect(finishedCheckConnection);
+    disconnect(errorConnection);
+
+    emit error(errorString);
+}

C++/cockatrice/src/client/network/update/client/client_update_checker.h

@@ -0,0 +1,51 @@
+/**
+ * @file client_update_checker.h
+ * @ingroup ClientUpdate
+ */
+//! \todo Document this file.
+
+#ifndef CLIENT_UPDATE_CHECKER_H
+#define CLIENT_UPDATE_CHECKER_H
+#include <QObject>
+
+class Release;
+
+/**
+ * We use a singleton instance of UpdateChannel, which can cause interference and feedback loops when multiple objects
+ * connect to it.
+ *
+ * This class encapsulates the usage of that UpdateChannel to ensure that the check only happens once per connection and
+ * the connection is destroyed after it's been used.
+ */
+class ClientUpdateChecker : public QObject
+{
+    Q_OBJECT
+
+    QMetaObject::Connection finishedCheckConnection;
+    QMetaObject::Connection errorConnection;
+
+    void actFinishedCheck(bool needToUpdate, bool isCompatible, Release *release);
+    void actError(const QString &errorString);
+
+public:
+    explicit ClientUpdateChecker(QObject *parent = nullptr);
+    /**
+     * Actually performs the check, using the currently selected update channel in the settings.
+     * Any resulting signals will only be sent once.
+     * This method should only be called ONCE per instance.
+     */
+    void check();
+
+signals:
+    /**
+     * Forwarded from UpdateChannel::finishedCheck
+     */
+    void finishedCheck(bool needToUpdate, bool isCompatible, Release *release);
+
+    /**
+     * Forwarded from UpdateChannel::error
+     */
+    void error(const QString &errorString);
+};
+
+#endif // CLIENT_UPDATE_CHECKER_H

C++/cockatrice/src/client/network/update/client/release_channel.cpp

@@ -0,0 +1,310 @@
+#include "release_channel.h"
+
+#include "version_string.h"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QMessageBox>
+#include <QNetworkReply>
+#include <QRegularExpression>
+#include <QSysInfo>
+#include <QtGlobal>
+
+#if defined(Q_OS_MACOS)
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#endif
+
+#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
+
+ReleaseChannel::ReleaseChannel() : netMan(new QNetworkAccessManager(this)), response(nullptr), lastRelease(nullptr)
+{
+}
+
+ReleaseChannel::~ReleaseChannel()
+{
+    netMan->deleteLater();
+}
+
+void ReleaseChannel::checkForUpdates()
+{
+    QString releaseChannelUrl = getReleaseChannelUrl();
+    qCInfo(ReleaseChannelLog) << "Searching for updates on the channel: " << releaseChannelUrl;
+    response = netMan->get(QNetworkRequest(releaseChannelUrl));
+    connect(response, &QNetworkReply::finished, this, &ReleaseChannel::releaseListFinished);
+}
+
+// Different release channel checking functions for different operating systems
+bool ReleaseChannel::downloadMatchesCurrentOS(const QString &fileName)
+{
+#if defined(Q_OS_MACOS)
+    static QRegularExpression version_regex("macOS(\\d+)");
+    auto match = version_regex.match(fileName);
+    if (!match.hasMatch()) {
+        return false;
+    }
+
+    auto getSystemVersion = [] {
+        // QSysInfo does not go through translation layers
+        // We need to use sysctl to reliably detect the underlying architecture
+        char arch[255];
+        size_t len = sizeof(arch);
+        if (sysctlbyname("machdep.cpu.brand_string", arch, &len, nullptr, 0) == 0) {
+            // Intel mac is only supported on macOS 13 versions
+            if (QString::fromUtf8(arch).contains("Intel")) {
+                return 13;
+            }
+        }
+
+        return QSysInfo::productVersion().split(".")[0].toInt();
+    };
+
+    // older(smaller) releases are compatible with a newer or the same system version
+    int sys_maj = getSystemVersion();
+    int rel_maj = match.captured(1).toInt();
+    return rel_maj == sys_maj;
+
+#elif defined(Q_OS_WIN)
+#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
+    Q_UNUSED(fileName);
+    return false;
+#endif
+
+#else // If the OS doesn't fit one of the above #defines, then it will never match
+    Q_UNUSED(fileName);
+    return false;
+#endif
+}
+
+QString StableReleaseChannel::getManualDownloadUrl() const
+{
+    return QString(STABLEMANUALDOWNLOAD_URL);
+}
+
+QString StableReleaseChannel::getName() const
+{
+    return tr("Default");
+}
+
+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) {
+        qCWarning(ReleaseChannelLog) << "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"))) {
+        qCWarning(ReleaseChannelLog) << "Invalid received from the release update server:" << resultMap;
+        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();
+        for (const auto &rawAsset : rawAssets) {
+            QVariantMap asset = rawAsset.toMap();
+            QString name = asset["name"].toString();
+            QString url = asset["browser_download_url"].toString();
+
+            if (downloadMatchesCurrentOS(name)) {
+                lastRelease->setDownloadUrl(url);
+                break;
+            }
+        }
+    }
+
+    QString shortHash = lastRelease->getCommitHash().left(GIT_SHORT_HASH_LEN);
+    QString myHash = QString(VERSION_COMMIT);
+    qCInfo(ReleaseChannelLog) << "Current hash=" << myHash << "update hash=" << shortHash;
+
+    qCInfo(ReleaseChannelLog) << "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;
+    qCInfo(ReleaseChannelLog) << "Searching for commit hash corresponding to stable channel tag: " << tagName;
+    response = netMan->get(QNetworkRequest(url));
+    connect(response, &QNetworkReply::finished, this, &StableReleaseChannel::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) {
+        qCWarning(ReleaseChannelLog) << "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"))) {
+        qCWarning(ReleaseChannelLog) << "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());
+    qCInfo(ReleaseChannelLog) << "Got reply from tag server, commit=" << lastRelease->getCommitHash();
+
+    QString shortHash = lastRelease->getCommitHash().left(GIT_SHORT_HASH_LEN);
+    QString myHash = QString(VERSION_COMMIT);
+    qCInfo(ReleaseChannelLog) << "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");
+}
+
+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()) {
+        qCWarning(ReleaseChannelLog) << "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")) {
+        qCWarning(ReleaseChannelLog) << "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));
+
+    qCInfo(ReleaseChannelLog) << "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();
+
+    qCInfo(ReleaseChannelLog) << "Searching for a corresponding file on the beta channel: " << betaBuildDownloadUrl;
+    response = netMan->get(QNetworkRequest(betaBuildDownloadUrl));
+    connect(response, &QNetworkReply::finished, this, &BetaReleaseChannel::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) {
+        qCWarning(ReleaseChannelLog) << "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);
+    qCInfo(ReleaseChannelLog) << "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);
+            qCInfo(ReleaseChannelLog) << "Found compatible version url=" << *url;
+            break;
+        }
+    }
+
+    emit finishedCheck(needToUpdate, compatibleVersion, lastRelease);
+}

C++/cockatrice/src/client/network/update/client/release_channel.h

@@ -0,0 +1,159 @@
+/**
+ * @file release_channel.h
+ * @ingroup ClientUpdate
+ */
+//! \todo Document this file.
+
+#ifndef RELEASECHANNEL_H
+#define RELEASECHANNEL_H
+
+#include <QDate>
+#include <QLoggingCategory>
+#include <QObject>
+#include <QString>
+#include <QVariantMap>
+#include <utility>
+
+inline Q_LOGGING_CATEGORY(ReleaseChannelLog, "release_channel");
+
+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:
+    [[nodiscard]] QString getName() const
+    {
+        return name;
+    }
+    [[nodiscard]] QString getDescriptionUrl() const
+    {
+        return descriptionUrl;
+    }
+    [[nodiscard]] QString getDownloadUrl() const
+    {
+        return downloadUrl;
+    }
+    [[nodiscard]] QString getCommitHash() const
+    {
+        return commitHash;
+    }
+    [[nodiscard]] QDate getPublishDate() const
+    {
+        return publishDate;
+    }
+    [[nodiscard]] bool isCompatibleVersionFound() const
+    {
+        return compatibleVersionFound;
+    }
+};
+
+class ReleaseChannel : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ReleaseChannel();
+    ~ReleaseChannel() override;
+
+protected:
+    QNetworkAccessManager *netMan;
+    QNetworkReply *response;
+    Release *lastRelease;
+
+protected:
+    static bool downloadMatchesCurrentOS(const QString &fileName);
+    [[nodiscard]] virtual QString getReleaseChannelUrl() const = 0;
+
+public:
+    Release *getLastRelease()
+    {
+        return lastRelease;
+    }
+    [[nodiscard]] virtual QString getManualDownloadUrl() const = 0;
+    [[nodiscard]] 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;
+
+    [[nodiscard]] QString getManualDownloadUrl() const override;
+
+    [[nodiscard]] QString getName() const override;
+
+protected:
+    [[nodiscard]] 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;
+
+    [[nodiscard]] QString getManualDownloadUrl() const override;
+
+    [[nodiscard]] QString getName() const override;
+
+protected:
+    [[nodiscard]] QString getReleaseChannelUrl() const override;
+protected slots:
+
+    void releaseListFinished() override;
+
+    void fileListFinished() override;
+};
+
+#endif

C++/cockatrice/src/client/network/update/client/update_downloader.cpp

@@ -0,0 +1,67 @@
+#include "update_downloader.h"
+
+#include <QUrl>
+
+UpdateDownloader::UpdateDownloader(QObject *parent) : QObject(parent), response(nullptr)
+{
+    netMan = new QNetworkAccessManager(this);
+}
+
+void UpdateDownloader::beginDownload(QUrl downloadUrl)
+{
+    // Save the original URL because we need it for the filename
+    if (originalUrl.isEmpty()) {
+        originalUrl = downloadUrl;
+    }
+
+    response = netMan->get(QNetworkRequest(downloadUrl));
+    connect(response, &QNetworkReply::finished, this, &UpdateDownloader::fileFinished);
+    connect(response, &QNetworkReply::downloadProgress, this, &UpdateDownloader::downloadProgress);
+    connect(this, &UpdateDownloader::stopDownload, response, &QNetworkReply::abort);
+}
+
+void UpdateDownloader::downloadError(QNetworkReply::NetworkError)
+{
+    if (response == nullptr) {
+        return;
+    }
+
+    emit error(response->errorString().toUtf8());
+}
+
+void UpdateDownloader::fileFinished()
+{
+    // If we finished but there's a redirect, follow it
+    QVariant redirect = response->attribute(QNetworkRequest::RedirectionTargetAttribute);
+    if (!redirect.isNull()) {
+        beginDownload(redirect.toUrl());
+        return;
+    }
+
+    // Handle any errors we had
+    if (response->error()) {
+        emit error(response->errorString());
+        return;
+    }
+
+    // Work out the file name of the download
+    QString fileName = QDir::temp().path() + QDir::separator() + originalUrl.toString().section('/', -1);
+
+    // Save the build in a temporary directory
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly)) {
+        emit error(tr("Could not open the file for reading."));
+        return;
+    }
+
+    file.write(response->readAll());
+    file.close();
+
+    // Emit the success signal with a URL to the download file
+    emit downloadSuccessful(QUrl::fromLocalFile(fileName));
+}
+
+void UpdateDownloader::downloadProgress(qint64 bytesRead, qint64 totalBytes)
+{
+    emit progressMade(bytesRead, totalBytes);
+}

C++/cockatrice/src/client/network/update/client/update_downloader.h

@@ -0,0 +1,35 @@
+/**
+ * @file update_downloader.h
+ * @ingroup ClientUpdate
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_UPDATEDOWNLOADER_H
+#define COCKATRICE_UPDATEDOWNLOADER_H
+
+#include <QObject>
+#include <QtNetwork>
+
+class UpdateDownloader : public QObject
+{
+    Q_OBJECT
+public:
+    explicit UpdateDownloader(QObject *parent);
+    void beginDownload(QUrl url);
+signals:
+    void downloadSuccessful(QUrl filepath);
+    void progressMade(qint64 bytesRead, qint64 totalBytes);
+    void error(QString errorString);
+    void stopDownload();
+
+private:
+    QUrl originalUrl;
+    QNetworkAccessManager *netMan;
+    QNetworkReply *response;
+private slots:
+    void fileFinished();
+    void downloadProgress(qint64 bytesRead, qint64 totalBytes);
+    void downloadError(QNetworkReply::NetworkError);
+};
+
+#endif // COCKATRICE_UPDATEDOWNLOADER_H

C++/cockatrice/src/client/settings/card_counter_settings.cpp

@@ -0,0 +1,59 @@
+#include "card_counter_settings.h"
+
+#include <QColor>
+#include <QSettings>
+#include <QtMath>
+
+CardCounterSettings::CardCounterSettings(const QString &settingsPath, QObject *parent)
+    : SettingsManager(settingsPath + "global.ini", "cards", "counters", parent)
+{
+}
+
+void CardCounterSettings::setColor(int counterId, const QColor &color)
+{
+    QSettings settings = getSettings();
+
+    QString key = QString("cards/counters/%1/color").arg(counterId);
+
+    if (settings.value(key).value<QColor>() == color) {
+        return;
+    }
+
+    settings.setValue(key, color);
+    emit colorChanged(counterId, color);
+}
+
+QColor CardCounterSettings::color(int counterId) const
+{
+    QColor defaultColor;
+
+    if (counterId < 6) {
+        // Preserve legacy colors
+        defaultColor = QColor::fromHsv(counterId * 60, 150, 255);
+    } else {
+        // Future-proof support for more counters with pseudo-random colors
+        int h = (counterId * 37) % 360;
+        int s = 128 + 64 * qSin((counterId * 97) * 0.1);   // 64-192
+        int v = 196 + 32 * qSin((counterId * 101) * 0.07); // 164-228
+
+        defaultColor = QColor::fromHsv(h, s, v);
+    }
+
+    return getSettings().value(QString("cards/counters/%1/color").arg(counterId), defaultColor).value<QColor>();
+}
+
+QString CardCounterSettings::displayName(int counterId) const
+{
+    // Currently, card counters name are fixed to A, B, ..., Z, AA, AB, ...
+
+    auto nChars = 1 + counterId / 26;
+    QString str;
+    str.resize(nChars);
+
+    for (auto it = str.rbegin(); it != str.rend(); ++it) {
+        *it = QChar('A' + (counterId) % 26);
+        counterId /= 26;
+    }
+
+    return str;
+}

C++/cockatrice/src/client/settings/card_counter_settings.h

@@ -0,0 +1,33 @@
+/**
+ * @file card_counter_settings.h
+ * @ingroup GameSettings
+ */
+//! \todo Document this file.
+
+#ifndef CARD_COUNTER_SETTINGS_H
+#define CARD_COUNTER_SETTINGS_H
+
+#include <libcockatrice/settings/settings_manager.h>
+
+class QSettings;
+class QColor;
+
+class CardCounterSettings : public SettingsManager
+{
+    Q_OBJECT
+
+public:
+    CardCounterSettings(const QString &settingsPath, QObject *parent = nullptr);
+
+    [[nodiscard]] QColor color(int counterId) const;
+
+    [[nodiscard]] QString displayName(int counterId) const;
+
+public slots:
+    void setColor(int counterId, const QColor &color);
+
+signals:
+    void colorChanged(int counterId, const QColor &color);
+};
+
+#endif // CARD_COUNTER_SETTINGS_H

C++/cockatrice/src/client/settings/shortcut_treeview.cpp

@@ -0,0 +1,162 @@
+#include "shortcut_treeview.h"
+
+#include "cache_settings.h"
+#include "shortcuts_settings.h"
+
+#include <QHeaderView>
+
+ShortcutFilterProxyModel::ShortcutFilterProxyModel(QObject *parent) : QSortFilterProxyModel(parent)
+{
+}
+
+/**
+ * Appends the parent and source row together before doing the regex match.
+ */
+bool ShortcutFilterProxyModel::filterAcceptsRow(const int sourceRow, const QModelIndex &sourceParent) const
+{
+    QModelIndex nameIndex = sourceModel()->index(sourceRow, filterKeyColumn(), sourceParent);
+    QModelIndex parentIndex = sourceModel()->index(sourceParent.row(), filterKeyColumn(), sourceParent.parent());
+
+    QString name = sourceModel()->data(nameIndex).toString();
+    QString parentName = sourceModel()->data(parentIndex).toString();
+
+    QString searchedString = parentName + " " + name;
+
+    return searchedString.contains(filterRegularExpression());
+}
+
+ShortcutTreeView::ShortcutTreeView(QWidget *parent) : QTreeView(parent)
+{
+    // model
+    shortcutsModel = new QStandardItemModel(this);
+    shortcutsModel->setColumnCount(3);
+    populateShortcutsModel();
+
+    // filter proxy
+    proxyModel = new ShortcutFilterProxyModel(this);
+    proxyModel->setRecursiveFilteringEnabled(true);
+    proxyModel->setSourceModel(shortcutsModel);
+    proxyModel->setDynamicSortFilter(true);
+    proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
+    proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
+    proxyModel->setFilterKeyColumn(0);
+
+    QTreeView::setModel(proxyModel);
+
+    // treeview
+    hideColumn(2);
+
+    setUniformRowHeights(true);
+    setAlternatingRowColors(true);
+
+    setSortingEnabled(true);
+    proxyModel->sort(0, Qt::AscendingOrder);
+
+    header()->setSectionResizeMode(QHeaderView::Interactive);
+    header()->setSortIndicator(0, Qt::AscendingOrder);
+    setSelectionMode(SingleSelection);
+    setSelectionBehavior(SelectRows);
+
+    expandAll();
+
+    connect(&SettingsCache::instance().shortcuts(), &ShortcutsSettings::shortCutChanged, this,
+            &ShortcutTreeView::refreshShortcuts);
+}
+
+void ShortcutTreeView::populateShortcutsModel()
+{
+    QHash<QString, QStandardItem *> parentItems;
+    QStandardItem *curParent = nullptr;
+    for (const auto &key : SettingsCache::instance().shortcuts().getAllShortcutKeys()) {
+        QString name = SettingsCache::instance().shortcuts().getShortcut(key).getName();
+        QString group = SettingsCache::instance().shortcuts().getShortcut(key).getGroupName();
+        QString shortcut = SettingsCache::instance().shortcuts().getShortcutString(key);
+
+        if (parentItems.contains(group)) {
+            curParent = parentItems.value(group);
+        } else {
+            curParent = new QStandardItem(group);
+            static QFont font = curParent->font();
+            font.setBold(true);
+            curParent->setFont(font);
+            parentItems.insert(group, curParent);
+        }
+
+        QList<QStandardItem *> list = {};
+        list << new QStandardItem(name) << new QStandardItem(shortcut) << new QStandardItem(key);
+        curParent->appendRow(list);
+    }
+
+    for (const auto &parent : parentItems) {
+        shortcutsModel->appendRow(parent);
+    }
+}
+
+void ShortcutTreeView::retranslateUi()
+{
+    shortcutsModel->setHeaderData(0, Qt::Horizontal, tr("Action"));
+    shortcutsModel->setHeaderData(1, Qt::Horizontal, tr("Shortcut"));
+    refreshShortcuts();
+}
+
+/**
+ * Loops over the model and reloads all rows
+ */
+static void loopOverModel(QAbstractItemModel *model, const QModelIndex &parent = QModelIndex())
+{
+    for (int r = 0; r < model->rowCount(parent); ++r) {
+        const auto friendlyNameIndex = model->index(r, 0, parent);
+
+        if (model->hasChildren(friendlyNameIndex)) {
+            const auto childIndex = model->index(0, 2, friendlyNameIndex);
+            const auto key = model->data(childIndex).toString();
+            const auto shortcutGroupName = SettingsCache::instance().shortcuts().getShortcut(key).getGroupName();
+            model->setData(friendlyNameIndex, shortcutGroupName);
+
+            loopOverModel(model, friendlyNameIndex);
+        } else {
+            const auto shortcutSequenceIndex = model->index(r, 1, parent);
+            const auto keyIndex = model->index(r, 2, parent);
+            const auto key = model->data(keyIndex).toString();
+
+            const auto shortcutKey = SettingsCache::instance().shortcuts().getShortcut(key).getName();
+            const auto shortcutSequence = SettingsCache::instance().shortcuts().getShortcutString(key);
+            model->setData(friendlyNameIndex, shortcutKey);
+            model->setData(shortcutSequenceIndex, shortcutSequence);
+        }
+    }
+}
+
+void ShortcutTreeView::refreshShortcuts()
+{
+    loopOverModel(shortcutsModel);
+}
+
+void ShortcutTreeView::currentChanged(const QModelIndex &current, const QModelIndex & /* previous */)
+{
+    QTreeView::scrollTo(current, QAbstractItemView::EnsureVisible);
+    if (current.parent().isValid()) {
+        auto shortcutName = model()->data(model()->index(current.row(), 2, current.parent())).toString();
+        emit currentItemChanged(shortcutName);
+    } else {
+        // emit empty string if the selection is a category header
+        emit currentItemChanged("");
+    }
+}
+
+/**
+ * The search string is split by word.
+ * A String is a match as long as it contains all the words in the search string in order
+ */
+void ShortcutTreeView::updateSearchString(const QString &searchString)
+{
+    QStringList searchWords = searchString.split(" ", Qt::SkipEmptyParts);
+
+    auto escapeRegex = [](const QString &s) { return QRegularExpression::escape(s); };
+    std::transform(searchWords.begin(), searchWords.end(), searchWords.begin(), escapeRegex);
+
+    auto regex = QRegularExpression(searchWords.join(".*"), QRegularExpression::CaseInsensitiveOption);
+
+    proxyModel->setFilterRegularExpression(regex);
+    expandAll();
+}

C++/cockatrice/src/client/settings/shortcut_treeview.h

@@ -0,0 +1,52 @@
+/**
+ * @file shortcut_treeview.h
+ * @ingroup CoreSettings
+ */
+//! \todo Document this file.
+
+#ifndef SHORTCUT_TREEVIEW_H
+#define SHORTCUT_TREEVIEW_H
+
+#include <QSortFilterProxyModel>
+#include <QStandardItemModel>
+#include <QTreeView>
+
+/**
+ * Custom implementation of QSortFilterProxyModel that appends the source and parent strings together when filtering
+ */
+class ShortcutFilterProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    explicit ShortcutFilterProxyModel(QObject *parent = nullptr);
+
+protected:
+    [[nodiscard]] bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+class ShortcutTreeView : public QTreeView
+{
+    Q_OBJECT
+public:
+    explicit ShortcutTreeView(QWidget *parent);
+    void retranslateUi();
+
+signals:
+    void currentItemChanged(const QString &shortcut);
+
+public slots:
+    void updateSearchString(const QString &searchString);
+
+private:
+    QStandardItemModel *shortcutsModel;
+    ShortcutFilterProxyModel *proxyModel;
+    void populateShortcutsModel();
+
+private slots:
+    void refreshShortcuts();
+
+protected:
+    void currentChanged(const QModelIndex &current, const QModelIndex &previous) override;
+};
+
+#endif // SHORTCUT_TREEVIEW_H

C++/cockatrice/src/client/settings/shortcuts_settings.cpp

@@ -0,0 +1,266 @@
+#include "shortcuts_settings.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QMessageBox>
+#include <QStringList>
+#include <utility>
+
+ShortcutKey::ShortcutKey(const QString &_name, QList<QKeySequence> _sequence, ShortcutGroup::Groups _group)
+    : QList<QKeySequence>(_sequence), name(_name), group(_group)
+{
+}
+
+ShortcutsSettings::ShortcutsSettings(const QString &settingsPath, QObject *parent) : QObject(parent)
+{
+    shortCuts = defaultShortCuts;
+    settingsFilePath = settingsPath;
+    settingsFilePath.append("shortcuts.ini");
+
+    bool exists = QFile(settingsFilePath).exists();
+
+    QSettings shortCutsFile(settingsFilePath, QSettings::IniFormat);
+
+    if (exists) {
+        shortCutsFile.beginGroup(custom);
+        const QStringList customKeys = shortCutsFile.allKeys();
+
+        QMap<QString, QString> invalidItems;
+        for (QStringList::const_iterator it = customKeys.constBegin(); it != customKeys.constEnd(); ++it) {
+            QString stringSequence = shortCutsFile.value(*it).toString();
+
+            // check whether shortcut name exists
+            if (!shortCuts.contains(*it)) {
+                qCWarning(ShortcutsSettingsLog) << "Unknown shortcut name:" << *it;
+                continue;
+            }
+
+            // check whether shortcut is forbidden
+            if (isKeyAllowed(*it, stringSequence)) {
+                auto shortcut = getShortcut(*it);
+                shortcut.setSequence(parseSequenceString(stringSequence));
+                shortCuts.insert(*it, shortcut);
+            } else {
+                invalidItems.insert(*it, stringSequence);
+            }
+        }
+
+        shortCutsFile.endGroup();
+
+        if (!invalidItems.isEmpty()) {
+            // warning message in case of invalid items
+            QMessageBox msgBox;
+            msgBox.setIcon(QMessageBox::Warning);
+            msgBox.setText(tr("Your configuration file contained invalid shortcuts.\n"
+                              "Please check your shortcut settings!"));
+            QString detailedMessage = tr("The following shortcuts have been set to default:\n");
+            for (QMap<QString, QString>::const_iterator item = invalidItems.constBegin();
+                 item != invalidItems.constEnd(); ++item) {
+                detailedMessage += item.key() + " - \"" + item.value() + "\"\n";
+            }
+            msgBox.setDetailedText(detailedMessage);
+            msgBox.exec();
+        }
+    }
+}
+
+/**
+ * @brief Migrates legacy shortcut key names to current naming scheme.
+ *
+ * PR 5079 changed Textbox/unfocusTextBox to Player/unfocusTextBox and
+ * tab_game/aFocusChat to Player/aFocusChat. This migration allows players
+ * to keep their already configured shortcuts.
+ */
+void ShortcutsSettings::migrateShortcuts()
+{
+    if (QFile(settingsFilePath).exists()) {
+        QSettings shortCutsFile(settingsFilePath, QSettings::IniFormat);
+
+        shortCutsFile.beginGroup(custom);
+
+        if (shortCutsFile.contains("Textbox/unfocusTextBox")) {
+            qCInfo(ShortcutsSettingsLog)
+                << "[ShortcutsSettings] Textbox/unfocusTextBox shortcut found. Migrating to Player/unfocusTextBox.";
+            QString unfocusTextBox = shortCutsFile.value("Textbox/unfocusTextBox", "").toString();
+            this->setShortcuts("Player/unfocusTextBox", unfocusTextBox);
+            shortCutsFile.remove("Textbox/unfocusTextBox");
+        }
+
+        if (shortCutsFile.contains("tab_game/aFocusChat")) {
+            qCInfo(ShortcutsSettingsLog)
+                << "[ShortcutsSettings] tab_game/aFocusChat shortcut found. Migrating to Player/aFocusChat.";
+            QString aFocusChat = shortCutsFile.value("tab_game/aFocusChat", "").toString();
+            this->setShortcuts("Player/aFocusChat", aFocusChat);
+            shortCutsFile.remove("tab_game/aFocusChat");
+        }
+
+        // PR #5564 changes "MainWindow/aDeckEditor" to "Tabs/aTabDeckEditor"
+        if (shortCutsFile.contains("MainWindow/aDeckEditor")) {
+            qCInfo(ShortcutsSettingsLog) << "MainWindow/aDeckEditor shortcut found. Migrating to Tabs/aTabDeckEditor.";
+            QString keySequence = shortCutsFile.value("MainWindow/aDeckEditor", "").toString();
+            this->setShortcuts("Tabs/aTabDeckEditor", keySequence);
+            shortCutsFile.remove("MainWindow/aDeckEditor");
+        }
+
+        shortCutsFile.endGroup();
+    }
+}
+
+ShortcutKey ShortcutsSettings::getDefaultShortcut(const QString &name) const
+{
+    return defaultShortCuts.value(name, ShortcutKey());
+}
+
+ShortcutKey ShortcutsSettings::getShortcut(const QString &name) const
+{
+    if (shortCuts.contains(name)) {
+        return shortCuts.value(name);
+    }
+
+    return getDefaultShortcut(name);
+}
+
+/**
+ * Gets the first shortcut for the given action.
+ *
+ * NOTE: In most cases you should be using ShortcutsSettings::getShortcut instead,
+ * as that will return all shortcuts if there are multiple shortcuts.
+ * The only reason to use this method is if an object does not accept multiple shortcuts, such as with QButtons.
+ */
+QKeySequence ShortcutsSettings::getSingleShortcut(const QString &name) const
+{
+    return getShortcut(name).at(0);
+}
+
+QString ShortcutsSettings::getDefaultShortcutString(const QString &name) const
+{
+    return stringifySequence(getDefaultShortcut(name));
+}
+
+QString ShortcutsSettings::getShortcutString(const QString &name) const
+{
+    return stringifySequence(getShortcut(name));
+}
+
+QString ShortcutsSettings::getShortcutFriendlyName(const QString &shortcutName) const
+{
+    for (auto it = defaultShortCuts.cbegin(); it != defaultShortCuts.cend(); ++it) {
+        if (shortcutName == it.key()) {
+            return it.value().getName();
+        }
+    }
+
+    return {};
+}
+
+QString ShortcutsSettings::stringifySequence(const QList<QKeySequence> &Sequence) const
+{
+    QStringList stringSequence;
+    for (const auto &i : Sequence) {
+        stringSequence.append(i.toString(QKeySequence::PortableText));
+    }
+
+    return stringSequence.join(sep);
+}
+
+QList<QKeySequence> ShortcutsSettings::parseSequenceString(const QString &stringSequence) const
+{
+    QList<QKeySequence> SequenceList;
+    for (const QString &shortcut : stringSequence.split(sep)) {
+        SequenceList.append(QKeySequence(shortcut, QKeySequence::PortableText));
+    }
+
+    return SequenceList;
+}
+
+void ShortcutsSettings::setShortcuts(const QString &name, const QList<QKeySequence> &Sequence)
+{
+    shortCuts[name].setSequence(Sequence);
+
+    QSettings shortCutsFile(settingsFilePath, QSettings::IniFormat);
+    shortCutsFile.beginGroup(custom);
+    shortCutsFile.setValue(name, stringifySequence(Sequence));
+    shortCutsFile.endGroup();
+    emit shortCutChanged();
+}
+
+void ShortcutsSettings::setShortcuts(const QString &name, const QKeySequence &Sequence)
+{
+    setShortcuts(name, QList<QKeySequence>{Sequence});
+}
+
+void ShortcutsSettings::setShortcuts(const QString &name, const QString &sequences)
+{
+    setShortcuts(name, parseSequenceString(sequences));
+}
+
+void ShortcutsSettings::resetAllShortcuts()
+{
+    shortCuts = defaultShortCuts;
+    QSettings shortCutsFile(settingsFilePath, QSettings::IniFormat);
+    shortCutsFile.beginGroup(custom);
+    shortCutsFile.remove("");
+    shortCutsFile.endGroup();
+    emit shortCutChanged();
+}
+
+void ShortcutsSettings::clearAllShortcuts()
+{
+    QSettings shortCutsFile(settingsFilePath, QSettings::IniFormat);
+    shortCutsFile.beginGroup(custom);
+    for (auto it = shortCuts.begin(); it != shortCuts.end(); ++it) {
+        it.value().setSequence(parseSequenceString(""));
+        shortCutsFile.setValue(it.key(), "");
+    }
+    shortCutsFile.endGroup();
+    emit shortCutChanged();
+}
+
+bool ShortcutsSettings::isKeyAllowed(const QString &name, const QString &sequences) const
+{
+    // if the shortcut is not to be used in deck-editor then it doesn't matter
+    if (name.startsWith("Player") || name.startsWith("Replays")) {
+        return true;
+    }
+    QString checkSequence = sequences.split(sep).last();
+    QStringList forbiddenKeys{"Del",        "Backspace", "Down",  "Up",         "Left",       "Right",
+                              "Return",     "Enter",     "Menu",  "Ctrl+Alt+-", "Ctrl+Alt+=", "Ctrl+Alt+[",
+                              "Ctrl+Alt+]", "Tab",       "Space", "Shift+S",    "Shift+Left", "Shift+Right"};
+    return !forbiddenKeys.contains(checkSequence);
+}
+
+/**
+ *  Checks that the shortcut doesn't overlap with an existing shortcut
+ *
+ * @param name The name of the shortcut
+ * @param sequences The shortcut key sequence
+ * @return Whether the shortcut is valid.
+ */
+bool ShortcutsSettings::isValid(const QString &name, const QString &sequences) const
+{
+    return findOverlaps(name, sequences).isEmpty();
+}
+
+/** @brief Checks if the shortcut is a shortcut that is active in all windows. */
+static bool isAlwaysActiveShortcut(const QString &shortcutName)
+{
+    return shortcutName.startsWith("MainWindow") || shortcutName.startsWith("Tabs");
+}
+
+QStringList ShortcutsSettings::findOverlaps(const QString &name, const QString &sequences) const
+{
+    QString checkSequence = sequences.split(sep).last();
+    QString checkKey = name.left(name.indexOf("/"));
+
+    QStringList overlaps;
+    for (const auto &key : shortCuts.keys()) {
+        if (key.startsWith(checkKey) || isAlwaysActiveShortcut(key) || isAlwaysActiveShortcut(checkKey)) {
+            QString storedSequence = stringifySequence(shortCuts.value(key));
+            if (storedSequence.split(sep).contains(checkSequence)) {
+                overlaps.append(getShortcutFriendlyName(key));
+            }
+        }
+    }
+
+    return overlaps;
+}

C++/cockatrice/src/client/settings/shortcuts_settings.h

@@ -0,0 +1,792 @@
+/**
+ * @file shortcuts_settings.h
+ * @ingroup CoreSettings
+ */
+//! \todo Document this file.
+
+#ifndef SHORTCUTSSETTINGS_H
+#define SHORTCUTSSETTINGS_H
+
+#include <QApplication>
+#include <QKeySequence>
+#include <QLoggingCategory>
+#include <QSettings>
+
+inline Q_LOGGING_CATEGORY(ShortcutsSettingsLog, "shortcuts_settings");
+
+class ShortcutGroup
+{
+public:
+    enum Groups
+    {
+        Main_Window,
+        Deck_Editor,
+        Game_Lobby,
+        Card_Counters,
+        Player_Counters,
+        Power_Toughness,
+        Game_Phases,
+        Playing_Area,
+        Move_selected,
+        View,
+        Move_top,
+        Move_bottom,
+        Gameplay,
+        Drawing,
+        Hand,
+        Chat_room,
+        Game_window,
+        Load_deck,
+        Replays,
+        Tabs
+    };
+
+    static QString getGroupName(ShortcutGroup::Groups group)
+    {
+        switch (group) {
+            case Main_Window:
+                return QApplication::translate("shortcutsTab", "Main Window");
+            case Deck_Editor:
+                return QApplication::translate("shortcutsTab", "Deck Editor");
+            case Game_Lobby:
+                return QApplication::translate("shortcutsTab", "Game Lobby");
+            case Card_Counters:
+                return QApplication::translate("shortcutsTab", "Card Counters");
+            case Player_Counters:
+                return QApplication::translate("shortcutsTab", "Player Counters");
+            case Power_Toughness:
+                return QApplication::translate("shortcutsTab", "Power and Toughness");
+            case Game_Phases:
+                return QApplication::translate("shortcutsTab", "Game Phases");
+            case Playing_Area:
+                return QApplication::translate("shortcutsTab", "Playing Area");
+            case Move_selected:
+                return QApplication::translate("shortcutsTab", "Move Selected Card");
+            case View:
+                return QApplication::translate("shortcutsTab", "View");
+            case Move_top:
+                return QApplication::translate("shortcutsTab", "Move Top Card");
+            case Move_bottom:
+                return QApplication::translate("shortcutsTab", "Move Bottom Card");
+            case Gameplay:
+                return QApplication::translate("shortcutsTab", "Gameplay");
+            case Drawing:
+                return QApplication::translate("shortcutsTab", "Drawing");
+            case Hand:
+                return QApplication::translate("shortcutsTab", "Hand");
+            case Chat_room:
+                return QApplication::translate("shortcutsTab", "Chat Room");
+            case Game_window:
+                return QApplication::translate("shortcutsTab", "Game Window");
+            case Load_deck:
+                return QApplication::translate("shortcutsTab", "Load Deck from Clipboard");
+            case Replays:
+                return QApplication::translate("shortcutsTab", "Replays");
+            case Tabs:
+                return QApplication::translate("shortcutsTab", "Tabs");
+        }
+
+        return {};
+    }
+};
+
+class ShortcutKey : public QList<QKeySequence>
+{
+public:
+    explicit ShortcutKey(const QString &_name = QString(),
+                         QList _sequence = QList(),
+                         ShortcutGroup::Groups _group = ShortcutGroup::Main_Window);
+    void setSequence(const QList &_sequence)
+    {
+        QList::operator=(_sequence);
+    }
+    [[nodiscard]] QString getName() const
+    {
+        return QApplication::translate("shortcutsTab", name.toUtf8().data());
+    }
+    [[nodiscard]] QString getGroupName() const
+    {
+        return ShortcutGroup::getGroupName(group);
+    }
+
+private:
+    QString name;
+    ShortcutGroup::Groups group;
+};
+
+class ShortcutsSettings : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ShortcutsSettings(const QString &settingsFilePath, QObject *parent = nullptr);
+
+    [[nodiscard]] ShortcutKey getDefaultShortcut(const QString &name) const;
+    [[nodiscard]] ShortcutKey getShortcut(const QString &name) const;
+    [[nodiscard]] QKeySequence getSingleShortcut(const QString &name) const;
+    [[nodiscard]] QString getDefaultShortcutString(const QString &name) const;
+    [[nodiscard]] QString getShortcutString(const QString &name) const;
+    [[nodiscard]] QString getShortcutFriendlyName(const QString &shortcutName) const;
+    [[nodiscard]] QList<QString> getAllShortcutKeys() const
+    {
+        return shortCuts.keys();
+    }
+
+    void setShortcuts(const QString &name, const QList<QKeySequence> &Sequence);
+    void setShortcuts(const QString &name, const QKeySequence &Sequence);
+    void setShortcuts(const QString &name, const QString &sequences);
+
+    [[nodiscard]] bool isKeyAllowed(const QString &name, const QString &sequences) const;
+    [[nodiscard]] bool isValid(const QString &name, const QString &sequences) const;
+    [[nodiscard]] QStringList findOverlaps(const QString &name, const QString &sequences) const;
+
+    void resetAllShortcuts();
+    void clearAllShortcuts();
+    void migrateShortcuts();
+
+signals:
+    void shortCutChanged();
+
+private:
+    const QChar sep = ';';
+    const QString custom = "Custom"; // name of custom group in shortCutsFile
+    QString settingsFilePath;
+    QHash<QString, ShortcutKey> shortCuts;
+
+    [[nodiscard]] QString stringifySequence(const QList<QKeySequence> &Sequence) const;
+    [[nodiscard]] QList<QKeySequence> parseSequenceString(const QString &stringSequence) const;
+
+    const QHash<QString, ShortcutKey> defaultShortCuts = {
+        {"MainWindow/aCheckCardUpdates", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Check for Card Updates..."),
+                                                     parseSequenceString(""),
+                                                     ShortcutGroup::Main_Window)},
+        {"MainWindow/aConnect", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Connect..."),
+                                            parseSequenceString("Ctrl+L"),
+                                            ShortcutGroup::Main_Window)},
+        {"MainWindow/aDisconnect", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Disconnect"),
+                                               parseSequenceString(""),
+                                               ShortcutGroup::Main_Window)},
+        {"MainWindow/aExit",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exit"), parseSequenceString(""), ShortcutGroup::Main_Window)},
+        {"MainWindow/aFullScreen", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Full screen"),
+                                               parseSequenceString("Ctrl+F"),
+                                               ShortcutGroup::Main_Window)},
+        {"MainWindow/aRegister", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Register..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Main_Window)},
+        {"MainWindow/aSettings", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Settings..."),
+                                             parseSequenceString("Ctrl+Shift+P"),
+                                             ShortcutGroup::Main_Window)},
+        {"MainWindow/aSinglePlayer", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Start a Local Game..."),
+                                                 parseSequenceString("Ctrl+Shift+L"),
+                                                 ShortcutGroup::Main_Window)},
+        {"MainWindow/aWatchReplay", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Watch Replay..."),
+                                                parseSequenceString(""),
+                                                ShortcutGroup::Main_Window)},
+        {"MainWindow/aStatusBar", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Show Status Bar"),
+                                              parseSequenceString(""),
+                                              ShortcutGroup::Main_Window)},
+        {"TabDeckEditor/aAnalyzeDeck", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Analyze Deck (deckstats.net)"),
+                                                   parseSequenceString(""),
+                                                   ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aAnalyzeDeckTappedout",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Analyze Deck (tappedout.net)"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aClearFilterAll", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Clear All Filters"),
+                                                      parseSequenceString(""),
+                                                      ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aClearFilterOne", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Clear Selected Filter"),
+                                                      parseSequenceString(""),
+                                                      ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aClose",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Close"), parseSequenceString(""), ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aDecrement", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card"),
+                                                 parseSequenceString("-"),
+                                                 ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aManageSets", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Manage Sets..."),
+                                                  parseSequenceString(""),
+                                                  ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aEditTokens", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Edit Custom Tokens..."),
+                                                  parseSequenceString(""),
+                                                  ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aExportDeckDecklist",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Export Deck (decklist.org)"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aExportDeckDecklistXyz",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Export Deck (decklist.xyz)"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aIncrement", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card"),
+                                                 parseSequenceString("+"),
+                                                 ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aLoadDeck", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Deck..."),
+                                                parseSequenceString("Ctrl+O"),
+                                                ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aLoadDeckFromWebsite",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load deck from online service..."),
+                     parseSequenceString("Ctrl+Shift+O"),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aLoadDeckFromClipboard",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Deck from Clipboard..."),
+                     parseSequenceString("Ctrl+Shift+V"),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aEditDeckInClipboard",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Edit Deck in Clipboard, Annotated"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aEditDeckInClipboardRaw",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Edit Deck in Clipboard"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aNewDeck", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "New Deck"),
+                                               parseSequenceString("Ctrl+N"),
+                                               ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aOpenCustomFolder",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Open Custom Pictures Folder"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aPrintDeck", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Print Deck..."),
+                                                 parseSequenceString("Ctrl+P"),
+                                                 ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aRemoveCard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Delete Card"),
+                                                  parseSequenceString(""),
+                                                  ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aResetLayout", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reset Layout"),
+                                                   parseSequenceString(""),
+                                                   ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aSaveDeck", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Save Deck"),
+                                                parseSequenceString("Ctrl+S"),
+                                                ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aSaveDeckAs", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Save Deck as..."),
+                                                  parseSequenceString("Ctrl+Shift+S"),
+                                                  ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aSaveDeckToClipboard",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Save Deck to Clipboard, Annotated"),
+                     parseSequenceString("Ctrl+Shift+C"),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aSaveDeckToClipboardNoSetInfo",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Save Deck to Clipboard, Annotated (No Set Info)"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aSaveDeckToClipboardRaw",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Save Deck to Clipboard"),
+                     parseSequenceString("Ctrl+Shift+R"),
+                     ShortcutGroup::Deck_Editor)},
+        {"TabDeckEditor/aSaveDeckToClipboardRawNoSetInfo",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Save Deck to Clipboard (No Set Info)"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Deck_Editor)},
+        {"DeckViewContainer/loadLocalButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Local Deck..."),
+                                                          parseSequenceString("Ctrl+O"),
+                                                          ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/loadRemoteButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Remote Deck..."),
+                                                           parseSequenceString("Ctrl+Alt+O"),
+                                                           ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/loadFromClipboardButton",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Deck from Clipboard..."),
+                     parseSequenceString("Ctrl+Shift+V"),
+                     ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/loadFromWebsiteButton",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load from website..."),
+                     parseSequenceString("Ctrl+Shift+O"),
+                     ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/unloadDeckButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Unload Deck"),
+                                                           parseSequenceString("Ctrl+Alt+U"),
+                                                           ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/readyStartButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Ready to Start"),
+                                                           parseSequenceString("Ctrl+Shift+S"),
+                                                           ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/sideboardLockButton",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Toggle Sideboard Lock"),
+                     parseSequenceString("Ctrl+Shift+B"),
+                     ShortcutGroup::Game_Lobby)},
+        {"DeckViewContainer/forceStartGameButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Force Start"),
+                                                               parseSequenceString(""),
+                                                               ShortcutGroup::Game_Lobby)},
+        {"Player/aCCMagenta", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card Counter (F)"),
+                                          parseSequenceString(""),
+                                          ShortcutGroup::Card_Counters)},
+        {"Player/aRCMagenta", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card Counter (F)"),
+                                          parseSequenceString(""),
+                                          ShortcutGroup::Card_Counters)},
+        {"Player/aSCMagenta", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Card Counters (F)..."),
+                                          parseSequenceString(""),
+                                          ShortcutGroup::Card_Counters)},
+        {"Player/aCCPurple", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card Counter (E)"),
+                                         parseSequenceString(""),
+                                         ShortcutGroup::Card_Counters)},
+        {"Player/aRCPurple", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card Counter (E)"),
+                                         parseSequenceString(""),
+                                         ShortcutGroup::Card_Counters)},
+        {"Player/aSCPurple", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Card Counters (E)..."),
+                                         parseSequenceString(""),
+                                         ShortcutGroup::Card_Counters)},
+        {"Player/aCCCyan", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card Counter(D)"),
+                                       parseSequenceString(""),
+                                       ShortcutGroup::Card_Counters)},
+        {"Player/aRCCyan", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card Counter (D)"),
+                                       parseSequenceString(""),
+                                       ShortcutGroup::Card_Counters)},
+        {"Player/aSCCyan", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Card Counters (D)..."),
+                                       parseSequenceString(""),
+                                       ShortcutGroup::Card_Counters)},
+        {"Player/aCCGreen", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card Counter (C)"),
+                                        parseSequenceString("Ctrl+>"),
+                                        ShortcutGroup::Card_Counters)},
+        {"Player/aRCGreen", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card Counter (C)"),
+                                        parseSequenceString("Ctrl+<"),
+                                        ShortcutGroup::Card_Counters)},
+        {"Player/aSCGreen", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Card Counters (C)..."),
+                                        parseSequenceString("Ctrl+?"),
+                                        ShortcutGroup::Card_Counters)},
+        {"Player/aCCYellow", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card Counter (B)"),
+                                         parseSequenceString("Ctrl+."),
+                                         ShortcutGroup::Card_Counters)},
+        {"Player/aRCYellow", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card Counter (B)"),
+                                         parseSequenceString("Ctrl+,"),
+                                         ShortcutGroup::Card_Counters)},
+        {"Player/aSCYellow", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Card Counters (B)..."),
+                                         parseSequenceString("Ctrl+/"),
+                                         ShortcutGroup::Card_Counters)},
+        {"Player/aCCRed", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Card Counter (A)"),
+                                      parseSequenceString("Alt+."),
+                                      ShortcutGroup::Card_Counters)},
+        {"Player/aRCRed", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Card Counter (A)"),
+                                      parseSequenceString("Alt+,"),
+                                      ShortcutGroup::Card_Counters)},
+        {"Player/aSCRed", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Card Counters (A)..."),
+                                      parseSequenceString("Alt+/"),
+                                      ShortcutGroup::Card_Counters)},
+        {"Player/aInc", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Life Counter"),
+                                    parseSequenceString("F12"),
+                                    ShortcutGroup::Player_Counters)},
+        {"Player/aDec", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Life Counter"),
+                                    parseSequenceString("F11"),
+                                    ShortcutGroup::Player_Counters)},
+        {"Player/aSet", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Life Counters..."),
+                                    parseSequenceString("Ctrl+L"),
+                                    ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_w", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add White Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_w", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove White Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_w", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set White Counters..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_u", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Blue Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_u", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Blue Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_u", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Blue Counters..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_b", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Black Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_b", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Black Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_b", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Black Counters..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_r", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Red Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_r", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Red Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_r", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Red Counters..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_g", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Green Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_g", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Green Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_g", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Green Counters..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_x", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Colorless Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_x", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Colorless Counter"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_x", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Colorless Counters..."),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Player_Counters)},
+        {"Player/aIncCounter_storm", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Other Counter"),
+                                                 parseSequenceString("Ctrl+]"),
+                                                 ShortcutGroup::Player_Counters)},
+        {"Player/aDecCounter_storm", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Other Counter"),
+                                                 parseSequenceString("Ctrl+["),
+                                                 ShortcutGroup::Player_Counters)},
+        {"Player/aSetCounter_storm", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Other Counters..."),
+                                                 parseSequenceString("Ctrl+\\"),
+                                                 ShortcutGroup::Player_Counters)},
+        {"Player/aIncrementAllCardCounters",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Increment all card counters"),
+                     parseSequenceString("Ctrl+Shift+A"),
+                     ShortcutGroup::Playing_Area)},
+        {"Player/aIncP", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Power (+1/+0)"),
+                                     parseSequenceString("Ctrl++;Ctrl+="),
+                                     ShortcutGroup::Power_Toughness)},
+        {"Player/aDecP", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Power (-1/-0)"),
+                                     parseSequenceString("Ctrl+-"),
+                                     ShortcutGroup::Power_Toughness)},
+        {"Player/aFlowP", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Move Toughness to Power (+1/-1)"),
+                                      parseSequenceString(""),
+                                      ShortcutGroup::Power_Toughness)},
+        {"Player/aIncT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Toughness (+0/+1)"),
+                                     parseSequenceString("Alt++;Alt+="),
+                                     ShortcutGroup::Power_Toughness)},
+        {"Player/aDecT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Toughness (-0/-1)"),
+                                     parseSequenceString("Alt+-"),
+                                     ShortcutGroup::Power_Toughness)},
+        {"Player/aFlowT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Move Power to Toughness (-1/+1)"),
+                                      parseSequenceString(""),
+                                      ShortcutGroup::Power_Toughness)},
+        {"Player/aIncPT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Add Power and Toughness (+1/+1)"),
+                                      parseSequenceString("Ctrl+Alt++;Ctrl+Alt+="),
+                                      ShortcutGroup::Power_Toughness)},
+        {"Player/aDecPT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Power and Toughness (-1/-1)"),
+                                      parseSequenceString("Ctrl+Alt+-"),
+                                      ShortcutGroup::Power_Toughness)},
+        {"Player/aSetPT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Power and Toughness..."),
+                                      parseSequenceString("Ctrl+P"),
+                                      ShortcutGroup::Power_Toughness)},
+        {"Player/aResetPT", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reset Power and Toughness"),
+                                        parseSequenceString("Ctrl+Alt+0"),
+                                        ShortcutGroup::Power_Toughness)},
+        {"Player/phase0", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Untap"),
+                                      parseSequenceString("F5"),
+                                      ShortcutGroup::Game_Phases)},
+        {"Player/phase1",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Upkeep"), parseSequenceString(""), ShortcutGroup::Game_Phases)},
+        {"Player/phase2",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Draw"), parseSequenceString("F6"), ShortcutGroup::Game_Phases)},
+        {"Player/phase3", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "First Main Phase"),
+                                      parseSequenceString("F7"),
+                                      ShortcutGroup::Game_Phases)},
+        {"Player/phase4", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Start Combat"),
+                                      parseSequenceString("F8"),
+                                      ShortcutGroup::Game_Phases)},
+        {"Player/phase5",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Attack"), parseSequenceString(""), ShortcutGroup::Game_Phases)},
+        {"Player/phase6",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Block"), parseSequenceString(""), ShortcutGroup::Game_Phases)},
+        {"Player/phase7",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Damage"), parseSequenceString(""), ShortcutGroup::Game_Phases)},
+        {"Player/phase8", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "End Combat"),
+                                      parseSequenceString(""),
+                                      ShortcutGroup::Game_Phases)},
+        {"Player/phase9", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Second Main Phase"),
+                                      parseSequenceString("F9"),
+                                      ShortcutGroup::Game_Phases)},
+        {"Player/phase10",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "End"), parseSequenceString("F10"), ShortcutGroup::Game_Phases)},
+        {"Player/aNextPhase", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Next Phase"),
+                                          parseSequenceString("Ctrl+Space;Tab"),
+                                          ShortcutGroup::Game_Phases)},
+        {"Player/aNextPhaseAction", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Next Phase Action"),
+                                                parseSequenceString("Shift+Tab"),
+                                                ShortcutGroup::Game_Phases)},
+        {"Player/aNextTurn", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Next Turn"),
+                                         parseSequenceString("Ctrl+Return;Ctrl+Enter"),
+                                         ShortcutGroup::Game_Phases)},
+        {"Player/aHide", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Hide Card in Reveal Window"),
+                                     parseSequenceString("Alt+H"),
+                                     ShortcutGroup::Playing_Area)},
+        {"Player/aTap", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Tap / Untap Card"),
+                                    parseSequenceString(""),
+                                    ShortcutGroup::Playing_Area)},
+        {"Player/aUntapAll", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Untap All"),
+                                         parseSequenceString("Ctrl+U"),
+                                         ShortcutGroup::Playing_Area)},
+        {"Player/aDoesntUntap", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Toggle Skip Untapping"),
+                                            parseSequenceString("Alt+U"),
+                                            ShortcutGroup::Playing_Area)},
+        {"Player/aFlip", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Turn Card Over"),
+                                     parseSequenceString("Alt+F"),
+                                     ShortcutGroup::Playing_Area)},
+        {"Player/aPeek", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Peek Card"),
+                                     parseSequenceString("Alt+L"),
+                                     ShortcutGroup::Playing_Area)},
+        {"Player/aPlay", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Play Card"),
+                                     parseSequenceString(""),
+                                     ShortcutGroup::Playing_Area)},
+        {"Player/aPlayFacedown", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Play Card, Face Down"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Playing_Area)},
+        {"Player/aAttach", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Attach Card..."),
+                                       parseSequenceString("Ctrl+Alt+A"),
+                                       ShortcutGroup::Playing_Area)},
+        {"Player/aUnattach", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Unattach Card"),
+                                         parseSequenceString("Ctrl+Alt+U"),
+                                         ShortcutGroup::Playing_Area)},
+        {"Player/aClone", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Clone Card"),
+                                      parseSequenceString("Ctrl+J"),
+                                      ShortcutGroup::Playing_Area)},
+        {"Player/aCreateToken", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Create Token..."),
+                                            parseSequenceString("Ctrl+T"),
+                                            ShortcutGroup::Playing_Area)},
+        {"Player/aCreateRelatedTokens", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Create All Related Tokens"),
+                                                    parseSequenceString("Ctrl+Shift+T"),
+                                                    ShortcutGroup::Playing_Area)},
+        {"Player/aCreateAnotherToken", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Create Another Token"),
+                                                   parseSequenceString("Ctrl+G"),
+                                                   ShortcutGroup::Playing_Area)},
+        {"Player/aSetAnnotation", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Set Annotation..."),
+                                              parseSequenceString("Alt+N"),
+                                              ShortcutGroup::Playing_Area)},
+        {"Player/aReduceLifeByPower", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reduce Life by Power"),
+                                                  parseSequenceString("Ctrl+Shift+L"),
+                                                  ShortcutGroup::Playing_Area)},
+        {"Player/aSelectAll", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Select All Cards in Zone"),
+                                          parseSequenceString("Ctrl+A"),
+                                          ShortcutGroup::Playing_Area)},
+        {"Player/aSelectRow", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Select All Cards in Row"),
+                                          parseSequenceString("Ctrl+Shift+X"),
+                                          ShortcutGroup::Playing_Area)},
+        {"Player/aSelectColumn", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Select All Cards in Column"),
+                                             parseSequenceString("Ctrl+Shift+C"),
+                                             ShortcutGroup::Playing_Area)},
+        {"Player/aRevealToAll", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reveal Selected Cards to All Players"),
+                                            parseSequenceString(""),
+                                            ShortcutGroup::Playing_Area)},
+        {"Player/aMoveToBottomLibrary", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Bottom of Library"),
+                                                    parseSequenceString("Ctrl+B"),
+                                                    ShortcutGroup::Move_selected)},
+        {"Player/aMoveToExile", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile"),
+                                            parseSequenceString(""),
+                                            ShortcutGroup::Move_selected)},
+        {"Player/aMoveToGraveyard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard"),
+                                                parseSequenceString("Ctrl+Del"),
+                                                ShortcutGroup::Move_selected)},
+        {"Player/aMoveToHand",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Hand"), parseSequenceString(""), ShortcutGroup::Move_selected)},
+        {"Player/aMoveToTopLibrary", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Top of Library"),
+                                                 parseSequenceString(""),
+                                                 ShortcutGroup::Move_selected)},
+        {"Player/aMoveToTable", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Battlefield"),
+                                            parseSequenceString(""),
+                                            ShortcutGroup::Move_selected)},
+        {"Player/aViewHand",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Hand"), parseSequenceString(""), ShortcutGroup::View)},
+        {"Player/aViewGraveyard",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard"), parseSequenceString("F4"), ShortcutGroup::View)},
+        {"Player/aViewLibrary",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Library"), parseSequenceString("F3"), ShortcutGroup::View)},
+        {"Player/aViewRfg",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile"), parseSequenceString(""), ShortcutGroup::View)},
+        {"Player/aViewSideboard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Sideboard"),
+                                              parseSequenceString("Ctrl+F3"),
+                                              ShortcutGroup::View)},
+        {"Player/aViewTopCards", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Top Cards of Library"),
+                                             parseSequenceString("Ctrl+W"),
+                                             ShortcutGroup::View)},
+        {"Player/aViewBottomCards", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Bottom Cards of Library"),
+                                                parseSequenceString("Ctrl+Shift+W"),
+                                                ShortcutGroup::View)},
+        {"Player/aCloseMostRecentZoneView", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Close Recent View"),
+                                                        parseSequenceString("Esc"),
+                                                        ShortcutGroup::View)},
+        {"Player/aMoveTopToPlay", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Stack"),
+                                              parseSequenceString("Ctrl+Y"),
+                                              ShortcutGroup::Move_top)},
+        {"Player/aMoveTopToPlayFaceDown", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Battlefield, Face Down"),
+                                                      parseSequenceString("Ctrl+Shift+E"),
+                                                      ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardToGraveyard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard"),
+                                                       parseSequenceString("Alt+Y"),
+                                                       ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardsToGraveyard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard (Multiple)"),
+                                                        parseSequenceString("Alt+M"),
+                                                        ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardsToGraveyardFaceDown",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard (Multiple), Face Down"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardToExile",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile"), parseSequenceString(""), ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardsToExile", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile (Multiple)"),
+                                                    parseSequenceString(""),
+                                                    ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardsToExileFaceDown",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile (Multiple), Face Down"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardsUntil", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Stack Until Found"),
+                                                  parseSequenceString("Ctrl+Shift+Y"),
+                                                  ShortcutGroup::Move_top)},
+        {"Player/aMoveTopCardToBottom", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Bottom of Library"),
+                                                    parseSequenceString(""),
+                                                    ShortcutGroup::Move_top)},
+        {"Player/aMoveBottomToPlay",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Stack"), parseSequenceString(""), ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomToPlayFaceDown", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Battlefield, Face Down"),
+                                                         parseSequenceString(""),
+                                                         ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardToGrave", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard"),
+                                                      parseSequenceString(""),
+                                                      ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardsToGrave", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard (Multiple)"),
+                                                       parseSequenceString(""),
+                                                       ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardsToGraveFaceDown",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Graveyard (Multiple), Face Down"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardToExile",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile"), parseSequenceString(""), ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardsToExile", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile (Multiple)"),
+                                                       parseSequenceString(""),
+                                                       ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardsToExileFaceDown",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Exile (Multiple), Face Down"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Move_bottom)},
+        {"Player/aMoveBottomCardToTop", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Top of Library"),
+                                                    parseSequenceString(""),
+                                                    ShortcutGroup::Move_bottom)},
+        {"Player/aDrawBottomCard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Draw Bottom Card"),
+                                               parseSequenceString(""),
+                                               ShortcutGroup::Move_bottom)},
+        {"Player/aDrawBottomCards", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Draw Multiple Cards from Bottom..."),
+                                                parseSequenceString(""),
+                                                ShortcutGroup::Move_bottom)},
+        {"Player/aDrawArrow", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Draw Arrow..."),
+                                          parseSequenceString("Alt+A"),
+                                          ShortcutGroup::Gameplay)},
+        {"Player/aRemoveLocalArrows", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Remove Local Arrows"),
+                                                  parseSequenceString("Ctrl+R"),
+                                                  ShortcutGroup::Gameplay)},
+        {"Player/aLeaveGame", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Leave Game"),
+                                          parseSequenceString("Ctrl+Q"),
+                                          ShortcutGroup::Gameplay)},
+        {"Player/aConcede",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Concede"), parseSequenceString("F2"), ShortcutGroup::Gameplay)},
+        {"Player/aRollDie", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Roll Dice..."),
+                                        parseSequenceString("Ctrl+I"),
+                                        ShortcutGroup::Gameplay)},
+        {"Player/aFlipCoin", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Flip Coin"),
+                                         parseSequenceString("Ctrl+Shift+I"),
+                                         ShortcutGroup::Gameplay)},
+        {"Player/aShuffle", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Shuffle Library"),
+                                        parseSequenceString("Ctrl+S"),
+                                        ShortcutGroup::Gameplay)},
+        {"Player/aShuffleTopCards", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Shuffle Top Cards of Library"),
+                                                parseSequenceString(""),
+                                                ShortcutGroup::Gameplay)},
+        {"Player/aShuffleBottomCards", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Shuffle Bottom Cards of Library"),
+                                                   parseSequenceString(""),
+                                                   ShortcutGroup::Gameplay)},
+        {"Player/aMulligan", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Mulligan"),
+                                         parseSequenceString("Ctrl+M"),
+                                         ShortcutGroup::Drawing)},
+        {"Player/aMulliganSame", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Mulligan (Same hand size)"),
+                                             parseSequenceString("Ctrl+Shift+M"),
+                                             ShortcutGroup::Drawing)},
+        {"Player/aMulliganMinusOne", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Mulligan (Hand size - 1)"),
+                                                 parseSequenceString("Ctrl+Shift+Alt+M"),
+                                                 ShortcutGroup::Drawing)},
+        {"Player/aDrawCard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Draw a Card"),
+                                         parseSequenceString("Ctrl+D"),
+                                         ShortcutGroup::Drawing)},
+        {"Player/aDrawCards", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Draw Multiple Cards..."),
+                                          parseSequenceString("Ctrl+E"),
+                                          ShortcutGroup::Drawing)},
+        {"Player/aUndoDraw", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Undo Draw"),
+                                         parseSequenceString("Ctrl+Shift+D"),
+                                         ShortcutGroup::Drawing)},
+        {"Player/aAlwaysRevealTopCard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Always Reveal Top Card"),
+                                                    parseSequenceString("Ctrl+N"),
+                                                    ShortcutGroup::Drawing)},
+        {"Player/aAlwaysLookAtTopCard", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Always Look At Top Card"),
+                                                    parseSequenceString("Ctrl+Shift+N"),
+                                                    ShortcutGroup::Drawing)},
+        {"Player/aSortHandByName", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Sort Hand by Name"),
+                                               parseSequenceString(""),
+                                               ShortcutGroup::Hand)},
+        {"Player/aSortHandByType", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Sort Hand by Type"),
+                                               parseSequenceString("Ctrl+Shift+H"),
+                                               ShortcutGroup::Hand)},
+        {"Player/aSortHandByManaValue", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Sort Hand by Mana Value"),
+                                                    parseSequenceString(""),
+                                                    ShortcutGroup::Hand)},
+        {"Player/aRevealHandToAll", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reveal Hand to All Players"),
+                                                parseSequenceString(""),
+                                                ShortcutGroup::Hand)},
+        {"Player/aRevealRandomHandCardToAll",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reveal Random Card to All Players"),
+                     parseSequenceString(""),
+                     ShortcutGroup::Hand)},
+        {"Player/aRotateViewCW", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Rotate View Clockwise"),
+                                             parseSequenceString(""),
+                                             ShortcutGroup::Gameplay)},
+        {"Player/aRotateViewCCW", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Rotate View Counterclockwise"),
+                                              parseSequenceString(""),
+                                              ShortcutGroup::Gameplay)},
+        {"Player/unfocusTextBox", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Unfocus Text Box"),
+                                              parseSequenceString("Esc"),
+                                              ShortcutGroup::Chat_room)},
+        {"Player/aFocusChat", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Focus Chat"),
+                                          parseSequenceString("Shift+Return"),
+                                          ShortcutGroup::Chat_room)},
+        {"tab_room/aClearChat", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Clear Chat"),
+                                            parseSequenceString("F12"),
+                                            ShortcutGroup::Chat_room)},
+        {"Player/aResetLayout", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Reset Layout"),
+                                            parseSequenceString(""),
+                                            ShortcutGroup::Game_window)},
+        {"DlgLoadDeckFromClipboard/refreshButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Refresh"),
+                                                               parseSequenceString("F5"),
+                                                               ShortcutGroup::Load_deck)},
+        {"Replays/aSkipForward", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Skip Forward"),
+                                             parseSequenceString("Right"),
+                                             ShortcutGroup::Replays)},
+        {"Replays/aSkipBackward", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Skip Backward"),
+                                              parseSequenceString("Left"),
+                                              ShortcutGroup::Replays)},
+        {"Replays/aSkipForwardBig", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Skip Forward by a lot"),
+                                                parseSequenceString("Ctrl+Right"),
+                                                ShortcutGroup::Replays)},
+        {"Replays/aSkipBackwardBig", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Skip Backward by a lot"),
+                                                 parseSequenceString("Ctrl+Left"),
+                                                 ShortcutGroup::Replays)},
+        {"Replays/playButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Play/Pause"),
+                                           parseSequenceString("Space"),
+                                           ShortcutGroup::Replays)},
+        {"Replays/fastForwardButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Toggle Fast Forward"),
+                                                  parseSequenceString("Ctrl+P"),
+                                                  ShortcutGroup::Replays)},
+        {"Tabs/aTabDeckEditor",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Deck Editor"), parseSequenceString(""), ShortcutGroup::Tabs)},
+        {"Tabs/aTabHome",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Home"), parseSequenceString(""), ShortcutGroup::Tabs)},
+        {"Tabs/aTabVisualDeckStorage", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Visual Deck Storage"),
+                                                   parseSequenceString(""),
+                                                   ShortcutGroup::Tabs)},
+        {"Tabs/aTabDeckStorage",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Deck Storage"), parseSequenceString(""), ShortcutGroup::Tabs)},
+        {"Tabs/aTabReplays",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Replays"), parseSequenceString(""), ShortcutGroup::Tabs)},
+        {"Tabs/aTabServer",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Server"), parseSequenceString(""), ShortcutGroup::Tabs)},
+        {"Tabs/aTabAccount",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Account"), parseSequenceString(""), ShortcutGroup::Tabs)},
+        {"Tabs/aTabAdmin", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Administration"),
+                                       parseSequenceString(""),
+                                       ShortcutGroup::Tabs)},
+        {"Tabs/aTabLogs",
+         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Logs"), parseSequenceString(""), ShortcutGroup::Tabs)},
+    };
+};
+
+#endif // SHORTCUTSSETTINGS_H

C++/cockatrice/src/client/sound_engine.cpp

@@ -0,0 +1,168 @@
+#include "sound_engine.h"
+
+#include "settings/cache_settings.h"
+
+#include <QDir>
+#include <QMediaPlayer>
+
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+#include <QAudioOutput>
+#endif
+
+#define DEFAULT_THEME_NAME "Default"
+#define TEST_SOUND_FILENAME "player_join"
+
+SoundEngine::SoundEngine(QObject *parent) : QObject(parent), audioOutput(nullptr), player(nullptr)
+{
+    ensureThemeDirectoryExists();
+    connect(&SettingsCache::instance(), &SettingsCache::soundThemeChanged, this, &SoundEngine::themeChangedSlot);
+    connect(&SettingsCache::instance(), &SettingsCache::soundEnabledChanged, this, &SoundEngine::soundEnabledChanged);
+
+    soundEnabledChanged();
+    themeChangedSlot();
+}
+
+SoundEngine::~SoundEngine()
+{
+    if (player) {
+        player->deleteLater();
+        player = nullptr;
+    }
+    if (audioOutput) {
+        audioOutput->deleteLater();
+        audioOutput = nullptr;
+    }
+}
+
+void SoundEngine::soundEnabledChanged()
+{
+    if (SettingsCache::instance().getSoundEnabled()) {
+        qCInfo(SoundEngineLog) << "SoundEngine: enabling sound with" << audioData.size() << "sounds";
+        if (!player) {
+            player = new QMediaPlayer;
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+            audioOutput = new QAudioOutput(player);
+            player->setAudioOutput(audioOutput);
+#endif
+        }
+    } else {
+        qCInfo(SoundEngineLog) << "SoundEngine: disabling sound";
+        if (player) {
+            player->stop();
+            player->deleteLater();
+            player = nullptr;
+        }
+        if (audioOutput) {
+            audioOutput->deleteLater();
+            audioOutput = nullptr;
+        }
+    }
+}
+
+void SoundEngine::playSound(const QString &fileName)
+{
+    if (!player) {
+        return;
+    }
+
+    if (!audioData.contains(fileName)) {
+        return;
+    }
+
+    player->stop();
+    int volumeSliderValue = SettingsCache::instance().getMasterVolume();
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+    player->audioOutput()->setVolume(qreal(volumeSliderValue) / 100);
+    player->setSource(QUrl::fromLocalFile(audioData[fileName]));
+#else
+    player->setVolume(volumeSliderValue);
+    player->setMedia(QUrl::fromLocalFile(audioData[fileName]));
+#endif
+    player->play();
+}
+
+void SoundEngine::testSound()
+{
+    playSound(TEST_SOUND_FILENAME);
+}
+
+void SoundEngine::ensureThemeDirectoryExists()
+{
+    if (SettingsCache::instance().getSoundThemeName().isEmpty() ||
+        !getAvailableThemes().contains(SettingsCache::instance().getSoundThemeName())) {
+        qCInfo(SoundEngineLog) << "Sounds theme name not set, setting default value";
+        SettingsCache::instance().setSoundThemeName(DEFAULT_THEME_NAME);
+    }
+}
+
+QStringMap &SoundEngine::getAvailableThemes()
+{
+    QDir dir;
+    availableThemes.clear();
+
+    // load themes from user profile dir
+
+    dir.setPath(SettingsCache::instance().getDataPath() + "/sounds");
+
+    for (const QString &themeName : dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot, QDir::Name)) {
+        if (!availableThemes.contains(themeName)) {
+            availableThemes.insert(themeName, dir.absoluteFilePath(themeName));
+        }
+    }
+
+    // load themes from cockatrice system dir
+    dir.setPath(qApp->applicationDirPath() +
+#ifdef Q_OS_MAC
+                "/../Resources/sounds"
+#elif defined(Q_OS_WIN)
+                "/sounds"
+#else // linux
+                "/../share/cockatrice/sounds"
+#endif
+    );
+
+    for (const QString &themeName : dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot, QDir::Name)) {
+        if (!availableThemes.contains(themeName)) {
+            availableThemes.insert(themeName, dir.absoluteFilePath(themeName));
+        }
+    }
+
+    return availableThemes;
+}
+
+void SoundEngine::themeChangedSlot()
+{
+    QString themeName = SettingsCache::instance().getSoundThemeName();
+    qCInfo(SoundEngineLog) << "Sound theme changed:" << themeName;
+
+    QDir dir = getAvailableThemes().value(themeName);
+
+    audioData.clear();
+
+    static const QStringList extensions = {".wav", ".mp3", ".ogg"};
+    static const QStringList fileNames = {
+        // Phases
+        "untap_step", "upkeep_step", "draw_step", "main_1", "start_combat", "attack_step", "block_step", "damage_step",
+        "end_combat", "main_2", "end_step",
+        // Game Actions
+        "draw_card", "play_card", "tap_card", "untap_card", "shuffle", "roll_dice", "life_change",
+        // Player
+        "player_join", "player_leave", "player_disconnect", "player_reconnect", "player_concede",
+        // Spectator
+        "spectator_join", "spectator_leave",
+        // Buddy
+        "buddy_join", "buddy_leave",
+        // Chat & UI
+        "chat_mention", "all_mention", "private_message"};
+
+    for (const QString &extension : extensions) {
+        for (const QString &name : fileNames) {
+            QFile file(dir.filePath(name + extension));
+            if (file.exists()) {
+                audioData.insert(name, file.fileName());
+            }
+        }
+    }
+
+    soundEnabledChanged();
+}

C++/cockatrice/src/client/sound_engine.h

@@ -0,0 +1,48 @@
+/**
+ * @file sound_engine.h
+ * @ingroup Core
+ */
+//! \todo Document this file.
+
+#ifndef SOUNDENGINE_H
+#define SOUNDENGINE_H
+
+#include <QAudioOutput>
+#include <QLoggingCategory>
+#include <QMap>
+#include <QMediaPlayer>
+#include <QObject>
+#include <QString>
+
+inline Q_LOGGING_CATEGORY(SoundEngineLog, "sound_engine");
+
+class QBuffer;
+
+typedef QMap<QString, QString> QStringMap;
+
+class SoundEngine : public QObject
+{
+    Q_OBJECT
+public:
+    explicit SoundEngine(QObject *parent = nullptr);
+    ~SoundEngine() override;
+    void playSound(const QString &fileName);
+    QStringMap &getAvailableThemes();
+
+private:
+    QStringMap availableThemes;
+    QMap<QString, QString> audioData;
+    QAudioOutput *audioOutput;
+    QMediaPlayer *player;
+
+protected:
+    void ensureThemeDirectoryExists();
+private slots:
+    void soundEnabledChanged();
+    void themeChangedSlot();
+public slots:
+    void testSound();
+};
+
+extern SoundEngine *soundEngine;
+#endif

C++/cockatrice/src/client/translation.h

@@ -0,0 +1,13 @@
+#ifndef TRANSLATION_H
+#define TRANSLATION_H
+
+enum GrammaticalCase
+{
+    CaseNominative,
+    CaseLookAtZone,
+    CaseTopCardsOfZone,
+    CaseRevealZone,
+    CaseShuffleZone
+};
+
+#endif

C++/cockatrice/src/database/interface/settings_card_preference_provider.h

@@ -0,0 +1,21 @@
+#ifndef COCKATRICE_SETTINGS_CARD_PREFERENCE_PROVIDER_H
+#define COCKATRICE_SETTINGS_CARD_PREFERENCE_PROVIDER_H
+#include "../../client/settings/cache_settings.h"
+
+#include <libcockatrice/interfaces/interface_card_preference_provider.h>
+
+class SettingsCardPreferenceProvider : public ICardPreferenceProvider
+{
+public:
+    [[nodiscard]] QString getCardPreferenceOverride(const QString &cardName) const override
+    {
+        return SettingsCache::instance().cardOverrides().getCardPreferenceOverride(cardName);
+    }
+
+    [[nodiscard]] bool getIncludeRebalancedCards() const override
+    {
+        return SettingsCache::instance().getIncludeRebalancedCards();
+    }
+};
+
+#endif // COCKATRICE_SETTINGS_CARD_PREFERENCE_PROVIDER_H

C++/cockatrice/src/filters/deck_filter_string.cpp

@@ -0,0 +1,220 @@
+#include "deck_filter_string.h"
+
+#include <QFileInfo>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <libcockatrice/filters/filter_string.h>
+#include <libcockatrice/utility/peglib.h>
+
+static peg::parser search(R"(
+Start <- QueryPartList
+~ws <- [ ]+
+QueryPartList <- ComplexQueryPart ( ws ("AND" ws)? ComplexQueryPart)* ws*
+
+ComplexQueryPart <- SomewhatComplexQueryPart ws "OR" ws ComplexQueryPart / SomewhatComplexQueryPart
+SomewhatComplexQueryPart <- [(] QueryPartList [)] / QueryPart
+
+QueryPart <- NotQuery / DeckContentQuery / DeckNameQuery / FileNameQuery / PathQuery / FormatQuery / CommentQuery / GenericQuery
+
+NotQuery <- ('NOT' ws/'-') SomewhatComplexQueryPart
+
+DeckContentQuery <- CardSearch NumericExpression?
+CardSearch <- '[[' CardFilterString ']]'
+CardFilterString <- (!']]'.)*
+
+DeckNameQuery <- ([Dd] 'eck')? [Nn] 'ame'? [:] String
+FileNameQuery <- [Ff] ([Nn] / 'ile' ([Nn] 'ame')?) [:] String
+PathQuery <- [Pp] 'ath'? [:] String
+FormatQuery <- [Ff] 'ormat'? [:] String
+CommentQuery <- [Cc] ('omment' 's'?)? [:] String
+
+GenericQuery <- String
+
+NonDoubleQuoteUnlessEscaped <- '\\\"'. / !["].
+NonSingleQuoteUnlessEscaped <- "\\\'". / !['].
+UnescapedStringListPart <- !['":<>()=! ].
+SingleApostropheString <- (UnescapedStringListPart+ ws*)* ['] (UnescapedStringListPart+ ws*)*
+
+String <- SingleApostropheString / UnescapedStringListPart+ / ["] <NonDoubleQuoteUnlessEscaped*> ["] / ['] <NonSingleQuoteUnlessEscaped*> [']
+
+NumericExpression <- NumericOperator ws? NumericValue
+NumericOperator <- [=:] / <[><!][=]?>
+NumericValue <- [0-9]+
+)");
+
+static std::once_flag init;
+
+static void setupParserRules()
+{
+    // plumbing
+    auto passthru = [](const peg::SemanticValues &sv) -> DeckFilter {
+        return !sv.empty() ? std::any_cast<DeckFilter>(sv[0]) : nullptr;
+    };
+
+    search["Start"] = passthru;
+    search["QueryPartList"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &info) {
+            auto matchesFilter = [&deck, &info](const std::any &query) {
+                return std::any_cast<DeckFilter>(query)(deck, info);
+            };
+            return std::all_of(sv.begin(), sv.end(), matchesFilter);
+        };
+    };
+    search["ComplexQueryPart"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &info) {
+            auto matchesFilter = [&deck, &info](const std::any &query) {
+                return std::any_cast<DeckFilter>(query)(deck, info);
+            };
+            return std::any_of(sv.begin(), sv.end(), matchesFilter);
+        };
+    };
+    search["SomewhatComplexQueryPart"] = passthru;
+    search["QueryPart"] = passthru;
+    search["NotQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        const auto dependent = std::any_cast<DeckFilter>(sv[0]);
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &info) -> bool {
+            return !dependent(deck, info);
+        };
+    };
+
+    search["String"] = [](const peg::SemanticValues &sv) -> QString {
+        if (sv.choice() == 0) {
+            return QString::fromStdString(std::string(sv.sv()));
+        }
+
+        return QString::fromStdString(std::string(sv.token(0)));
+    };
+
+    search["NumericExpression"] = [](const peg::SemanticValues &sv) -> NumberMatcher {
+        const auto arg = std::any_cast<int>(sv[1]);
+        const auto op = std::any_cast<QString>(sv[0]);
+
+        if (op == ">") {
+            return [=](const int s) { return s > arg; };
+        }
+        if (op == ">=") {
+            return [=](const int s) { return s >= arg; };
+        }
+        if (op == "<") {
+            return [=](const int s) { return s < arg; };
+        }
+        if (op == "<=") {
+            return [=](const int s) { return s <= arg; };
+        }
+        if (op == "=") {
+            return [=](const int s) { return s == arg; };
+        }
+        if (op == ":") {
+            return [=](const int s) { return s == arg; };
+        }
+        if (op == "!=") {
+            return [=](const int s) { return s != arg; };
+        }
+        return [](int) { return false; };
+    };
+
+    search["NumericValue"] = [](const peg::SemanticValues &sv) -> int {
+        return QString::fromStdString(std::string(sv.sv())).toInt();
+    };
+
+    search["NumericOperator"] = [](const peg::SemanticValues &sv) -> QString {
+        return QString::fromStdString(std::string(sv.sv()));
+    };
+
+    // actual functionality
+    search["DeckContentQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto cardFilter = FilterString(std::any_cast<QString>(sv[0]));
+        auto numberMatcher = sv.size() > 1 ? std::any_cast<NumberMatcher>(sv[1]) : [](int count) { return count > 0; };
+
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &) -> bool {
+            int count = 0;
+            auto cardNodes = deck->deckLoader->getDeck().deckList.getCardNodes();
+            for (auto node : cardNodes) {
+                auto cardInfoPtr = CardDatabaseManager::query()->getCardInfo(node->getName());
+                if (!cardInfoPtr.isNull() && cardFilter.check(cardInfoPtr)) {
+                    count += node->getNumber();
+                }
+            }
+            return numberMatcher(count);
+        };
+    };
+
+    search["CardSearch"] = [](const peg::SemanticValues &sv) -> QString { return std::any_cast<QString>(sv[0]); };
+
+    search["CardFilterString"] = [](const peg::SemanticValues &sv) -> QString {
+        return QString::fromStdString(std::string(sv.sv()));
+    };
+
+    search["DeckNameQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto name = std::any_cast<QString>(sv[0]);
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &) {
+            return deck->deckLoader->getDeck().deckList.getName().contains(name, Qt::CaseInsensitive);
+        };
+    };
+
+    search["FileNameQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto name = std::any_cast<QString>(sv[0]);
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &) {
+            auto filename = QFileInfo(deck->filePath).fileName();
+            return filename.contains(name, Qt::CaseInsensitive);
+        };
+    };
+
+    search["PathQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto name = std::any_cast<QString>(sv[0]);
+        return [=](const DeckPreviewWidget *, const ExtraDeckSearchInfo &info) {
+            return info.relativeFilePath.contains(name, Qt::CaseInsensitive);
+        };
+    };
+
+    search["FormatQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto format = std::any_cast<QString>(sv[0]);
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &) {
+            auto gameFormat = deck->deckLoader->getDeck().deckList.getGameFormat();
+            return QString::compare(format, gameFormat, Qt::CaseInsensitive) == 0;
+        };
+    };
+
+    search["CommentQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto value = std::any_cast<QString>(sv[0]);
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &) {
+            auto comments = deck->deckLoader->getDeck().deckList.getComments();
+            return comments.contains(value, Qt::CaseInsensitive);
+        };
+    };
+
+    search["GenericQuery"] = [](const peg::SemanticValues &sv) -> DeckFilter {
+        auto name = std::any_cast<QString>(sv[0]);
+        return [=](const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &) {
+            return deck->getDisplayName().contains(name, Qt::CaseInsensitive);
+        };
+    };
+}
+
+DeckFilterString::DeckFilterString()
+{
+    filter = [](const DeckPreviewWidget *, const ExtraDeckSearchInfo &) { return false; };
+    _error = "Not initialized";
+}
+
+DeckFilterString::DeckFilterString(const QString &expr)
+{
+    QByteArray ba = expr.simplified().toUtf8();
+
+    std::call_once(init, setupParserRules);
+
+    _error = QString();
+
+    if (ba.isEmpty()) {
+        filter = [](const DeckPreviewWidget *, const ExtraDeckSearchInfo &) { return true; };
+        return;
+    }
+
+    search.set_logger([&](size_t /*ln*/, size_t col, const std::string &msg) {
+        _error = QString("Error at position %1: %2").arg(col).arg(QString::fromStdString(msg));
+    });
+
+    if (!search.parse(ba.data(), filter)) {
+        qCInfo(DeckFilterStringLog).nospace() << "DeckFilterString error for " << expr << "; " << qPrintable(_error);
+        filter = [](const DeckPreviewWidget *, const ExtraDeckSearchInfo &) { return false; };
+    }
+}

C++/cockatrice/src/filters/deck_filter_string.h

@@ -0,0 +1,55 @@
+/**
+ * @file deck_filter_string.h
+ * @ingroup DeckStorageWidgets
+ */
+//! \todo Document this file.
+
+#ifndef DECK_FILTER_STRING_H
+#define DECK_FILTER_STRING_H
+
+#include "../interface/widgets/visual_deck_storage/deck_preview/deck_preview_widget.h"
+
+#include <QLoggingCategory>
+#include <QString>
+#include <functional>
+
+inline Q_LOGGING_CATEGORY(DeckFilterStringLog, "deck_filter_string");
+
+/**
+ * Extra info relevant to filtering that isn't present in the DeckPreviewWidget
+ */
+struct ExtraDeckSearchInfo
+{
+    /**
+     * The relative filepath starting from the deck folder
+     */
+    QString relativeFilePath;
+};
+
+typedef std::function<bool(const DeckPreviewWidget *, const ExtraDeckSearchInfo &)> DeckFilter;
+
+class DeckFilterString
+{
+public:
+    DeckFilterString();
+    explicit DeckFilterString(const QString &expr);
+    bool check(const DeckPreviewWidget *deck, const ExtraDeckSearchInfo &info) const
+    {
+        return filter(deck, info);
+    }
+
+    [[nodiscard]] bool valid() const
+    {
+        return _error.isEmpty();
+    }
+
+    QString error()
+    {
+        return _error;
+    }
+
+private:
+    QString _error;
+    DeckFilter filter;
+};
+#endif // DECK_FILTER_STRING_H

C++/cockatrice/src/filters/filter_builder.cpp

@@ -0,0 +1,82 @@
+#include "filter_builder.h"
+
+#include "../interface/widgets/utility/custom_line_edit.h"
+
+#include <QComboBox>
+#include <QGridLayout>
+#include <QPushButton>
+#include <libcockatrice/filters/filter_card.h>
+
+FilterBuilder::FilterBuilder(QWidget *parent) : QWidget(parent)
+{
+    filterCombo = new QComboBox;
+    filterCombo->setObjectName("filterCombo");
+    for (int i = 0; i < CardFilter::AttrEnd; i++) {
+        filterCombo->addItem(CardFilter::attrName(static_cast<CardFilter::Attr>(i)), QVariant(i));
+    }
+
+    typeCombo = new QComboBox;
+    typeCombo->setObjectName("typeCombo");
+    for (int i = 0; i < CardFilter::TypeEnd; i++) {
+        typeCombo->addItem(CardFilter::typeName(static_cast<CardFilter::Type>(i)), QVariant(i));
+    }
+
+    QPushButton *ok = new QPushButton(QPixmap("theme:icons/increment"), QString());
+    ok->setObjectName("ok");
+    ok->setMaximumSize(20, 20);
+
+    edit = new LineEditUnfocusable;
+    edit->setObjectName("edit");
+    edit->setPlaceholderText(tr("Type your filter here"));
+    edit->setClearButtonEnabled(true);
+    edit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+
+    QGridLayout *layout = new QGridLayout;
+    layout->setObjectName("layout");
+    layout->setContentsMargins(0, 0, 0, 0);
+
+    layout->addWidget(typeCombo, 0, 0, 1, 2);
+    layout->addWidget(filterCombo, 0, 2, 1, 2);
+    layout->addWidget(edit, 1, 0, 1, 3);
+    layout->addWidget(ok, 1, 3);
+
+    setLayout(layout);
+
+    connect(filterCombo, qOverload<int>(&QComboBox::activated), edit, [this](int) { setFocus(); });
+    connect(edit, &LineEditUnfocusable::returnPressed, this, &FilterBuilder::emit_add);
+    connect(ok, &QPushButton::released, this, &FilterBuilder::emit_add);
+    fltr = NULL;
+}
+
+FilterBuilder::~FilterBuilder()
+{
+    destroyFilter();
+}
+
+void FilterBuilder::destroyFilter()
+{
+    if (fltr) {
+        delete fltr;
+    }
+}
+
+static int comboCurrentIntData(const QComboBox *combo)
+{
+    return combo->itemData(combo->currentIndex()).toInt();
+}
+
+void FilterBuilder::emit_add()
+{
+    QString txt;
+
+    txt = edit->text();
+    if (txt.length() < 1) {
+        return;
+    }
+
+    destroyFilter();
+    fltr = new CardFilter(txt, static_cast<CardFilter::Type>(comboCurrentIntData(typeCombo)),
+                          static_cast<CardFilter::Attr>(comboCurrentIntData(filterCombo)));
+    emit add(fltr);
+    edit->clear();
+}

C++/cockatrice/src/filters/filter_builder.h

@@ -0,0 +1,43 @@
+/**
+ * @file filter_builder.h
+ * @ingroup CardDatabaseModelFilters
+ */
+//! \todo Document this file.
+
+#ifndef FILTERBUILDER_H
+#define FILTERBUILDER_H
+
+#include <QWidget>
+
+class QCheckBox;
+class QComboBox;
+class LineEditUnfocusable;
+class CardFilter;
+
+class FilterBuilder : public QWidget
+{
+    Q_OBJECT
+
+private:
+    QComboBox *typeCombo;
+    QComboBox *filterCombo;
+    LineEditUnfocusable *edit;
+    CardFilter *fltr;
+
+    void destroyFilter();
+
+public:
+    explicit FilterBuilder(QWidget *parent = nullptr);
+    ~FilterBuilder() override;
+
+signals:
+    void add(const CardFilter *f);
+
+public slots:
+private slots:
+    void emit_add();
+
+protected:
+};
+
+#endif

C++/cockatrice/src/filters/filter_tree_model.cpp

@@ -0,0 +1,358 @@
+#include "filter_tree_model.h"
+
+#include <QFont>
+#include <libcockatrice/filters/filter_card.h>
+#include <libcockatrice/filters/filter_tree.h>
+
+FilterTreeModel::FilterTreeModel(QObject *parent) : QAbstractItemModel(parent)
+{
+    fTree = new FilterTree;
+    connect(fTree, &FilterTree::preInsertRow, this, &FilterTreeModel::proxyBeginInsertRow);
+    connect(fTree, &FilterTree::postInsertRow, this, &FilterTreeModel::proxyEndInsertRow);
+    connect(fTree, &FilterTree::preRemoveRow, this, &FilterTreeModel::proxyBeginRemoveRow);
+    connect(fTree, &FilterTree::postRemoveRow, this, &FilterTreeModel::proxyEndRemoveRow);
+}
+
+FilterTreeModel::~FilterTreeModel()
+{
+    delete fTree;
+}
+
+void FilterTreeModel::proxyBeginInsertRow(const FilterTreeNode *node, int i)
+{
+    int idx;
+
+    idx = node->index();
+    if (idx >= 0) {
+        beginInsertRows(createIndex(idx, 0, (void *)node), i, i);
+    }
+}
+
+void FilterTreeModel::proxyEndInsertRow(const FilterTreeNode *node, int)
+{
+    int idx;
+
+    idx = node->index();
+    if (idx >= 0) {
+        endInsertRows();
+    }
+}
+
+void FilterTreeModel::proxyBeginRemoveRow(const FilterTreeNode *node, int i)
+{
+    int idx;
+
+    idx = node->index();
+    if (idx >= 0) {
+        beginRemoveRows(createIndex(idx, 0, (void *)node), i, i);
+    }
+}
+
+void FilterTreeModel::proxyEndRemoveRow(const FilterTreeNode *node, int)
+{
+    int idx;
+
+    idx = node->index();
+    if (idx >= 0) {
+        endRemoveRows();
+    }
+}
+
+FilterTreeNode *FilterTreeModel::indexToNode(const QModelIndex &idx) const
+{
+    void *ip;
+    FilterTreeNode *node;
+
+    if (!idx.isValid()) {
+        return fTree;
+    }
+
+    ip = idx.internalPointer();
+    if (ip == NULL) {
+        return fTree;
+    }
+
+    node = static_cast<FilterTreeNode *>(ip);
+    return node;
+}
+
+void FilterTreeModel::addFilter(const CardFilter *f)
+{
+    emit layoutAboutToBeChanged();
+    fTree->termNode(f);
+    emit layoutChanged();
+}
+
+void FilterTreeModel::removeFilter(const CardFilter *f)
+{
+    emit layoutAboutToBeChanged();
+    fTree->removeFilter(f);
+    emit layoutChanged();
+}
+
+void FilterTreeModel::clearFiltersOfType(CardFilter::Attr filterType)
+{
+    emit layoutAboutToBeChanged();
+
+    // Recursively remove all nodes with the given filter type
+    fTree->removeFiltersByAttr(filterType);
+
+    emit layoutChanged();
+}
+
+QList<const CardFilter *> FilterTreeModel::getFiltersOfType(CardFilter::Attr filterType) const
+{
+    QList<const CardFilter *> filters;
+    if (!fTree) {
+        return filters;
+    }
+
+    std::function<void(const FilterTreeNode *)> traverse;
+    traverse = [&](const FilterTreeNode *node) {
+        if (const auto *filterItem = dynamic_cast<const FilterItem *>(node)) {
+            if (filterItem->attr() == filterType) {
+                QString text = filterItem->text();
+                filters.append(new CardFilter(text, filterItem->type(), filterItem->attr()));
+            }
+        }
+        for (int i = 0; i < node->childCount(); ++i) {
+            traverse(node->nodeAt(i));
+        }
+    };
+
+    traverse(fTree);
+    return filters;
+}
+
+QList<const CardFilter *> FilterTreeModel::allFilters() const
+{
+    QList<const CardFilter *> filters;
+    if (!fTree) {
+        return filters;
+    }
+
+    std::function<void(const FilterTreeNode *)> traverse;
+    traverse = [&](const FilterTreeNode *node) {
+        if (const auto *filterItem = dynamic_cast<const FilterItem *>(node)) {
+            QString text = filterItem->text();
+            filters.append(new CardFilter(text, filterItem->type(), filterItem->attr()));
+        }
+        for (int i = 0; i < node->childCount(); ++i) {
+            traverse(node->nodeAt(i));
+        }
+    };
+
+    traverse(fTree);
+    return filters;
+}
+
+int FilterTreeModel::rowCount(const QModelIndex &parent) const
+{
+    const FilterTreeNode *node;
+    int result;
+
+    if (parent.column() > 0) {
+        return 0;
+    }
+
+    node = indexToNode(parent);
+    if (node) {
+        result = node->childCount();
+    } else {
+        result = 0;
+    }
+
+    return result;
+}
+
+int FilterTreeModel::columnCount(const QModelIndex & /*parent*/) const
+{
+    return 1;
+}
+
+QVariant FilterTreeModel::data(const QModelIndex &index, int role) const
+{
+    const FilterTreeNode *node;
+
+    if (!index.isValid()) {
+        return QVariant();
+    }
+    if (index.column() >= columnCount()) {
+        return QVariant();
+    }
+
+    node = indexToNode(index);
+    if (node == NULL) {
+        return QVariant();
+    }
+
+    switch (role) {
+        case Qt::FontRole:
+            if (!node->isLeaf()) {
+                QFont f;
+                f.setBold(true);
+                return f;
+            }
+            break;
+        case Qt::DisplayRole:
+        case Qt::EditRole:
+        case Qt::ToolTipRole:
+        case Qt::StatusTipRole:
+        case Qt::WhatsThisRole:
+            return node->text();
+        case Qt::CheckStateRole:
+            if (node->isEnabled()) {
+                return Qt::Checked;
+            } else {
+                return Qt::Unchecked;
+            }
+        default:
+            return QVariant();
+    }
+
+    return QVariant();
+}
+
+bool FilterTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+    FilterTreeNode *node;
+
+    if (!index.isValid()) {
+        return false;
+    }
+    if (index.column() >= columnCount()) {
+        return false;
+    }
+    if (role != Qt::CheckStateRole) {
+        return false;
+    }
+
+    node = indexToNode(index);
+    if (node == NULL || node == fTree) {
+        return false;
+    }
+
+    Qt::CheckState state = static_cast<Qt::CheckState>(value.toInt());
+    if (state == Qt::Checked) {
+        node->enable();
+    } else {
+        node->disable();
+    }
+
+    emit dataChanged(index, index);
+    return true;
+}
+
+Qt::ItemFlags FilterTreeModel::flags(const QModelIndex &index) const
+{
+    const FilterTreeNode *node;
+    Qt::ItemFlags result;
+
+    if (!index.isValid()) {
+        return Qt::NoItemFlags;
+    }
+
+    node = indexToNode(index);
+    if (node == NULL) {
+        return Qt::NoItemFlags;
+    }
+
+    result = Qt::ItemIsEnabled;
+    if (node == fTree) {
+        return result;
+    }
+
+    result |= Qt::ItemIsSelectable;
+    result |= Qt::ItemIsUserCheckable;
+
+    return result;
+}
+
+QModelIndex FilterTreeModel::nodeIndex(const FilterTreeNode *node, int row, int column) const
+{
+    FilterTreeNode *child;
+
+    if (column > 0 || row >= node->childCount()) {
+        return QModelIndex();
+    }
+
+    child = node->nodeAt(row);
+    return createIndex(row, column, child);
+}
+
+QModelIndex FilterTreeModel::index(int row, int column, const QModelIndex &parent) const
+{
+    const FilterTreeNode *node;
+
+    if (!hasIndex(row, column, parent)) {
+        return QModelIndex();
+    }
+
+    node = indexToNode(parent);
+    if (node == NULL) {
+        return QModelIndex();
+    }
+
+    return nodeIndex(node, row, column);
+}
+
+QModelIndex FilterTreeModel::parent(const QModelIndex &ind) const
+{
+    const FilterTreeNode *node;
+    FilterTreeNode *parent;
+    QModelIndex idx;
+
+    if (!ind.isValid()) {
+        return QModelIndex();
+    }
+
+    node = indexToNode(ind);
+    if (node == NULL || node == fTree) {
+        return QModelIndex();
+    }
+
+    parent = node->parent();
+    if (parent) {
+        int row = parent->index();
+        if (row < 0) {
+            return QModelIndex();
+        }
+        idx = createIndex(row, 0, parent);
+        return idx;
+    }
+
+    return QModelIndex();
+}
+
+bool FilterTreeModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    FilterTreeNode *node;
+    int i, last;
+
+    last = row + count - 1;
+    if (!parent.isValid() || count < 1 || row < 0) {
+        return false;
+    }
+
+    node = indexToNode(parent);
+    if (node == NULL || last >= node->childCount()) {
+        return false;
+    }
+
+    for (i = 0; i < count; i++) {
+        node->deleteAt(row);
+    }
+
+    if (node != fTree && node->childCount() < 1) {
+        return removeRow(parent.row(), parent.parent());
+    }
+
+    return true;
+}
+
+void FilterTreeModel::clear()
+{
+    emit layoutAboutToBeChanged();
+    fTree->clear();
+    emit layoutChanged();
+}

C++/cockatrice/src/filters/filter_tree_model.h

@@ -0,0 +1,58 @@
+/**
+ * @file filter_tree_model.h
+ * @ingroup CardDatabaseModelFilters
+ */
+//! \todo Document this file.
+
+#ifndef FILTERTREEMODEL_H
+#define FILTERTREEMODEL_H
+
+#include <QAbstractItemModel>
+#include <libcockatrice/filters/filter_card.h>
+
+class FilterTree;
+class CardFilter;
+class FilterTreeNode;
+
+class FilterTreeModel : public QAbstractItemModel
+{
+    Q_OBJECT
+private:
+    FilterTree *fTree;
+
+public slots:
+    void addFilter(const CardFilter *f);
+    void removeFilter(const CardFilter *f);
+    void clearFiltersOfType(CardFilter::Attr filterType);
+    [[nodiscard]] QList<const CardFilter *> getFiltersOfType(CardFilter::Attr filterType) const;
+    [[nodiscard]] QList<const CardFilter *> allFilters() const;
+
+private slots:
+    void proxyBeginInsertRow(const FilterTreeNode *, int);
+    void proxyEndInsertRow(const FilterTreeNode *, int);
+    void proxyBeginRemoveRow(const FilterTreeNode *, int);
+    void proxyEndRemoveRow(const FilterTreeNode *, int);
+
+private:
+    [[nodiscard]] FilterTreeNode *indexToNode(const QModelIndex &idx) const;
+    QModelIndex nodeIndex(const FilterTreeNode *node, int row, int column) const;
+
+public:
+    FilterTreeModel(QObject *parent = nullptr);
+    ~FilterTreeModel() override;
+    [[nodiscard]] FilterTree *filterTree() const
+    {
+        return fTree;
+    }
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    [[nodiscard]] int columnCount(const QModelIndex & /*parent*/ = QModelIndex()) const override;
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role) const override;
+    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
+    [[nodiscard]] Qt::ItemFlags flags(const QModelIndex &index) const override;
+    [[nodiscard]] QModelIndex parent(const QModelIndex &ind) const override;
+    [[nodiscard]] QModelIndex index(int row, int column, const QModelIndex &parent) const override;
+    bool removeRows(int row, int count, const QModelIndex &parent) override;
+    void clear();
+};
+
+#endif

C++/cockatrice/src/filters/syntax_help.cpp

@@ -0,0 +1,86 @@
+#include "syntax_help.h"
+
+#include <QFile>
+#include <QRegularExpression>
+#include <QTextStream>
+
+/**
+ * Creates the card search syntax help window
+ *
+ * @return the QTextBrowser
+ */
+static QTextBrowser *createBrowser(const QString &helpFile)
+{
+    QFile file(helpFile);
+
+    if (!file.open(QFile::ReadOnly | QFile::Text)) {
+        qCWarning(SyntaxHelpLog) << "Could not open syntax help file: " << helpFile;
+        return nullptr;
+    }
+
+    QTextStream in(&file);
+    QString text = in.readAll();
+    file.close();
+
+    // --- Remove @page declarations at the top of the file ---
+    auto opts = QRegularExpression::MultilineOption;
+    text = text.replace(QRegularExpression(R"(^\s*@page[^\n]*\n)", opts), "");
+
+    // Poor Markdown Converter
+    text = text.replace(QRegularExpression("^(###)(.*)", opts), "<h3>\\2</h3>")
+               .replace(QRegularExpression("^(##)(.*)", opts), "<h2>\\2</h2>")
+               .replace(QRegularExpression("^(#)(.*)", opts), "<h1>\\2</h1>")
+               .replace(QRegularExpression("^------*", opts), "<hr />")
+               .replace(QRegularExpression(R"(\[([^[]+)\]\(([^\)]+)\))", opts), R"(<a href='\2'>\1</a>)");
+
+    auto browser = new QTextBrowser();
+    browser->setParent(nullptr, Qt::Window | Qt::WindowTitleHint | Qt::WindowSystemMenuHint |
+                                    Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint |
+                                    Qt::WindowFullscreenButtonHint);
+    browser->setWindowTitle("Search Help");
+    browser->setReadOnly(true);
+    browser->setMinimumSize({500, 600});
+
+    QString sheet = QString("a { text-decoration: underline; color: rgb(71,158,252) };");
+    browser->document()->setDefaultStyleSheet(sheet);
+    browser->setHtml(text);
+
+    browser->show();
+
+    return browser;
+}
+
+/**
+ * Creates the card search syntax help window and connects its anchorClicked signal to the given QLineEdit.
+ * The window will automatically close when the QLineEdit is destroyed.
+ *
+ * @return the QTextBrowser
+ */
+QTextBrowser *createSearchSyntaxHelpWindow(QLineEdit *lineEdit)
+{
+    auto browser = createBrowser("theme:help/search.md");
+    QObject::connect(browser, &QTextBrowser::anchorClicked,
+                     [lineEdit](const QUrl &link) { lineEdit->setText(link.fragment()); });
+    QObject::connect(lineEdit, &QObject::destroyed, browser, &QTextBrowser::close);
+    return browser;
+}
+
+/**
+ * Creates the deck search syntax help window and connects its anchorClicked signal to the given QLineEdit.
+ * The window will automatically close when the QLineEdit is destroyed.
+ *
+ * @return the QTextBrowser
+ */
+QTextBrowser *createDeckSearchSyntaxHelpWindow(QLineEdit *lineEdit)
+{
+    auto browser = createBrowser("theme:help/deck_search.md");
+    QObject::connect(browser, &QTextBrowser::anchorClicked, [lineEdit](const QUrl &link) {
+        if (link.fragment() == "cardSearchSyntaxHelp") {
+            createSearchSyntaxHelpWindow(lineEdit);
+        } else {
+            lineEdit->setText(link.fragment());
+        }
+    });
+    QObject::connect(lineEdit, &QObject::destroyed, browser, &QTextBrowser::close);
+    return browser;
+}

C++/cockatrice/src/filters/syntax_help.h

@@ -0,0 +1,21 @@
+/**
+ * @file syntax_help.h
+ * @ingroup CardDatabaseModelFilters
+ * @ingroup DeckStorageWidgets
+ */
+//! \todo Document this file.
+
+#ifndef SEARCH_SYNTAX_HELP_H
+#define SEARCH_SYNTAX_HELP_H
+
+#include <QLineEdit>
+#include <QLoggingCategory>
+#include <QTextBrowser>
+
+inline Q_LOGGING_CATEGORY(SyntaxHelpLog, "syntax_help");
+
+QTextBrowser *createSearchSyntaxHelpWindow(QLineEdit *lineEdit);
+
+QTextBrowser *createDeckSearchSyntaxHelpWindow(QLineEdit *lineEdit);
+
+#endif // SEARCH_SYNTAX_HELP_H

C++/cockatrice/src/game/abstract_game.cpp

@@ -0,0 +1,58 @@
+#include "abstract_game.h"
+
+#include "../interface/widgets/tabs/tab_game.h"
+#include "player/player_logic.h"
+
+AbstractGame::AbstractGame(QObject *_parent) : QObject(_parent)
+{
+    gameMetaInfo = new GameMetaInfo(this);
+    gameEventHandler = new GameEventHandler(this);
+
+    activeCard = nullptr;
+}
+
+bool AbstractGame::isHost() const
+{
+    return gameState->getHostId() == playerManager->getLocalPlayerId();
+}
+
+AbstractClient *AbstractGame::getClientForPlayer(int playerId) const
+{
+    if (gameState->getClients().size() > 1) {
+        if (playerId == -1) {
+            playerId = playerManager->getActiveLocalPlayer(gameState->getActivePlayer())->getPlayerInfo()->getId();
+        }
+
+        return gameState->getClients().at(playerId);
+    } else if (gameState->getClients().isEmpty()) {
+        return nullptr;
+    } else {
+        return gameState->getClients().first();
+    }
+}
+
+void AbstractGame::loadReplay(GameReplay *replay)
+{
+    gameMetaInfo->setFromProto(replay->game_info());
+    gameMetaInfo->setSpectatorsOmniscient(true);
+}
+
+void AbstractGame::setActiveCard(CardItem *card)
+{
+    activeCard = card;
+}
+
+CardItem *AbstractGame::getCard(int playerId, const QString &zoneName, int cardId) const
+{
+    PlayerLogic *player = playerManager->getPlayer(playerId);
+    if (!player) {
+        return nullptr;
+    }
+
+    CardZoneLogic *zone = player->getZones().value(zoneName, 0);
+    if (!zone) {
+        return nullptr;
+    }
+
+    return zone->getCard(cardId);
+}

C++/cockatrice/src/game/abstract_game.h

@@ -0,0 +1,67 @@
+/**
+ * @file abstract_game.h
+ * @ingroup GameLogic
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_ABSTRACT_GAME_H
+#define COCKATRICE_ABSTRACT_GAME_H
+
+#include "game_event_handler.h"
+#include "game_meta_info.h"
+#include "game_state.h"
+#include "player/player_manager.h"
+
+#include <QObject>
+#include <libcockatrice/protocol/pb/game_replay.pb.h>
+
+class CardItem;
+class AbstractGame : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit AbstractGame(QObject *parent);
+
+    GameMetaInfo *gameMetaInfo;
+    GameState *gameState;
+    GameEventHandler *gameEventHandler;
+    PlayerManager *playerManager;
+    CardItem *activeCard;
+
+    GameMetaInfo *getGameMetaInfo()
+    {
+        return gameMetaInfo;
+    }
+
+    GameState *getGameState() const
+    {
+        return gameState;
+    }
+
+    GameEventHandler *getGameEventHandler() const
+    {
+        return gameEventHandler;
+    }
+
+    PlayerManager *getPlayerManager() const
+    {
+        return playerManager;
+    }
+
+    bool isHost() const;
+
+    AbstractClient *getClientForPlayer(int playerId) const;
+
+    void loadReplay(GameReplay *replay);
+
+    CardItem *getCard(int playerId, const QString &zoneName, int cardId) const;
+
+    void setActiveCard(CardItem *card);
+    CardItem *getActiveCard() const
+    {
+        return activeCard;
+    }
+};
+
+#endif // COCKATRICE_ABSTRACT_GAME_H

C++/cockatrice/src/game/arrow_registry.cpp

@@ -0,0 +1,48 @@
+#include "arrow_registry.h"
+
+#include "../game_graphics/board/arrow_item.h"
+
+void ArrowRegistry::insert(QSharedPointer<ArrowData> data, ArrowItem *arrow)
+{
+    const ArrowKey key{data->creatorId, data->id};
+
+    if (auto *existing = take(data->creatorId, data->id)) {
+        existing->delArrow();
+    }
+
+    dataStore.insert(key, data);
+    items.insert(key, arrow);
+    byPlayer[data->creatorId].insert(data->id);
+}
+
+ArrowItem *ArrowRegistry::take(int creatorId, int arrowId)
+{
+    const ArrowKey key{creatorId, arrowId};
+    dataStore.remove(key);
+    auto &playerSet = byPlayer[creatorId];
+    playerSet.remove(arrowId);
+    if (playerSet.isEmpty()) {
+        byPlayer.remove(creatorId);
+    }
+    return items.take(key);
+}
+
+ArrowItem *ArrowRegistry::get(int creatorId, int arrowId) const
+{
+    return items.value(ArrowKey{creatorId, arrowId}, nullptr);
+}
+
+bool ArrowRegistry::contains(int creatorId, int arrowId) const
+{
+    return items.contains(ArrowKey{creatorId, arrowId});
+}
+
+QSet<int> ArrowRegistry::idsForPlayer(int playerId) const
+{
+    return byPlayer.value(playerId);
+}
+
+QList<ArrowItem *> ArrowRegistry::all() const
+{
+    return items.values();
+}

C++/cockatrice/src/game/arrow_registry.h

@@ -0,0 +1,43 @@
+#ifndef COCKATRICE_ARROW_REGISTRY_H
+#define COCKATRICE_ARROW_REGISTRY_H
+
+#include "board/arrow_data.h"
+
+#include <QMap>
+#include <QSet>
+#include <QSharedPointer>
+
+class ArrowItem;
+
+struct ArrowKey
+{
+    int creatorId;
+    int arrowId;
+
+    bool operator<(const ArrowKey &other) const
+    {
+        if (creatorId != other.creatorId) {
+            return creatorId < other.creatorId;
+        }
+        return arrowId < other.arrowId;
+    }
+};
+
+class ArrowRegistry
+{
+public:
+    void insert(QSharedPointer<ArrowData> data, ArrowItem *arrow);
+    ArrowItem *take(int creatorId, int arrowId);
+
+    [[nodiscard]] ArrowItem *get(int creatorId, int arrowId) const;
+    [[nodiscard]] bool contains(int creatorId, int arrowId) const;
+    [[nodiscard]] QSet<int> idsForPlayer(int playerId) const;
+    [[nodiscard]] QList<ArrowItem *> all() const;
+
+private:
+    QMap<ArrowKey, QSharedPointer<ArrowData>> dataStore;
+    QMap<ArrowKey, ArrowItem *> items;
+    QMap<int, QSet<int>> byPlayer;
+};
+
+#endif

C++/cockatrice/src/game/board/arrow_data.cpp

@@ -0,0 +1,21 @@
+#include "arrow_data.h"
+
+ArrowData ArrowData::fromProto(const ServerInfo_Arrow &arrow, int creatorId, bool isLocalCreator)
+{
+    ArrowData data;
+    data.creatorId = creatorId;
+    data.isLocalCreator = isLocalCreator;
+    data.id = arrow.id();
+    data.startPlayerId = arrow.start_player_id();
+    data.startZone = QString::fromStdString(arrow.start_zone());
+    data.startCardId = arrow.start_card_id();
+    data.targetPlayerId = arrow.target_player_id();
+    data.color = convertColorToQColor(arrow.arrow_color());
+
+    if (arrow.has_target_zone()) {
+        data.targetZone = QString::fromStdString(arrow.target_zone());
+        data.targetCardId = arrow.target_card_id();
+    }
+
+    return data;
+}

C++/cockatrice/src/game/board/arrow_data.h

@@ -0,0 +1,30 @@
+#ifndef COCKATRICE_ARROW_DATA_H
+#define COCKATRICE_ARROW_DATA_H
+
+#include <QColor>
+#include <QString>
+#include <libcockatrice/protocol/pb/serverinfo_arrow.pb.h>
+#include <libcockatrice/utility/color.h>
+
+struct ArrowData
+{
+    int creatorId = -1;
+    bool isLocalCreator = false;
+    int id = -1;
+    int startPlayerId = -1;
+    QString startZone = "";
+    int startCardId = -1;
+    int targetPlayerId = -1;
+    QString targetZone = "";
+    int targetCardId = -1;
+    QColor color = "";
+
+    static ArrowData fromProto(const ServerInfo_Arrow &arrow, int creatorId, bool isLocalCreator);
+
+    bool isPlayerTargeted() const
+    {
+        return targetZone.isEmpty();
+    }
+};
+
+#endif // COCKATRICE_ARROW_DATA_H

C++/cockatrice/src/game/board/card_list.cpp

@@ -0,0 +1,159 @@
+#include "card_list.h"
+
+#include "../../game_graphics/board/card_item.h"
+
+#include <QDebug>
+#include <algorithm>
+#include <libcockatrice/card/card_info.h>
+
+CardList::CardList(bool _contentsKnown) : QList<CardItem *>(), contentsKnown(_contentsKnown)
+{
+}
+
+/**
+ * @brief Finds the CardItem with the given id in the list.
+ * If contentsKnown is false, then this just returns the first element of the list.
+ *
+ * @param cardId The id of the card to find.
+ *
+ * @returns A pointer to the CardItem, or a nullptr if not found.
+ */
+CardItem *CardList::findCard(const int cardId) const
+{
+    if (!contentsKnown && !empty()) {
+        return at(0);
+    } else {
+        for (auto *cardItem : *this) {
+            if (cardItem->getId() == cardId) {
+                return cardItem;
+            }
+        }
+    }
+    return nullptr;
+}
+
+/**
+ * @brief sorts the list by using string comparison on properties extracted from the CardItem
+ * The cards are compared using each property in order.
+ * If two cards have the same value for a property, then the next property in the list is used.
+ *
+ * @param option the option to compare the cards by, in order of usage.
+ */
+void CardList::sortBy(const QList<SortOption> &option)
+{
+    // early return if we know we won't be sorting
+    if (option.isEmpty()) {
+        return;
+    }
+
+    auto comparator = [&option](CardItem *a, CardItem *b) {
+        for (auto prop : option) {
+            auto extractor = getExtractorFor(prop);
+            QString t1 = extractor(a);
+            QString t2 = extractor(b);
+            if (t1 != t2) {
+                return t1 < t2;
+            }
+        }
+        return false;
+    };
+
+    std::sort(begin(), end(), comparator);
+}
+
+/**
+ * Creates a String for the card such that when sorting cards using that string, it will result in the
+ * following sort order:
+ * - Unrecognized colors
+ * - Land cards
+ * - Colorless cards
+ * - Monocolor cards, in wubrg order
+ * - Monocolor cards of any custom colors
+ * - 2C cards (no internal order)
+ * - 3C cards (no internal order)
+ * - 4C cards (no internal order)
+ * - 5C cards (no internal order)
+ *
+ * @param c The card info
+ * @param appendAtEnd For multicolor cards, whether to also append the entire color string at the end.
+ */
+static QString getColorSortString(const CardInfo &c, bool appendAtEnd)
+{
+    QString colors = c.getColors();
+    switch (colors.size()) {
+        case 0: {
+            if (c.getCardType().contains("Land")) {
+                return "a_land";
+            } else {
+                return "b_colorless";
+            }
+        }
+        case 1:
+            // force wubrg order
+            switch (colors.at(0).toLatin1()) {
+                case 'W':
+                    return "c_W";
+                case 'U':
+                    return "d_U";
+                case 'B':
+                    return "e_B";
+                case 'R':
+                    return "f_R";
+                case 'G':
+                    return "g_G";
+                default:
+                    // handle any custom colors
+                    return QString("h_%1").arg(colors.at(0));
+            }
+        default:
+            return QString("i%1_%2").arg(colors.size()).arg(appendAtEnd ? colors : "");
+    }
+}
+
+/**
+ * @brief returns the function that extracts the given property from the CardItem.
+ */
+std::function<QString(CardItem *)> CardList::getExtractorFor(SortOption option)
+{
+    switch (option) {
+        case NoSort:
+            return [](CardItem *) { return ""; };
+        case SortByMainType:
+            return [](CardItem *c) { return c->getCardInfo().getMainCardType(); };
+        case SortByManaValue:
+            // getCmc returns the int as a string. We pad with 0's so that string comp also works on it
+            return [](CardItem *c) { return c->getCard() ? c->getCardInfo().getCmc().rightJustified(4, '0') : ""; };
+        case SortByColorGrouping:
+            return [](CardItem *c) { return c->getCard() ? getColorSortString(c->getCardInfo(), false) : ""; };
+        case SortByName:
+            return [](CardItem *c) { return c->getName(); };
+        case SortByType:
+            return [](CardItem *c) { return c->getCardInfo().getCardType(); };
+        case SortByManaCost:
+            return [](CardItem *c) {
+                if (!c->getCard()) {
+                    return QString();
+                }
+
+                auto info = c->getCardInfo();
+
+                // calculation copied from CardDatabaseModel.
+                // we pad the cmc and also append the mana cost to the end so same cmc cards still have a sort order
+                return QString("%1%2").arg(info.getCmc(), 4, QChar('0')).arg(info.getManaCost());
+            };
+        case SortByColors:
+            return [](CardItem *c) { return c->getCard() ? getColorSortString(c->getCardInfo(), true) : ""; };
+        case SortByPt:
+            // do the same padding trick as above
+            return
+                [](CardItem *c) { return c->getCard() ? c->getCardInfo().getPowTough().rightJustified(10, '0') : ""; };
+        case SortBySet:
+            return [](CardItem *c) { return c->getCardInfo().getSetsNames(); };
+        case SortByPrinting:
+            return [](CardItem *c) { return c->getProviderId(); };
+    }
+
+    // this line should never be reached
+    qCWarning(CardListLog) << "cardlist.cpp: Could not find extractor for SortOption" << option;
+    return [](CardItem *) { return ""; };
+}

C++/cockatrice/src/game/board/card_list.h

@@ -0,0 +1,55 @@
+/**
+ * @file card_list.h
+ * @ingroup GameLogicCards
+ */
+//! \todo Document this file.
+
+#ifndef CARDLIST_H
+#define CARDLIST_H
+
+#include <QList>
+#include <QLoggingCategory>
+
+inline Q_LOGGING_CATEGORY(CardListLog, "card_list");
+
+class CardItem;
+
+class CardList : public QList<CardItem *>
+{
+protected:
+    bool contentsKnown;
+
+public:
+    enum SortOption
+    {
+        NoSort,
+
+        // Options that are used by groupBy
+        // Should partition all cards into a reasonable number of buckets
+        SortByMainType,
+        SortByManaValue,
+        SortByColorGrouping,
+
+        // Options that are used by sortBy
+        // We don't care about buckets; we want as many distinct values as possible.
+        SortByName,
+        SortByType,
+        SortByManaCost,
+        SortByColors,
+        SortByPt,
+        SortBySet,
+        SortByPrinting
+    };
+    explicit CardList(bool _contentsKnown);
+    CardItem *findCard(const int cardId) const;
+    bool getContentsKnown() const
+    {
+        return contentsKnown;
+    }
+
+    void sortBy(const QList<SortOption> &options);
+
+    static std::function<QString(CardItem *)> getExtractorFor(SortOption option);
+};
+
+#endif

C++/cockatrice/src/game/board/card_state.cpp

@@ -0,0 +1,111 @@
+#include "card_state.h"
+
+void CardState::resetState(bool keepAnnotations)
+{
+    attacking = false;
+    counters.clear();
+    pt.clear();
+    if (!keepAnnotations) {
+        annotation.clear();
+    }
+    attachedTo = nullptr;
+}
+
+void CardState::setZone(CardZoneLogic *_zone)
+{
+    if (zone == _zone) {
+        return;
+    }
+
+    zone = _zone;
+    emit zoneChanged(this, zone);
+    emit stateChanged();
+}
+
+void CardState::setAttacking(bool _attacking)
+{
+    if (attacking == _attacking) {
+        return;
+    }
+    attacking = _attacking;
+    emit attackingChanged(_attacking);
+    emit stateChanged();
+}
+
+void CardState::insertCounter(int id, int value)
+{
+    counters.insert(id, value);
+
+    emit countersChanged(counters);
+    emit stateChanged();
+}
+
+void CardState::setCounter(int id, int value)
+{
+    if (value) {
+        counters[id] = value;
+    } else {
+        counters.remove(id);
+    }
+
+    emit countersChanged(counters);
+    emit stateChanged();
+}
+
+void CardState::clearCounters()
+{
+    counters.clear();
+    emit countersChanged(counters);
+    emit stateChanged();
+}
+
+void CardState::setAnnotation(const QString &_annotation)
+{
+    if (annotation == _annotation) {
+        return;
+    }
+    annotation = _annotation;
+    emit annotationChanged(annotation);
+    emit stateChanged();
+}
+
+void CardState::setPT(const QString &_pt)
+{
+    if (pt == _pt) {
+        return;
+    }
+    pt = _pt;
+    emit ptChanged(pt);
+    emit stateChanged();
+}
+
+void CardState::setDoesntUntap(bool _doesntUntap)
+{
+    if (doesntUntap == _doesntUntap) {
+        return;
+    }
+    doesntUntap = _doesntUntap;
+    emit doesntUntapChanged(_doesntUntap);
+    emit stateChanged();
+}
+
+void CardState::setDestroyOnZoneChange(bool _destroyOnZoneChange)
+{
+    if (destroyOnZoneChange == _destroyOnZoneChange) {
+        return;
+    }
+
+    destroyOnZoneChange = _destroyOnZoneChange;
+    emit destroyOnZoneChangeChanged(_destroyOnZoneChange);
+    emit stateChanged();
+}
+
+void CardState::setAttachedTo(CardItem *_attachedTo)
+{
+    if (attachedTo == _attachedTo) {
+        return;
+    }
+    attachedTo = _attachedTo;
+    emit attachedToChanged(_attachedTo);
+    emit stateChanged();
+}

C++/cockatrice/src/game/board/card_state.h

@@ -0,0 +1,103 @@
+#ifndef COCKATRICE_CARD_STATE_H
+#define COCKATRICE_CARD_STATE_H
+
+#include <QMap>
+#include <QObject>
+
+class CardZoneLogic;
+class CardItem;
+class CardState : public QObject
+{
+    Q_OBJECT
+
+private:
+    bool attacking = false;
+    QMap<int, int> counters;
+    QString annotation;
+    QString pt;
+    bool doesntUntap = false;
+    bool destroyOnZoneChange = false;
+
+    CardItem *attachedTo = nullptr;
+    CardZoneLogic *zone = nullptr;
+
+signals:
+    void stateChanged();
+
+    void attackingChanged(bool newValue);
+    void countersChanged(const QMap<int, int> &newCounters);
+    void annotationChanged(const QString &newAnnotation);
+    void ptChanged(const QString &newPt);
+    void doesntUntapChanged(bool newValue);
+    void destroyOnZoneChangeChanged(bool newValue);
+    void attachedToChanged(CardItem *newAttachedTo);
+    void zoneChanged(CardState *changedCard, CardZoneLogic *newZone);
+
+public:
+    explicit CardState(QObject *parent, CardZoneLogic *_zone) : QObject(parent), zone(_zone)
+    {
+    }
+
+    void resetState(bool keepAnnotations);
+
+    CardZoneLogic *getZone() const
+    {
+        return zone;
+    }
+
+    void setZone(CardZoneLogic *_zone);
+
+    bool getAttacking() const
+    {
+        return attacking;
+    }
+    void setAttacking(bool _attacking);
+
+    const QMap<int, int> &getCounters() const
+    {
+        return counters;
+    }
+
+    void insertCounter(int id, int value);
+
+    void setCounter(int id, int value);
+
+    void clearCounters();
+
+    QString getAnnotation() const
+    {
+        return annotation;
+    }
+
+    void setAnnotation(const QString &_annotation);
+
+    QString getPT() const
+    {
+        return pt;
+    }
+
+    void setPT(const QString &_pt);
+
+    bool getDoesntUntap() const
+    {
+        return doesntUntap;
+    }
+
+    void setDoesntUntap(bool _doesntUntap);
+
+    bool getDestroyOnZoneChange() const
+    {
+        return destroyOnZoneChange;
+    }
+
+    void setDestroyOnZoneChange(bool _destroyOnZoneChange);
+
+    CardItem *getAttachedTo() const
+    {
+        return attachedTo;
+    }
+
+    void setAttachedTo(CardItem *_attachedTo);
+};
+
+#endif // COCKATRICE_CARD_STATE_H

C++/cockatrice/src/game/board/counter_state.cpp

@@ -0,0 +1,24 @@
+#include "counter_state.h"
+
+#include <libcockatrice/utility/color.h>
+
+CounterState::CounterState(int id, const QString &name, const QColor &color, int radius, int value, QObject *parent)
+    : QObject(parent), id(id), name(name), color(color), radius(radius), value(value)
+{
+}
+
+CounterState *CounterState::fromProto(const ServerInfo_Counter &counter, QObject *parent)
+{
+    return new CounterState(counter.id(), QString::fromStdString(counter.name()),
+                            convertColorToQColor(counter.counter_color()), counter.radius(), counter.count(), parent);
+}
+
+void CounterState::setValue(int newValue)
+{
+    if (newValue == value) {
+        return;
+    }
+    int old = value;
+    value = newValue;
+    emit valueChanged(old, newValue);
+}

C++/cockatrice/src/game/board/counter_state.h

@@ -0,0 +1,51 @@
+#ifndef COCKATRICE_COUNTER_STATE_H
+#define COCKATRICE_COUNTER_STATE_H
+
+#include <QColor>
+#include <QObject>
+#include <QString>
+#include <libcockatrice/protocol/pb/serverinfo_counter.pb.h>
+
+class CounterState : public QObject
+{
+    Q_OBJECT
+public:
+    CounterState(int id, const QString &name, const QColor &color, int radius, int value, QObject *parent = nullptr);
+
+    static CounterState *fromProto(const ServerInfo_Counter &counter, QObject *parent = nullptr);
+
+    int getId() const
+    {
+        return id;
+    }
+    QString getName() const
+    {
+        return name;
+    }
+    QColor getColor() const
+    {
+        return color;
+    }
+    int getRadius() const
+    {
+        return radius;
+    }
+    int getValue() const
+    {
+        return value;
+    }
+
+    void setValue(int newValue);
+
+signals:
+    void valueChanged(int oldValue, int newValue);
+
+private:
+    int id;
+    QString name;
+    QColor color;
+    int radius;
+    int value;
+};
+
+#endif // COCKATRICE_COUNTER_STATE_H

C++/cockatrice/src/game/game.cpp

@@ -0,0 +1,20 @@
+#include "game.h"
+
+#include "../interface/widgets/tabs/tab_game.h"
+
+#include <libcockatrice/protocol/pb/event_game_joined.pb.h>
+
+Game::Game(QObject *_parent,
+           bool isLocalGame,
+           QList<AbstractClient *> &_clients,
+           const Event_GameJoined &event,
+           const QMap<int, QString> &_roomGameTypes)
+    : AbstractGame(_parent)
+{
+    gameMetaInfo->setFromProto(event.game_info());
+    gameMetaInfo->setRoomGameTypes(_roomGameTypes);
+    gameState = new GameState(this, 0, event.host_id(), isLocalGame, _clients, false, event.resuming(), -1, false);
+    connect(gameMetaInfo, &GameMetaInfo::startedChanged, gameState, &GameState::onStartedChanged);
+    playerManager = new PlayerManager(this, event.player_id(), event.judge(), event.spectator());
+    gameMetaInfo->setStarted(false);
+}

C++/cockatrice/src/game/game.h

@@ -0,0 +1,26 @@
+/**
+ * @file game.h
+ * @ingroup GameLogic
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_GAME_H
+#define COCKATRICE_GAME_H
+
+#include "abstract_game.h"
+
+#include <QObject>
+
+class Game : public AbstractGame
+{
+    Q_OBJECT
+
+public:
+    Game(QObject *parent,
+         bool isLocalGame,
+         QList<AbstractClient *> &_clients,
+         const Event_GameJoined &event,
+         const QMap<int, QString> &_roomGameTypes);
+};
+
+#endif // COCKATRICE_GAME_H

C++/cockatrice/src/game/game_event_handler.cpp

@@ -0,0 +1,540 @@
+#include "game_event_handler.h"
+
+#include "../game_graphics/log/message_log_widget.h"
+#include "../interface/widgets/tabs/tab_game.h"
+#include "abstract_game.h"
+
+#include <libcockatrice/network/client/abstract/abstract_client.h>
+#include <libcockatrice/protocol/get_pb_extension.h>
+#include <libcockatrice/protocol/pb/command_concede.pb.h>
+#include <libcockatrice/protocol/pb/command_delete_arrow.pb.h>
+#include <libcockatrice/protocol/pb/command_game_say.pb.h>
+#include <libcockatrice/protocol/pb/command_leave_game.pb.h>
+#include <libcockatrice/protocol/pb/command_next_turn.pb.h>
+#include <libcockatrice/protocol/pb/command_reverse_turn.pb.h>
+#include <libcockatrice/protocol/pb/command_set_active_phase.pb.h>
+#include <libcockatrice/protocol/pb/context_connection_state_changed.pb.h>
+#include <libcockatrice/protocol/pb/context_deck_select.pb.h>
+#include <libcockatrice/protocol/pb/event_game_closed.pb.h>
+#include <libcockatrice/protocol/pb/event_game_host_changed.pb.h>
+#include <libcockatrice/protocol/pb/event_game_say.pb.h>
+#include <libcockatrice/protocol/pb/event_game_state_changed.pb.h>
+#include <libcockatrice/protocol/pb/event_join.pb.h>
+#include <libcockatrice/protocol/pb/event_kicked.pb.h>
+#include <libcockatrice/protocol/pb/event_leave.pb.h>
+#include <libcockatrice/protocol/pb/event_player_properties_changed.pb.h>
+#include <libcockatrice/protocol/pb/event_reverse_turn.pb.h>
+#include <libcockatrice/protocol/pb/event_set_active_phase.pb.h>
+#include <libcockatrice/protocol/pb/event_set_active_player.pb.h>
+#include <libcockatrice/protocol/pb/game_event_container.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
+
+GameEventHandler::GameEventHandler(AbstractGame *_game) : QObject(_game), game(_game)
+{
+}
+
+void GameEventHandler::sendGameCommand(PendingCommand *pend, int playerId)
+{
+    AbstractClient *client = game->getClientForPlayer(playerId);
+    if (!client) {
+        return;
+    }
+
+    connect(pend, &PendingCommand::finished, this, &GameEventHandler::commandFinished);
+    client->sendCommand(pend);
+}
+
+void GameEventHandler::sendGameCommand(const google::protobuf::Message &command, int playerId)
+{
+    AbstractClient *client = game->getClientForPlayer(playerId);
+    if (!client) {
+        return;
+    }
+
+    PendingCommand *pend = prepareGameCommand(command);
+    connect(pend, &PendingCommand::finished, this, &GameEventHandler::commandFinished);
+    client->sendCommand(pend);
+}
+
+void GameEventHandler::commandFinished(const Response &response)
+{
+    if (response.response_code() == Response::RespChatFlood) {
+        emit gameFlooded();
+    }
+}
+
+PendingCommand *GameEventHandler::prepareGameCommand(const ::google::protobuf::Message &cmd)
+{
+    CommandContainer cont;
+    cont.set_game_id(static_cast<google::protobuf::uint32>(game->getGameMetaInfo()->gameId()));
+    GameCommand *c = cont.add_game_command();
+    c->GetReflection()->MutableMessage(c, cmd.GetDescriptor()->FindExtensionByName("ext"))->CopyFrom(cmd);
+    return new PendingCommand(cont);
+}
+
+PendingCommand *GameEventHandler::prepareGameCommand(const QList<const ::google::protobuf::Message *> &cmdList)
+{
+    CommandContainer cont;
+    cont.set_game_id(static_cast<google::protobuf::uint32>(game->getGameMetaInfo()->gameId()));
+    for (auto i : cmdList) {
+        GameCommand *c = cont.add_game_command();
+        c->GetReflection()->MutableMessage(c, i->GetDescriptor()->FindExtensionByName("ext"))->CopyFrom(*i);
+        delete i;
+    }
+    return new PendingCommand(cont);
+}
+
+void GameEventHandler::processGameEventContainer(const GameEventContainer &cont,
+                                                 AbstractClient *client,
+                                                 EventProcessingOptions options)
+{
+    const GameEventContext &context = cont.context();
+    emit containerProcessingStarted(context);
+
+    const int eventListSize = cont.event_list_size();
+    for (int i = 0; i < eventListSize; ++i) {
+        const GameEvent &event = cont.event_list(i);
+        const int playerId = event.player_id();
+        const auto eventType = static_cast<GameEvent::GameEventType>(getPbExtension(event));
+
+        if (cont.has_forced_by_judge()) {
+            auto id = cont.forced_by_judge();
+            PlayerLogic *judgep = game->getPlayerManager()->getPlayers().value(id, nullptr);
+            if (judgep) {
+                emit setContextJudgeName(judgep->getPlayerInfo()->getName());
+            } else if (game->getPlayerManager()->getSpectators().contains(id)) {
+                emit setContextJudgeName(
+                    QString::fromStdString(game->getPlayerManager()->getSpectators().value(id).name()));
+            }
+        }
+
+        if (game->getPlayerManager()->getSpectators().contains(playerId)) {
+            switch (eventType) {
+                case GameEvent::GAME_SAY:
+                    eventSpectatorSay(event.GetExtension(Event_GameSay::ext), playerId, context);
+                    break;
+                case GameEvent::LEAVE:
+                    eventSpectatorLeave(event.GetExtension(Event_Leave::ext), playerId, context);
+                    break;
+                default:
+                    break;
+            }
+        } else {
+            if ((game->getGameState()->getClients().size() > 1) && (playerId != -1)) {
+                if (game->getGameState()->getClients().at(playerId) != client) {
+                    continue;
+                }
+            }
+
+            switch (eventType) {
+                case GameEvent::GAME_STATE_CHANGED:
+                    eventGameStateChanged(event.GetExtension(Event_GameStateChanged::ext), playerId, context);
+                    break;
+                case GameEvent::PLAYER_PROPERTIES_CHANGED:
+                    eventPlayerPropertiesChanged(event.GetExtension(Event_PlayerPropertiesChanged::ext), playerId,
+                                                 context);
+                    break;
+                case GameEvent::JOIN:
+                    eventJoin(event.GetExtension(Event_Join::ext), playerId, context);
+                    break;
+                case GameEvent::LEAVE:
+                    eventLeave(event.GetExtension(Event_Leave::ext), playerId, context);
+                    break;
+                case GameEvent::KICKED:
+                    eventKicked(event.GetExtension(Event_Kicked::ext), playerId, context);
+                    break;
+                case GameEvent::GAME_HOST_CHANGED:
+                    eventGameHostChanged(event.GetExtension(Event_GameHostChanged::ext), playerId, context);
+                    break;
+                case GameEvent::GAME_CLOSED:
+                    eventGameClosed(event.GetExtension(Event_GameClosed::ext), playerId, context);
+                    break;
+                case GameEvent::SET_ACTIVE_PLAYER:
+                    eventSetActivePlayer(event.GetExtension(Event_SetActivePlayer::ext), playerId, context);
+                    break;
+                case GameEvent::SET_ACTIVE_PHASE:
+                    eventSetActivePhase(event.GetExtension(Event_SetActivePhase::ext), playerId, context);
+                    break;
+                case GameEvent::REVERSE_TURN:
+                    eventReverseTurn(event.GetExtension(Event_ReverseTurn::ext), playerId, context);
+                    break;
+
+                default: {
+                    PlayerLogic *player = game->getPlayerManager()->getPlayers().value(playerId, 0);
+                    if (!player) {
+                        qCWarning(GameEventHandlerLog) << "unhandled game event: invalid player id";
+                        break;
+                    }
+                    player->getPlayerEventHandler()->processGameEvent(eventType, event, context, options);
+                    emitUserEvent();
+                }
+            }
+        }
+    }
+    emit containerProcessingDone();
+}
+
+void GameEventHandler::handleNextTurn()
+{
+    sendGameCommand(Command_NextTurn());
+}
+
+void GameEventHandler::handleReverseTurn()
+{
+    sendGameCommand(Command_ReverseTurn());
+}
+
+void GameEventHandler::handleActiveLocalPlayerConceded()
+{
+    sendGameCommand(Command_Concede());
+}
+
+void GameEventHandler::handleActiveLocalPlayerUnconceded()
+{
+    sendGameCommand(Command_Unconcede());
+}
+
+void GameEventHandler::handleActivePhaseChanged(int phase)
+{
+    Command_SetActivePhase cmd;
+    cmd.set_phase(static_cast<google::protobuf::uint32>(phase));
+    sendGameCommand(cmd);
+}
+
+void GameEventHandler::handleGameLeft()
+{
+    sendGameCommand(Command_LeaveGame());
+}
+
+void GameEventHandler::handleChatMessageSent(const QString &chatMessage)
+{
+    Command_GameSay cmd;
+    cmd.set_message(chatMessage.toStdString());
+    sendGameCommand(cmd);
+}
+
+void GameEventHandler::handleArrowDeletion(int creatorId, int arrowId)
+{
+    Command_DeleteArrow cmd;
+    cmd.set_arrow_id(arrowId);
+
+    auto preparedCommand = prepareGameCommand(cmd);
+
+    connect(preparedCommand, &PendingCommand::finished, this, [creatorId, arrowId, this](const Response &response) {
+        handleArrowDeletionFinished(response, creatorId, arrowId);
+    });
+
+    sendGameCommand(preparedCommand);
+}
+
+void GameEventHandler::handleArrowDeletionFinished(const Response &response, int creatorId, int arrowId)
+{
+    if (response.response_code() == Response::RespNameNotFound) {
+        emit arrowDeleted(creatorId, arrowId);
+    }
+}
+
+void GameEventHandler::eventSpectatorSay(const Event_GameSay &event,
+                                         int eventPlayerId,
+                                         const GameEventContext & /*context*/)
+{
+    const ServerInfo_User &userInfo = game->getPlayerManager()->getSpectators().value(eventPlayerId);
+    emit logSpectatorSay(userInfo, QString::fromStdString(event.message()));
+}
+
+void GameEventHandler::eventSpectatorLeave(const Event_Leave &event,
+                                           int eventPlayerId,
+                                           const GameEventContext & /*context*/)
+{
+    emit logSpectatorLeave(game->getPlayerManager()->getSpectatorName(eventPlayerId), getLeaveReason(event.reason()));
+
+    emit spectatorLeft(eventPlayerId);
+
+    game->getPlayerManager()->removeSpectator(eventPlayerId);
+
+    emitUserEvent();
+}
+
+void GameEventHandler::eventGameStateChanged(const Event_GameStateChanged &event,
+                                             int /*eventPlayerId*/,
+                                             const GameEventContext & /*context*/)
+{
+    const int playerListSize = event.player_list_size();
+
+    QVector<QPair<int, QPair<QString, QString>>> opponentDecksToDisplay;
+
+    for (int i = 0; i < playerListSize; ++i) {
+        const ServerInfo_Player &playerInfo = event.player_list(i);
+        const ServerInfo_PlayerProperties &prop = playerInfo.properties();
+        const int playerId = prop.player_id();
+        QString playerName = QString::fromStdString(prop.user_info().name());
+        emit addPlayerToAutoCompleteList("@" + playerName);
+        if (prop.spectator()) {
+            if (!game->getPlayerManager()->getSpectators().contains(playerId)) {
+                game->getPlayerManager()->addSpectator(playerId, prop);
+                emit spectatorJoined(prop);
+            }
+        } else {
+            PlayerLogic *player = game->getPlayerManager()->getPlayers().value(playerId, 0);
+            if (!player) {
+                player = game->getPlayerManager()->addPlayer(playerId, prop.user_info());
+                emit playerJoined(prop);
+            }
+            player->processPlayerInfo(playerInfo);
+            if (player->getPlayerInfo()->getLocal()) {
+                emit localPlayerDeckSelected(player, playerId, playerInfo);
+            } else {
+                if (!game->getGameMetaInfo()->proto().share_decklists_on_load()) {
+                    continue;
+                }
+
+                opponentDecksToDisplay.append(
+                    qMakePair(playerId, qMakePair(playerName, QString::fromStdString(playerInfo.deck_list()))));
+            }
+        }
+    }
+
+    processCardAttachmentsForPlayers(event);
+
+    emit remotePlayersDecksSelected(opponentDecksToDisplay);
+
+    game->getGameState()->setGameTime(event.seconds_elapsed());
+
+    if (event.game_started() && !game->getGameMetaInfo()->started()) {
+        game->getGameState()->setResuming(!game->getGameState()->isGameStateKnown());
+        game->getGameMetaInfo()->setStarted(event.game_started());
+        if (game->getGameState()->isGameStateKnown()) {
+            emit logGameStart();
+        }
+        game->getGameState()->setActivePlayer(event.active_player_id());
+        game->getGameState()->setCurrentPhase(event.active_phase());
+    } else if (!event.game_started() && game->getGameMetaInfo()->started()) {
+        game->getGameState()->setCurrentPhase(-1);
+        game->getGameState()->setActivePlayer(-1);
+        game->getGameMetaInfo()->setStarted(false);
+        emit gameStopped();
+    }
+    game->getGameState()->setGameStateKnown(true);
+    emitUserEvent();
+}
+
+void GameEventHandler::processCardAttachmentsForPlayers(const Event_GameStateChanged &event)
+{
+    for (int i = 0; i < event.player_list_size(); ++i) {
+        const ServerInfo_Player &playerInfo = event.player_list(i);
+        const ServerInfo_PlayerProperties &prop = playerInfo.properties();
+        if (!prop.spectator()) {
+            PlayerLogic *player = game->getPlayerManager()->getPlayers().value(prop.player_id(), 0);
+            if (!player) {
+                continue;
+            }
+            player->processCardAttachment(playerInfo);
+        }
+    }
+}
+
+void GameEventHandler::eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event,
+                                                    int eventPlayerId,
+                                                    const GameEventContext &context)
+{
+    PlayerLogic *player = game->getPlayerManager()->getPlayers().value(eventPlayerId, 0);
+    if (!player) {
+        return;
+    }
+    const ServerInfo_PlayerProperties &prop = event.player_properties();
+    emit playerPropertiesChanged(prop, eventPlayerId);
+
+    const auto contextType = static_cast<GameEventContext::ContextType>(getPbExtension(context));
+    switch (contextType) {
+        case GameEventContext::READY_START: {
+            bool ready = prop.ready_start();
+            if (player->getPlayerInfo()->getLocal()) {
+                emit localPlayerReadyStateChanged(player->getPlayerInfo()->getId(), ready);
+            }
+            if (ready) {
+                emit logReadyStart(player);
+            } else {
+                emit logNotReadyStart(player);
+            }
+            break;
+        }
+        case GameEventContext::CONCEDE: {
+            player->setConceded(true);
+
+            QMapIterator<int, PlayerLogic *> playerIterator(game->getPlayerManager()->getPlayers());
+            while (playerIterator.hasNext()) {
+                playerIterator.next().value()->updateZones();
+            }
+
+            emit logConcede(eventPlayerId);
+
+            break;
+        }
+        case GameEventContext::UNCONCEDE: {
+            player->setConceded(false);
+
+            QMapIterator<int, PlayerLogic *> playerIterator(game->getPlayerManager()->getPlayers());
+            while (playerIterator.hasNext()) {
+                playerIterator.next().value()->updateZones();
+            }
+
+            emit logUnconcede(eventPlayerId);
+
+            break;
+        }
+        case GameEventContext::DECK_SELECT: {
+            Context_DeckSelect deckSelect = context.GetExtension(Context_DeckSelect::ext);
+            emit logDeckSelect(player, QString::fromStdString(deckSelect.deck_hash()), deckSelect.sideboard_size());
+            if (game->getGameMetaInfo()->proto().share_decklists_on_load() && deckSelect.has_deck_list() &&
+                eventPlayerId != game->getPlayerManager()->getLocalPlayerId()) {
+                emit remotePlayerDeckSelected(QString::fromStdString(deckSelect.deck_list()), eventPlayerId,
+                                              player->getPlayerInfo()->getName());
+            }
+            break;
+        }
+        case GameEventContext::SET_SIDEBOARD_LOCK: {
+            if (player->getPlayerInfo()->getLocal()) {
+                emit localPlayerSideboardLocked(player->getPlayerInfo()->getId(), prop.sideboard_locked());
+            }
+            emit logSideboardLockSet(player, prop.sideboard_locked());
+            break;
+        }
+        case GameEventContext::CONNECTION_STATE_CHANGED: {
+            emit logConnectionStateChanged(player, prop.ping_seconds() != -1);
+            break;
+        }
+        default:;
+    }
+}
+
+void GameEventHandler::eventJoin(const Event_Join &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
+{
+    const ServerInfo_PlayerProperties &playerInfo = event.player_properties();
+    const int playerId = playerInfo.player_id();
+    QString playerName = QString::fromStdString(playerInfo.user_info().name());
+    emit addPlayerToAutoCompleteList(playerName);
+
+    if (game->getPlayerManager()->getPlayers().contains(playerId)) {
+        return;
+    }
+
+    if (playerInfo.spectator()) {
+        game->getPlayerManager()->addSpectator(playerId, playerInfo);
+        emit logJoinSpectator(playerName);
+        emit spectatorJoined(playerInfo);
+    } else {
+        PlayerLogic *newPlayer = game->getPlayerManager()->addPlayer(playerId, playerInfo.user_info());
+        emit logJoinPlayer(newPlayer);
+        emit playerJoined(playerInfo);
+    }
+
+    emitUserEvent();
+}
+
+QString GameEventHandler::getLeaveReason(Event_Leave::LeaveReason reason)
+{
+    switch (reason) {
+        case Event_Leave::USER_KICKED:
+            return tr("kicked by game host or moderator");
+            break;
+        case Event_Leave::USER_LEFT:
+            return tr("player left the game");
+            break;
+        case Event_Leave::USER_DISCONNECTED:
+            return tr("player disconnected from server");
+            break;
+        case Event_Leave::OTHER:
+        default:
+            return tr("reason unknown");
+            break;
+    }
+}
+void GameEventHandler::eventLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext & /*context*/)
+{
+    PlayerLogic *player = game->getPlayerManager()->getPlayers().value(eventPlayerId, 0);
+    if (!player) {
+        return;
+    }
+
+    player->clear();
+    emit playerLeft(eventPlayerId);
+
+    emit logLeave(player, getLeaveReason(event.reason()));
+
+    game->getPlayerManager()->removePlayer(eventPlayerId);
+
+    player->deleteLater();
+
+    // Rearrange all remaining zones so that attachment relationship updates take place
+    QMapIterator<int, PlayerLogic *> playerIterator(game->getPlayerManager()->getPlayers());
+    while (playerIterator.hasNext()) {
+        playerIterator.next().value()->updateZones();
+    }
+
+    emitUserEvent();
+}
+
+void GameEventHandler::eventKicked(const Event_Kicked & /*event*/,
+                                   int /*eventPlayerId*/,
+                                   const GameEventContext & /*context*/)
+{
+    emit gameClosed();
+    emit logKicked();
+    emit playerKicked();
+    emitUserEvent();
+}
+
+void GameEventHandler::eventReverseTurn(const Event_ReverseTurn &event,
+                                        int eventPlayerId,
+                                        const GameEventContext & /*context*/)
+{
+    PlayerLogic *player = game->getPlayerManager()->getPlayers().value(eventPlayerId, 0);
+    if (!player) {
+        return;
+    }
+
+    emit logTurnReversed(player, event.reversed());
+}
+
+void GameEventHandler::eventGameHostChanged(const Event_GameHostChanged & /*event*/,
+                                            int eventPlayerId,
+                                            const GameEventContext & /*context*/)
+{
+    game->getGameState()->setHostId(eventPlayerId);
+}
+
+void GameEventHandler::eventGameClosed(const Event_GameClosed & /*event*/,
+                                       int /*eventPlayerId*/,
+                                       const GameEventContext & /*context*/)
+{
+    game->getGameMetaInfo()->setStarted(false);
+    game->getGameState()->setGameClosed(true);
+    emit gameClosed();
+    emit logGameClosed();
+    emitUserEvent();
+}
+
+void GameEventHandler::eventSetActivePlayer(const Event_SetActivePlayer &event,
+                                            int /*eventPlayerId*/,
+                                            const GameEventContext & /*context*/)
+{
+    game->getGameState()->setActivePlayer(event.active_player_id());
+    PlayerLogic *player = game->getPlayerManager()->getPlayer(event.active_player_id());
+    if (!player) {
+        return;
+    }
+    emit logActivePlayer(player);
+    emitUserEvent();
+}
+
+void GameEventHandler::eventSetActivePhase(const Event_SetActivePhase &event,
+                                           int /*eventPlayerId*/,
+                                           const GameEventContext & /*context*/)
+{
+    const int phase = event.phase();
+    if (game->getGameState()->getCurrentPhase() != phase) {
+        emit logActivePhaseChanged(phase);
+    }
+    game->getGameState()->setCurrentPhase(phase);
+    emitUserEvent();
+}

C++/cockatrice/src/game/game_event_handler.h

@@ -0,0 +1,137 @@
+/**
+ * @file game_event_handler.h
+ * @ingroup GameLogic
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_GAME_EVENT_HANDLER_H
+#define COCKATRICE_GAME_EVENT_HANDLER_H
+
+#include "player/event_processing_options.h"
+
+#include <QLoggingCategory>
+#include <QObject>
+#include <libcockatrice/protocol/pb/event_leave.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_player.pb.h>
+
+class AbstractClient;
+class Response;
+class GameEventContainer;
+class GameEventContext;
+class GameCommand;
+class GameState;
+class MessageLogWidget;
+class CommandContainer;
+class Event_GameJoined;
+class Event_GameStateChanged;
+class Event_PlayerPropertiesChanged;
+class Event_Join;
+class Event_Leave;
+class Event_GameHostChanged;
+class Event_GameClosed;
+class Event_GameStart;
+class Event_SetActivePlayer;
+class Event_SetActivePhase;
+class Event_Ping;
+class Event_GameSay;
+class Event_Kicked;
+class Event_ReverseTurn;
+class AbstractGame;
+class PendingCommand;
+class PlayerLogic;
+
+inline Q_LOGGING_CATEGORY(GameEventHandlerLog, "game_event_handler");
+
+class GameEventHandler : public QObject
+{
+    Q_OBJECT
+
+private:
+    AbstractGame *game;
+
+public:
+    explicit GameEventHandler(AbstractGame *_game);
+
+    void handleNextTurn();
+    void handleReverseTurn();
+
+    void handleActiveLocalPlayerConceded();
+    void handleActiveLocalPlayerUnconceded();
+    void handleActivePhaseChanged(int phase);
+    void handleGameLeft();
+    void handleChatMessageSent(const QString &chatMessage);
+    void handleArrowDeletion(int creatorId, int arrowId);
+    void handleArrowDeletionFinished(const Response &response, int creatorId, int arrowId);
+
+    void eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext &context);
+    void eventSpectatorLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
+
+    void eventGameStateChanged(const Event_GameStateChanged &event, int eventPlayerId, const GameEventContext &context);
+    void processCardAttachmentsForPlayers(const Event_GameStateChanged &event);
+    void eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event,
+                                      int eventPlayerId,
+                                      const GameEventContext &context);
+    void eventJoin(const Event_Join &event, int eventPlayerId, const GameEventContext &context);
+    void eventLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
+    QString getLeaveReason(Event_Leave::LeaveReason reason);
+    void eventKicked(const Event_Kicked &event, int eventPlayerId, const GameEventContext &context);
+    void eventGameHostChanged(const Event_GameHostChanged &event, int eventPlayerId, const GameEventContext &context);
+    void eventGameClosed(const Event_GameClosed &event, int eventPlayerId, const GameEventContext &context);
+
+    void eventSetActivePlayer(const Event_SetActivePlayer &event, int eventPlayerId, const GameEventContext &context);
+    void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);
+    void eventPing(const Event_Ping &event, int eventPlayerId, const GameEventContext &context);
+    void eventReverseTurn(const Event_ReverseTurn &event, int eventPlayerId, const GameEventContext & /*context*/);
+
+    void commandFinished(const Response &response);
+
+    void
+    processGameEventContainer(const GameEventContainer &cont, AbstractClient *client, EventProcessingOptions options);
+    PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
+    PendingCommand *prepareGameCommand(const QList<const ::google::protobuf::Message *> &cmdList);
+public slots:
+    void sendGameCommand(PendingCommand *pend, int playerId = -1);
+    void sendGameCommand(const ::google::protobuf::Message &command, int playerId = -1);
+
+signals:
+    void emitUserEvent();
+    void addPlayerToAutoCompleteList(QString playerName);
+    void localPlayerDeckSelected(PlayerLogic *localPlayer, int playerId, ServerInfo_Player playerInfo);
+    void remotePlayerDeckSelected(QString deckList, int playerId, QString playerName);
+    void remotePlayersDecksSelected(QVector<QPair<int, QPair<QString, QString>>> opponentDecks);
+    void localPlayerSideboardLocked(int playerId, bool sideboardLocked);
+    void localPlayerReadyStateChanged(int playerId, bool ready);
+    void gameStopped();
+    void gameClosed();
+    void playerPropertiesChanged(const ServerInfo_PlayerProperties &prop, int playerId);
+    void playerJoined(const ServerInfo_PlayerProperties &playerInfo);
+    void playerLeft(int leavingPlayerId);
+    void playerKicked();
+    void spectatorJoined(const ServerInfo_PlayerProperties &spectatorInfo);
+    void spectatorLeft(int leavingSpectatorId);
+    void gameFlooded();
+    void containerProcessingStarted(GameEventContext context);
+    void setContextJudgeName(QString judgeName);
+    void containerProcessingDone();
+    void arrowDeleted(int creatorId, int arrowId);
+    void logSpectatorSay(ServerInfo_User userInfo, QString message);
+    void logSpectatorLeave(QString name, QString reason);
+    void logGameStart();
+    void logReadyStart(PlayerLogic *player);
+    void logNotReadyStart(PlayerLogic *player);
+    void logDeckSelect(PlayerLogic *player, QString deckHash, int sideboardSize);
+    void logSideboardLockSet(PlayerLogic *player, bool sideboardLocked);
+    void logConnectionStateChanged(PlayerLogic *player, bool connected);
+    void logJoinSpectator(QString spectatorName);
+    void logJoinPlayer(PlayerLogic *player);
+    void logLeave(PlayerLogic *player, QString reason);
+    void logKicked();
+    void logTurnReversed(PlayerLogic *player, bool reversed);
+    void logGameClosed();
+    void logActivePlayer(PlayerLogic *activePlayer);
+    void logActivePhaseChanged(int activePhase);
+    void logConcede(int playerId);
+    void logUnconcede(int playerId);
+};
+
+#endif // COCKATRICE_GAME_EVENT_HANDLER_H

C++/cockatrice/src/game/game_meta_info.cpp

@@ -0,0 +1,7 @@
+#include "game_meta_info.h"
+
+#include "abstract_game.h"
+
+GameMetaInfo::GameMetaInfo(AbstractGame *parent) : QObject(parent)
+{
+}

C++/cockatrice/src/game/game_meta_info.h

@@ -0,0 +1,113 @@
+/**
+ * @file game_meta_info.h
+ * @ingroup GameLogic
+ */
+//! \todo Document this file.
+
+#ifndef GAME_META_INFO_H
+#define GAME_META_INFO_H
+
+#include <QMap>
+#include <QObject>
+#include <libcockatrice/protocol/pb/serverinfo_game.pb.h>
+
+// Translation layer class to expose protobuf safely and hook it up to Qt Signals.
+// This class de-couples the domain object (i.e. the GameMetaInfo) from the network object.
+// If the network object changes, only this class needs to be adjusted.
+
+class AbstractGame;
+class GameMetaInfo : public QObject
+{
+    Q_OBJECT
+public:
+    explicit GameMetaInfo(AbstractGame *parent);
+
+    QMap<int, QString> roomGameTypes;
+
+    // Populate from protobuf (e.g., after network message)
+    void setFromProto(const ServerInfo_Game &gi)
+    {
+        gameInfo_.CopyFrom(gi);
+    }
+
+    const ServerInfo_Game &proto() const
+    {
+        return gameInfo_;
+    }
+
+    // High-level getters that avoid exposing protobuf directly
+    int gameId() const
+    {
+        return gameInfo_.game_id();
+    }
+    int maxPlayers() const
+    {
+        return gameInfo_.max_players();
+    }
+    QString description() const
+    {
+        return QString::fromStdString(gameInfo_.description());
+    }
+    bool started() const
+    {
+        return gameInfo_.started();
+    }
+    bool spectatorsOmniscient() const
+    {
+        return gameInfo_.spectators_omniscient();
+    }
+    bool spectatorsCanChat() const
+    {
+        return gameInfo_.spectators_can_chat();
+    }
+    int gameTypesSize() const
+    {
+        return gameInfo_.game_types_size();
+    }
+    int gameTypeIdAt(int index) const
+    {
+        return gameInfo_.game_types(index);
+    }
+
+    QMap<int, QString> getRoomGameTypes() const
+    {
+        return roomGameTypes;
+    }
+
+    void setRoomGameTypes(QMap<int, QString> _roomGameTypes)
+    {
+        roomGameTypes = _roomGameTypes;
+    }
+
+    QString findRoomGameType(int index)
+    {
+        return roomGameTypes.find(gameInfo_.game_types(index)).value();
+    }
+
+public slots:
+    void setStarted(bool s)
+    {
+        if (gameInfo_.started() == s) {
+            return;
+        }
+        gameInfo_.set_started(s);
+        emit startedChanged(s);
+    }
+    void setSpectatorsOmniscient(bool v)
+    {
+        if (gameInfo_.spectators_omniscient() == v) {
+            return;
+        }
+        gameInfo_.set_spectators_omniscient(v);
+        emit spectatorsOmniscienceChanged(v);
+    }
+
+signals:
+    void startedChanged(bool started);
+    void spectatorsOmniscienceChanged(bool omniscient);
+
+private:
+    ServerInfo_Game gameInfo_;
+};
+
+#endif // GAME_META_INFO_H

C++/cockatrice/src/game/game_state.cpp

@@ -0,0 +1,41 @@
+#include "game_state.h"
+
+#include "abstract_game.h"
+
+GameState::GameState(AbstractGame *parent,
+                     int _secondsElapsed,
+                     int _hostId,
+                     bool _isLocalGame,
+                     const QList<AbstractClient *> _clients,
+                     bool _gameStateKnown,
+                     bool _resuming,
+                     int _currentPhase,
+                     bool _gameClosed)
+    : QObject(parent), gameTimer(nullptr), secondsElapsed(_secondsElapsed), hostId(_hostId), isLocalGame(_isLocalGame),
+      clients(_clients), gameStateKnown(_gameStateKnown), resuming(_resuming), currentPhase(_currentPhase),
+      activePlayer(-1), gameClosed(_gameClosed)
+{
+    gameTimer = new QTimer(this);
+    gameTimer->setInterval(1000);
+    connect(gameTimer, &QTimer::timeout, this, &GameState::incrementGameTime);
+    gameTimer->start();
+}
+
+void GameState::incrementGameTime()
+{
+    setGameTime(++secondsElapsed);
+}
+
+void GameState::setGameTime(int _secondsElapsed)
+{
+    secondsElapsed = _secondsElapsed;
+    int seconds = _secondsElapsed;
+    int minutes = seconds / 60;
+    seconds -= minutes * 60;
+    int hours = minutes / 60;
+    minutes -= hours * 60;
+
+    emit updateTimeElapsedLabel(QString::number(hours).rightJustified(2, '0') + ":" +
+                                QString::number(minutes).rightJustified(2, '0') + ":" +
+                                QString::number(seconds).rightJustified(2, '0'));
+}

C++/cockatrice/src/game/game_state.h

@@ -0,0 +1,137 @@
+/**
+ * @file game_state.h
+ * @ingroup GameLogic
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_GAME_STATE_H
+#define COCKATRICE_GAME_STATE_H
+
+#include <QTimer>
+#include <libcockatrice/network/client/abstract/abstract_client.h>
+
+class AbstractGame;
+class ServerInfo_PlayerProperties;
+class ServerInfo_User;
+
+class GameState : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit GameState(AbstractGame *parent,
+                       int secondsElapsed,
+                       int hostId,
+                       bool isLocalGame,
+                       QList<AbstractClient *> clients,
+                       bool gameStateKnown,
+                       bool resuming,
+                       int currentPhase,
+                       bool gameClosed);
+
+    void setHostId(int _hostId)
+    {
+        hostId = _hostId;
+    }
+
+    QList<AbstractClient *> getClients() const
+    {
+        return clients;
+    }
+
+    bool getIsLocalGame() const
+    {
+        return isLocalGame;
+    }
+
+    bool isResuming() const
+    {
+        return resuming;
+    }
+
+    void setResuming(bool _resuming)
+    {
+        resuming = _resuming;
+    }
+
+    bool isGameStateKnown() const
+    {
+        return gameStateKnown;
+    }
+
+    int getCurrentPhase() const
+    {
+        return currentPhase;
+    }
+
+    void setCurrentPhase(int phase)
+    {
+        currentPhase = phase;
+        emit activePhaseChanged(phase);
+    }
+
+    void setActivePlayer(int activePlayerId)
+    {
+        activePlayer = activePlayerId;
+        emit activePlayerChanged(activePlayer);
+    }
+
+    int getActivePlayer() const
+    {
+        return activePlayer;
+    }
+
+    void setGameClosed(bool closed)
+    {
+        gameClosed = closed;
+    }
+
+    bool isGameClosed() const
+    {
+        return gameClosed;
+    }
+
+    void onStartedChanged(bool _started)
+    {
+        if (_started) {
+            emit gameStarted(_started);
+        } else {
+            emit gameStopped();
+        }
+    }
+
+    void setGameStateKnown(bool known)
+    {
+        gameStateKnown = known;
+    }
+
+    int getHostId() const
+    {
+        return hostId;
+    }
+
+signals:
+    void updateTimeElapsedLabel(QString newTime);
+    void gameStarted(bool resuming);
+    void gameStopped();
+    void activePhaseChanged(int activePhase);
+    void activePlayerChanged(int playerId);
+
+public slots:
+    void incrementGameTime();
+    void setGameTime(int _secondsElapsed);
+
+private:
+    QTimer *gameTimer;
+    int secondsElapsed;
+    int hostId;
+    const bool isLocalGame;
+    QList<AbstractClient *> clients;
+    bool gameStateKnown;
+    bool resuming;
+    int currentPhase;
+    int activePlayer;
+    bool gameClosed;
+};
+
+#endif // COCKATRICE_GAME_STATE_H

C++/cockatrice/src/game/phase.cpp

@@ -0,0 +1,60 @@
+#include "phase.h"
+
+Phase::Phase(const QString &_name, const QString &_color, const QString &_soundFileName)
+    : name(_name), color(_color), soundFileName(_soundFileName)
+{
+}
+
+/**
+ * @return The translated name for the phase
+ */
+QString Phase::getName() const
+{
+    return tr(name.toUtf8().data());
+}
+
+Phase Phases::getPhase(int phase)
+{
+    if (0 <= phase && phase < Phases::phaseTypesCount) {
+        return phases[phase];
+    } else {
+        return unknownPhase;
+    }
+}
+
+int Phases::getLastSubphase(int phase)
+{
+    if (0 <= phase && phase < Phases::phaseTypesCount) {
+        return subPhasesEnd[phase];
+    } else {
+        return phase;
+    }
+}
+
+QVector<int> getSubPhasesEnd()
+{
+    QVector<int> array(Phases::phaseTypesCount);
+    for (int phaseEnd = Phases::phaseTypesCount - 1; phaseEnd >= 0;) {
+        int subPhase = phaseEnd;
+        for (; subPhase >= 0 && Phases::phases[phaseEnd].color == Phases::phases[subPhase].color; --subPhase) {
+            array[subPhase] = phaseEnd;
+        }
+        phaseEnd = subPhase;
+    }
+    return array;
+}
+
+const Phase Phases::unknownPhase(QT_TRANSLATE_NOOP("Phase", "Unknown Phase"), "black", "unknown_phase");
+const Phase Phases::phases[Phases::phaseTypesCount] = {
+    {QT_TRANSLATE_NOOP("Phase", "Untap"), "green", "untap_step"},
+    {QT_TRANSLATE_NOOP("Phase", "Upkeep"), "green", "upkeep_step"},
+    {QT_TRANSLATE_NOOP("Phase", "Draw"), "green", "draw_step"},
+    {QT_TRANSLATE_NOOP("Phase", "First Main"), "blue", "main_1"},
+    {QT_TRANSLATE_NOOP("Phase", "Beginning of Combat"), "red", "start_combat"},
+    {QT_TRANSLATE_NOOP("Phase", "Declare Attackers"), "red", "attack_step"},
+    {QT_TRANSLATE_NOOP("Phase", "Declare Blockers"), "red", "block_step"},
+    {QT_TRANSLATE_NOOP("Phase", "Combat Damage"), "red", "damage_step"},
+    {QT_TRANSLATE_NOOP("Phase", "End of Combat"), "red", "end_combat"},
+    {QT_TRANSLATE_NOOP("Phase", "Second Main"), "blue", "main_2"},
+    {QT_TRANSLATE_NOOP("Phase", "End/Cleanup"), "green", "end_step"}};
+const QVector<int> Phases::subPhasesEnd = getSubPhasesEnd();

C++/cockatrice/src/game/phase.h

@@ -0,0 +1,37 @@
+/**
+ * @file phase.h
+ * @ingroup GameLogic
+ */
+//! \todo Document this file.
+
+#ifndef PHASE_H
+#define PHASE_H
+
+#include <QApplication>
+#include <QString>
+
+class Phase
+{
+    Q_DECLARE_TR_FUNCTIONS(Phase)
+
+    QString name;
+
+public:
+    QString color, soundFileName;
+    Phase(const QString &_name, const QString &_color, const QString &_soundFileName);
+
+    QString getName() const;
+};
+
+struct Phases
+{
+    const static int phaseTypesCount = 11;
+    const static Phase unknownPhase;
+    const static Phase phases[phaseTypesCount];
+    const static QVector<int> subPhasesEnd;
+
+    static Phase getPhase(int);
+    static int getLastSubphase(int phase);
+};
+
+#endif // PHASE_H

C++/cockatrice/src/game/player/event_processing_options.h

@@ -0,0 +1,25 @@
+/**
+ * @file event_processing_options.h
+ * @ingroup GameLogicPlayers
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_EVENT_PROCESSING_OPTIONS_H
+#define COCKATRICE_EVENT_PROCESSING_OPTIONS_H
+
+#include <QFlags>
+
+// Define the base enum
+enum EventProcessingOption
+{
+    SKIP_REVEAL_WINDOW = 0x0001,
+    SKIP_TAP_ANIMATION = 0x0002
+};
+
+// Wrap it in a QFlags typedef
+Q_DECLARE_FLAGS(EventProcessingOptions, EventProcessingOption)
+
+// Add operator overloads (|, &, etc.)
+Q_DECLARE_OPERATORS_FOR_FLAGS(EventProcessingOptions)
+
+#endif // COCKATRICE_EVENT_PROCESSING_OPTIONS_H

C++/cockatrice/src/game/player/player_actions.h

@@ -0,0 +1,254 @@
+/**
+ * @file player_actions.h
+ *  @ingroup GameLogicActions
+ * @ingroup GameLogicPlayers
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_PLAYER_ACTIONS_H
+#define COCKATRICE_PLAYER_ACTIONS_H
+
+#include "../../game_graphics/board/card_item.h"
+#include "../../game_graphics/dialogs/dlg_create_token.h"
+#include "../../game_graphics/dialogs/dlg_move_top_cards_until.h"
+#include "../../game_graphics/player/card_menu_action_type.h"
+#include "event_processing_options.h"
+#include "player_logic.h"
+
+#include <QMenu>
+#include <QObject>
+#include <libcockatrice/card/relation/card_relation_type.h>
+#include <libcockatrice/filters/filter_string.h>
+
+namespace google
+{
+namespace protobuf
+{
+class Message;
+}
+} // namespace google
+
+class Command_MoveCard;
+class GameEventContext;
+class PendingCommand;
+class PlayerLogic;
+class PlayerActions : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum CardsToReveal
+    {
+        RANDOM_CARD_FROM_ZONE = -2
+    };
+
+    explicit PlayerActions(PlayerLogic *player);
+
+    void sendGameCommand(PendingCommand *pend);
+    void sendGameCommand(const google::protobuf::Message &command);
+
+    PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
+    PendingCommand *prepareGameCommand(const QList<const ::google::protobuf::Message *> &cmdList);
+
+    void moveOneCardUntil(CardItem *card);
+    void stopMoveTopCardsUntil();
+
+    [[nodiscard]] bool isMovingCardsUntil() const
+    {
+        return movingCardsUntil;
+    }
+
+signals:
+    void requestViewTopCardsDialog(int defaultNumberTopCards, int deckSize);
+    void requestViewBottomCardsDialog(int defaultNumberBottomCards, int deckSize);
+    void requestShuffleTopDialog(int defaultNumberTopCards, int maxCards);
+    void requestShuffleBottomDialog(int defaultNumberBottomCards, int maxCards);
+    void requestMulliganDialog(int startSize, int handSize, int deckSize);
+    void requestDrawCardsDialog(int defaultNumberTopCards, int deckSize);
+    void requestMoveTopCardsToDialog(int defaultNumberTopCards,
+                                     int maxCards,
+                                     const QString &targetZone,
+                                     const QString &zoneDisplayName,
+                                     bool faceDown);
+    void requestMoveTopCardsUntilDialog(MoveTopCardsUntilOptions options);
+    void requestMoveBottomCardsToDialog(int defaultNumberBottomCards,
+                                        int maxCards,
+                                        const QString &targetZone,
+                                        const QString &zoneDisplayName,
+                                        bool faceDown);
+    void requestDrawBottomCardsDialog(int defaultNumberBottomCards, int maxCards);
+    void requestRollDieDialog();
+    void requestCreateTokenDialog(const QStringList &predefinedTokens);
+    void requestCreateRelatedFromRelationDialog(const CardItem *sourceCard, const CardRelation *cardRelation);
+    void requestMoveCardXCardsFromTopDialog(int defaultNumberTopCardsToPlaceBelow, int deckSize);
+    void requestSetPTDialog(const QString &oldPT);
+    void requestSetAnnotationDialog(const QString &oldAnnotation);
+    void requestSetCardCounterDialog(int counterId, const QString &oldValueForDlg);
+    void requestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed = false);
+    void requestSortHand(const QList<CardList::SortOption> &options);
+    void requestEnableAndSetCreateAnotherTokenAction(const QString &lastTokenName);
+    void requestSetLastToken(CardInfoPtr lastToken);
+
+public slots:
+    void setLastToken(CardInfoPtr cardInfo);
+    void setLastTokenInfo(CardInfoPtr cardInfo);
+    void playCard(CardItem *c, bool faceDown);
+    void playCardToTable(const CardItem *c, bool faceDown);
+
+    void actUntapAll();
+    void actRequestRollDieDialog();
+    void actRollDie(int sides, int count);
+    void actFlipCoin();
+    void actRequestCreateTokenDialog(const QStringList &predefinedTokens);
+    void actCreateToken(TokenInfo tokenToCreate);
+    void actCreateAnotherToken();
+    void actRequestCreateRelatedFromRelationDialog(const CardItem *sourceCard, const CardRelation *cardRelation);
+    bool createRelatedFromRelation(const CardItem *sourceCard, const CardRelation *cardRelation, int variableCount);
+    void onRelatedCardCreated(const CardItem *sourceCard, const CardRelation *cardRelation);
+    void setLastRelatedCreationSucceeded(bool succeeded)
+    {
+        lastRelatedCreationSucceeded = succeeded;
+    }
+    void actShuffle();
+    void actRequestShuffleTopDialog();
+    void actShuffleTop(int number);
+    void actRequestShuffleBottomDialog();
+    void actShuffleBottom(int number);
+    void actDrawCard();
+    void actRequestDrawCardsDialog();
+    void actDrawCards(int number);
+    void actUndoDraw();
+    void actRequestMulliganDialog();
+    void actMulligan(int number);
+    void actMulliganSameSize();
+    void actMulliganMinusOne();
+    void doMulligan(int number);
+
+    void actPlay(QList<CardItem *> selectedCards);
+    void actPlayFacedown(QList<CardItem *> selectedCards);
+    void actHide(QList<CardItem *> selectedCards);
+
+    void actMoveTopCardToPlay();
+    void actMoveTopCardToPlayFaceDown();
+    void actMoveTopCardToGrave();
+    void actMoveTopCardToExile();
+    void actMoveTopCardsToGrave();
+    void actMoveTopCardsToGraveFaceDown();
+    void actMoveTopCardsToExile();
+    void actMoveTopCardsToExileFaceDown();
+    void actRequestMoveTopCardsUntilDialog();
+    void moveTopCardsUntil(const QString &expr, MoveTopCardsUntilOptions options);
+    void actMoveTopCardToBottom();
+    void actRequestMoveTopCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
+    void moveTopCardsTo(int number, const QString &targetZone, bool faceDown);
+    void actDrawBottomCard();
+    void actRequestDrawBottomCardsDialog();
+    void actDrawBottomCards(int number);
+    void actMoveBottomCardToPlay();
+    void actMoveBottomCardToPlayFaceDown();
+    void actMoveBottomCardToGrave();
+    void actMoveBottomCardToExile();
+    void actMoveBottomCardsToGrave();
+    void actMoveBottomCardsToGraveFaceDown();
+    void actMoveBottomCardsToExile();
+    void actMoveBottomCardsToExileFaceDown();
+    void actMoveBottomCardToTop();
+    void actRequestMoveBottomCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
+    void moveBottomCardsTo(int number, const QString &targetZone, bool faceDown);
+
+    void actSelectAll();
+    void actSelectRow();
+    void actSelectColumn();
+
+    void actViewLibrary();
+    void actViewHand();
+    void actRequestViewTopCardsDialog();
+    void actViewTopCards(int number);
+    void actRequestViewBottomCardsDialog();
+    void actViewBottomCards(int number);
+    void actAlwaysRevealTopCard(bool alwaysRevealTopCard);
+    void actAlwaysLookAtTopCard(bool alwaysRevealTopCard);
+    void actViewGraveyard();
+    void actLendLibrary(int lendToPlayerId);
+    void actRevealTopCards(int revealToPlayerId, int amount);
+    void actRevealRandomGraveyardCard(int revealToPlayerId);
+    void actViewRfg();
+    void actViewSideboard();
+
+    void actSayMessage();
+
+    void actOpenDeckInDeckEditor();
+    void actCreatePredefinedToken();
+    void actCreateRelatedCard();
+    void actCreateAllRelatedCards();
+
+    void actRequestMoveCardXCardsFromTopDialog();
+    void actMoveCardXCardsFromTop(QList<CardItem *> selectedCards, int number);
+    void actRemoveCardCounter(QList<CardItem *> selectedCards, int counterId);
+    void actAddCardCounter(QList<CardItem *> selectedCards, int counterId);
+    void actRequestSetCardCounterDialog(QList<CardItem *> selectedCards, int counterId);
+    void actSetCardCounter(QList<CardItem *> selectedCards, int counterId, const QString &counterValue);
+    void actIncrementAllCardCounters(QList<CardItem *> cardsToUpdate);
+    void actAttach();
+    void actUnattach(QList<CardItem *> selectedCards);
+    void actDrawArrow();
+    void actIncPT(QList<CardItem *> selectedCards, int deltaP, int deltaT);
+    void actResetPT(QList<CardItem *> selectedCards);
+    void actRequestSetPTDialog(QList<CardItem *> selectedCards);
+    void actSetPT(QList<CardItem *> selectedCards, const QString &pt);
+    void actIncP(QList<CardItem *> selectedCards);
+    void actDecP(QList<CardItem *> selectedCards);
+    void actIncT(QList<CardItem *> selectedCards);
+    void actDecT(QList<CardItem *> selectedCards);
+    void actIncPT(QList<CardItem *> selectedCards);
+    void actDecPT(QList<CardItem *> selectedCards);
+    void actFlowP(QList<CardItem *> selectedCards);
+    void actFlowT(QList<CardItem *> selectedCards);
+
+    void actReduceLifeByPower(QList<CardItem *> selectedCards);
+
+    void actRequestSetAnnotationDialog(QList<CardItem *> selectedCards);
+    void actSetAnnotation(QList<CardItem *> selectedCards, const QString &annotation);
+    void actReveal(QList<CardItem *> selectedCards, QAction *action);
+    void actRevealHand(int revealToPlayerId);
+    void actRevealRandomHandCard(int revealToPlayerId);
+    void actRevealLibrary(int revealToPlayerId);
+
+    void actSortHand();
+
+    void cardMenuAction(QList<CardItem *> selectedCards, CardMenuActionType type);
+
+private:
+    PlayerLogic *player;
+
+    int defaultNumberTopCards = 1;
+    int defaultNumberTopCardsToPlaceBelow = 1;
+    int defaultNumberBottomCards = 1;
+    int defaultNumberDieRoll = 20;
+
+    TokenInfo lastTokenInfo;
+    int lastTokenTableRow;
+
+    bool movingCardsUntil;
+    QTimer *moveTopCardTimer;
+    FilterString movingCardsUntilFilter;
+    int movingCardsUntilCounter = 0;
+    MoveTopCardsUntilOptions movingCardsUntilOptions;
+
+    bool lastRelatedCreationSucceeded = false;
+
+    void createCard(const CardItem *sourceCard,
+                    const QString &dbCardName,
+                    CardRelationType attach = CardRelationType::DoesNotAttach,
+                    bool persistent = false,
+                    bool faceDown = false);
+
+    void playSelectedCards(QList<CardItem *> selectedCards, bool faceDown = false);
+
+    void cmdSetTopCard(Command_MoveCard &cmd);
+    void cmdSetBottomCard(Command_MoveCard &cmd);
+
+    void offsetCardCounter(QList<CardItem *> selectedCards, int counterId, int offset);
+};
+
+#endif // COCKATRICE_PLAYER_ACTIONS_H

C++/cockatrice/src/game/player/player_event_handler.cpp

@@ -0,0 +1,664 @@
+#include "player_event_handler.h"
+
+#include "../../game_graphics/board/arrow_item.h"
+#include "../../game_graphics/board/card_item.h"
+#include "../../game_graphics/zones/view_zone.h"
+#include "../../interface/widgets/tabs/tab_game.h"
+#include "../board/arrow_data.h"
+#include "../board/card_list.h"
+#include "player_actions.h"
+#include "player_logic.h"
+
+#include <libcockatrice/protocol/pb/command_set_card_attr.pb.h>
+#include <libcockatrice/protocol/pb/context_move_card.pb.h>
+#include <libcockatrice/protocol/pb/context_undo_draw.pb.h>
+#include <libcockatrice/protocol/pb/event_attach_card.pb.h>
+#include <libcockatrice/protocol/pb/event_change_zone_properties.pb.h>
+#include <libcockatrice/protocol/pb/event_create_arrow.pb.h>
+#include <libcockatrice/protocol/pb/event_create_counter.pb.h>
+#include <libcockatrice/protocol/pb/event_create_token.pb.h>
+#include <libcockatrice/protocol/pb/event_del_counter.pb.h>
+#include <libcockatrice/protocol/pb/event_delete_arrow.pb.h>
+#include <libcockatrice/protocol/pb/event_destroy_card.pb.h>
+#include <libcockatrice/protocol/pb/event_draw_cards.pb.h>
+#include <libcockatrice/protocol/pb/event_dump_zone.pb.h>
+#include <libcockatrice/protocol/pb/event_flip_card.pb.h>
+#include <libcockatrice/protocol/pb/event_game_log_notice.pb.h>
+#include <libcockatrice/protocol/pb/event_game_say.pb.h>
+#include <libcockatrice/protocol/pb/event_move_card.pb.h>
+#include <libcockatrice/protocol/pb/event_reveal_cards.pb.h>
+#include <libcockatrice/protocol/pb/event_roll_die.pb.h>
+#include <libcockatrice/protocol/pb/event_set_card_attr.pb.h>
+#include <libcockatrice/protocol/pb/event_set_card_counter.pb.h>
+#include <libcockatrice/protocol/pb/event_set_counter.pb.h>
+#include <libcockatrice/protocol/pb/event_shuffle.pb.h>
+#include <libcockatrice/utility/color.h>
+#include <libcockatrice/utility/zone_names.h>
+
+PlayerEventHandler::PlayerEventHandler(PlayerLogic *_player) : QObject(_player), player(_player)
+{
+    connect(this, &PlayerEventHandler::requestCardMenuUpdate, player, &PlayerLogic::requestCardMenuUpdate);
+}
+
+void PlayerEventHandler::eventGameSay(const Event_GameSay &event)
+{
+    emit logSay(player, QString::fromStdString(event.message()));
+}
+
+void PlayerEventHandler::eventShuffle(const Event_Shuffle &event)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+    auto &cardList = zone->getCards();
+    int absStart = event.start();
+    if (absStart < 0) { // negative indexes start from the end
+        absStart += cardList.length();
+    }
+
+    // close all views that contain shuffled cards
+    for (ZoneViewZone *view : zone->getViews()) {
+        if (view != nullptr) {
+            int length = view->getLogic()->getCards().length();
+            // we want to close empty views as well
+            if (length == 0 || length > absStart) { // note this assumes views always start at the top of the library
+                view->close();
+            }
+        } else {
+            qWarning() << zone->getName() << "of" << player->getPlayerInfo()->getName() << "holds empty zoneview!";
+        }
+    }
+
+    // remove revealed card name on top of decks
+    if (absStart == 0 && !cardList.isEmpty()) {
+        cardList.first()->setCardRef({});
+        emit zone->updateGraphics();
+    }
+
+    emit logShuffle(player, zone, event.start(), event.end());
+}
+
+void PlayerEventHandler::eventRollDie(const Event_RollDie &event)
+{
+    if (!event.values().empty()) {
+        QList<uint> rolls(event.values().begin(), event.values().end());
+        std::sort(rolls.begin(), rolls.end());
+        emit logRollDie(player, static_cast<int>(event.sides()), rolls);
+    } else if (event.value()) {
+        // Backwards compatibility for old clients
+        emit logRollDie(player, static_cast<int>(event.sides()), {event.value()});
+    }
+}
+
+void PlayerEventHandler::eventCreateArrow(const Event_CreateArrow &event)
+{
+    auto data = QSharedPointer<ArrowData>::create(ArrowData::fromProto(
+        event.arrow_info(), player->getPlayerInfo()->getId(), player->getPlayerInfo()->getLocal()));
+
+    const auto &playerList = player->getGame()->getPlayerManager()->getPlayers();
+    PlayerLogic *startPlayer = playerList.value(data->startPlayerId);
+    PlayerLogic *targetPlayer = playerList.value(data->targetPlayerId);
+
+    QString startCardName, targetCardName;
+    if (startPlayer) {
+        if (auto *zone = startPlayer->getZones().value(data->startZone)) {
+            if (auto *card = zone->getCard(data->startCardId)) {
+                startCardName = card->getName();
+            }
+        }
+    }
+    if (!data->isPlayerTargeted() && targetPlayer) {
+        if (auto *zone = targetPlayer->getZones().value(data->targetZone)) {
+            if (auto *card = zone->getCard(data->targetCardId)) {
+                targetCardName = card->getName();
+            }
+        }
+    }
+
+    emit player->arrowCreateRequested(data);
+
+    if (startPlayer && targetPlayer && !startCardName.isEmpty() &&
+        (data->isPlayerTargeted() || !targetCardName.isEmpty())) {
+        emit logCreateArrow(player, startPlayer, startCardName, targetPlayer, targetCardName, data->isPlayerTargeted());
+    }
+}
+
+void PlayerEventHandler::eventDeleteArrow(const Event_DeleteArrow &event)
+{
+    emit player->arrowDeleted(player->getPlayerInfo()->getId(), event.arrow_id());
+}
+
+void PlayerEventHandler::eventCreateToken(const Event_CreateToken &event)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+
+    CardRef cardRef = {QString::fromStdString(event.card_name()), QString::fromStdString(event.card_provider_id())};
+    CardItem *card = new CardItem(player, nullptr, cardRef, event.card_id());
+    // use db PT if not provided in event and not face-down
+    if (!QString::fromStdString(event.pt()).isEmpty()) {
+        card->setPT(QString::fromStdString(event.pt()));
+    } else if (!event.face_down()) {
+        ExactCard dbCard = card->getCard();
+        if (dbCard) {
+            card->setPT(dbCard.getInfo().getPowTough());
+        }
+    }
+    card->setColor(QString::fromStdString(event.color()));
+    card->setAnnotation(QString::fromStdString(event.annotation()));
+    card->setDestroyOnZoneChange(event.destroy_on_zone_change());
+    card->setFaceDown(event.face_down());
+
+    emit logCreateToken(player, card->getName(), card->getPT(), card->getFaceDown());
+    zone->addCard(card, true, event.x(), event.y());
+}
+
+void PlayerEventHandler::eventSetCardAttr(const Event_SetCardAttr &event,
+                                          const GameEventContext &context,
+                                          EventProcessingOptions options)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+
+    if (!event.has_card_id()) {
+        const CardList &cards = zone->getCards();
+        for (int i = 0; i < cards.size(); ++i) {
+            setCardAttrHelper(context, cards.at(i), event.attribute(), QString::fromStdString(event.attr_value()), true,
+                              options);
+        }
+        if (event.attribute() == AttrTapped) {
+            emit logSetTapped(player, nullptr, event.attr_value() == "1");
+        }
+    } else {
+        CardItem *card = zone->getCard(event.card_id());
+        if (!card) {
+            qWarning() << "PlayerEventHandler::eventSetCardAttr: card id=" << event.card_id() << "not found";
+            return;
+        }
+        setCardAttrHelper(context, card, event.attribute(), QString::fromStdString(event.attr_value()), false, options);
+    }
+}
+
+void PlayerEventHandler::setCardAttrHelper(const GameEventContext &context,
+                                           CardItem *card,
+                                           CardAttribute attribute,
+                                           const QString &avalue,
+                                           bool allCards,
+                                           EventProcessingOptions options)
+{
+    if (card == nullptr) {
+        return;
+    }
+
+    bool moveCardContext = context.HasExtension(Context_MoveCard::ext);
+    switch (attribute) {
+        case AttrTapped: {
+            bool tapped = avalue == "1";
+            if (!(!tapped && card->getDoesntUntap() && allCards)) {
+                if (!allCards) {
+                    emit logSetTapped(player, card, tapped);
+                }
+                bool canAnimate = !options.testFlag(SKIP_TAP_ANIMATION) && !moveCardContext;
+                card->setTapped(tapped, canAnimate);
+            }
+            break;
+        }
+        case AttrAttacking: {
+            card->setAttacking(avalue == "1");
+            break;
+        }
+        case AttrFaceDown: {
+            card->setFaceDown(avalue == "1");
+            break;
+        }
+        case AttrColor: {
+            card->setColor(avalue);
+            break;
+        }
+        case AttrAnnotation: {
+            emit logSetAnnotation(player, card, avalue);
+            card->setAnnotation(avalue);
+            break;
+        }
+        case AttrDoesntUntap: {
+            bool value = (avalue == "1");
+            emit logSetDoesntUntap(player, card, value);
+            card->setDoesntUntap(value);
+            break;
+        }
+        case AttrPT: {
+            emit logSetPT(player, card, avalue);
+            card->setPT(avalue);
+            break;
+        }
+    }
+}
+
+void PlayerEventHandler::eventSetCardCounter(const Event_SetCardCounter &event)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+
+    CardItem *card = zone->getCard(event.card_id());
+    if (!card) {
+        return;
+    }
+
+    int oldValue = card->getCounters().value(event.counter_id(), 0);
+    card->setCounter(event.counter_id(), event.counter_value());
+    emit requestCardMenuUpdate(card);
+    emit logSetCardCounter(player, card->getName(), event.counter_id(), event.counter_value(), oldValue);
+}
+
+void PlayerEventHandler::eventCreateCounter(const Event_CreateCounter &event)
+{
+    player->addCounter(event.counter_info());
+}
+
+void PlayerEventHandler::eventSetCounter(const Event_SetCounter &event)
+{
+    CounterState *ctr = player->getCounters().value(event.counter_id(), nullptr);
+    if (!ctr) {
+        return;
+    }
+    int oldValue = ctr->getValue();
+    ctr->setValue(event.value());
+    emit logSetCounter(player, ctr->getName(), event.value(), oldValue);
+}
+
+void PlayerEventHandler::eventDelCounter(const Event_DelCounter &event)
+{
+    player->delCounter(event.counter_id());
+}
+
+void PlayerEventHandler::eventDumpZone(const Event_DumpZone &event)
+{
+    PlayerLogic *zoneOwner = player->getGame()->getPlayerManager()->getPlayers().value(event.zone_owner_id(), 0);
+    if (!zoneOwner) {
+        return;
+    }
+    CardZoneLogic *zone = zoneOwner->getZones().value(QString::fromStdString(event.zone_name()), 0);
+    if (!zone) {
+        return;
+    }
+    emit logDumpZone(player, zone, event.number_cards(), event.is_reversed());
+}
+
+void PlayerEventHandler::eventMoveCard(const Event_MoveCard &event, const GameEventContext &context)
+{
+    PlayerLogic *startPlayer = player->getGame()->getPlayerManager()->getPlayers().value(event.start_player_id());
+    if (!startPlayer) {
+        return;
+    }
+    QString startZoneString = QString::fromStdString(event.start_zone());
+    CardZoneLogic *startZone = startPlayer->getZones().value(startZoneString, 0);
+    PlayerLogic *targetPlayer = player->getGame()->getPlayerManager()->getPlayers().value(event.target_player_id());
+    if (!targetPlayer) {
+        return;
+    }
+    CardZoneLogic *targetZone;
+    if (event.has_target_zone()) {
+        targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
+    } else {
+        targetZone = startZone;
+    }
+    if (!startZone || !targetZone) {
+        return;
+    }
+
+    int position = event.position();
+    int x = event.x();
+    int y = event.y();
+
+    int logPosition = position;
+    int logX = x;
+    if (x == -1) {
+        x = 0;
+    }
+    CardItem *card = startZone->takeCard(position, event.card_id(), startZone != targetZone);
+    if (card == nullptr) {
+        return;
+    }
+    if (startZone != targetZone) {
+        card->deleteCardInfoPopup();
+    }
+    if (event.has_card_name()) {
+        QString name = QString::fromStdString(event.card_name());
+        QString providerId =
+            event.has_new_card_provider_id() ? QString::fromStdString(event.new_card_provider_id()) : "";
+        card->setCardRef({name, providerId});
+    }
+
+    if (card->getAttachedTo() && (startZone != targetZone)) {
+        CardItem *parentCard = card->getAttachedTo();
+        card->setAttachedTo(nullptr);
+        parentCard->getZone()->reorganizeCards();
+    }
+
+    card->deleteDragItem();
+
+    card->setId(event.new_card_id());
+    card->setFaceDown(event.face_down());
+    if (startZone != targetZone) {
+        card->setBeingPointedAt(false);
+        card->setHovered(false);
+
+        const QList<CardItem *> &attachedCards = card->getAttachedCards();
+        for (auto attachedCard : attachedCards) {
+            emit targetZone->cardAdded(attachedCard);
+        }
+
+        if (startZone->getPlayer() != targetZone->getPlayer()) {
+            card->setOwner(targetZone->getPlayer());
+        }
+    }
+
+    // The log event has to be sent before the card is added to the target zone
+    // because the addCard function can modify the card object.
+    if (context.HasExtension(Context_UndoDraw::ext)) {
+        emit logUndoDraw(player, card->getName());
+    } else {
+        emit logMoveCard(player, card, startZone, logPosition, targetZone, logX);
+    }
+
+    targetZone->addCard(card, true, x, y);
+
+    emit cardZoneChanged(card, startZone == targetZone);
+    emit requestCardMenuUpdate(card);
+
+    if (player->getPlayerActions()->isMovingCardsUntil() && startZoneString == ZoneNames::DECK &&
+        targetZone->getName() == ZoneNames::STACK) {
+        player->getPlayerActions()->moveOneCardUntil(card);
+    }
+}
+
+void PlayerEventHandler::eventFlipCard(const Event_FlipCard &event)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+    CardItem *card = zone->getCard(event.card_id());
+    if (!card) {
+        return;
+    }
+
+    if (!event.face_down()) {
+        QString cardName = QString::fromStdString(event.card_name());
+        QString providerId = QString::fromStdString(event.card_provider_id());
+        card->setCardRef({cardName, providerId});
+    }
+
+    emit logFlipCard(player, card->getName(), event.face_down());
+    card->setFaceDown(event.face_down());
+    emit requestCardMenuUpdate(card);
+}
+
+void PlayerEventHandler::eventDestroyCard(const Event_DestroyCard &event)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+
+    CardItem *card = zone->getCard(event.card_id());
+    if (!card) {
+        return;
+    }
+
+    QList<CardItem *> attachedCards = card->getAttachedCards();
+    // This list is always empty except for buggy server implementations.
+    for (auto &attachedCard : attachedCards) {
+        attachedCard->setAttachedTo(nullptr);
+    }
+
+    emit logDestroyCard(player, card->getName());
+    zone->takeCard(-1, event.card_id(), true);
+    card->deleteLater();
+}
+
+void PlayerEventHandler::eventAttachCard(const Event_AttachCard &event)
+{
+    const QMap<int, PlayerLogic *> &playerList = player->getGame()->getPlayerManager()->getPlayers();
+    PlayerLogic *targetPlayer = nullptr;
+    CardZoneLogic *targetZone = nullptr;
+    CardItem *targetCard = nullptr;
+    if (event.has_target_player_id()) {
+        targetPlayer = playerList.value(event.target_player_id(), 0);
+        if (targetPlayer) {
+            targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
+            if (targetZone) {
+                targetCard = targetZone->getCard(event.target_card_id());
+            }
+        }
+    }
+
+    CardZoneLogic *startZone = player->getZone(QString::fromStdString(event.start_zone()));
+    if (!startZone) {
+        return;
+    }
+
+    CardItem *startCard = startZone->getCard(event.card_id());
+    if (!startCard) {
+        return;
+    }
+
+    CardItem *oldParent = startCard->getAttachedTo();
+
+    startCard->setAttachedTo(targetCard);
+
+    startZone->reorganizeCards();
+    if ((startZone != targetZone) && targetZone) {
+        targetZone->reorganizeCards();
+    }
+    if (oldParent) {
+        oldParent->getZone()->reorganizeCards();
+    }
+
+    if (targetCard) {
+        emit logAttachCard(player, startCard->getName(), targetPlayer, targetCard->getName());
+    } else {
+        emit logUnattachCard(player, startCard->getName());
+    }
+    emit requestCardMenuUpdate(startCard);
+}
+
+void PlayerEventHandler::eventDrawCards(const Event_DrawCards &event)
+{
+    CardZoneLogic *_deck = player->getDeckZone();
+    CardZoneLogic *_hand = player->getHandZone();
+
+    const int listSize = event.cards_size();
+    if (listSize) {
+        for (int i = 0; i < listSize; ++i) {
+            const ServerInfo_Card &cardInfo = event.cards(i);
+            CardItem *card = _deck->takeCard(0, cardInfo.id());
+            QString cardName = QString::fromStdString(cardInfo.name());
+            QString providerId = QString::fromStdString(cardInfo.provider_id());
+            card->setCardRef({cardName, providerId});
+            _hand->addCard(card, false, -1);
+        }
+    } else {
+        const int number = event.number();
+        for (int i = 0; i < number; ++i) {
+            _hand->addCard(_deck->takeCard(0, -1), false, -1);
+        }
+    }
+
+    _hand->reorganizeCards();
+    _deck->reorganizeCards();
+    emit logDrawCards(player, event.number(), _deck->getCards().size() == 0);
+}
+
+void PlayerEventHandler::eventRevealCards(const Event_RevealCards &event, EventProcessingOptions options)
+{
+    Q_UNUSED(options);
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+    PlayerLogic *otherPlayer = nullptr;
+    if (event.has_other_player_id()) {
+        otherPlayer = player->getGame()->getPlayerManager()->getPlayers().value(event.other_player_id());
+        if (!otherPlayer) {
+            return;
+        }
+    }
+
+    bool peeking = false;
+    QList<const ServerInfo_Card *> cardList;
+    const int cardListSize = event.cards_size();
+    for (int i = 0; i < cardListSize; ++i) {
+        const ServerInfo_Card *temp = &event.cards(i);
+        if (temp->face_down()) {
+            peeking = true;
+        }
+        cardList.append(temp);
+    }
+
+    if (peeking) {
+        for (const auto &card : cardList) {
+            QString cardName = QString::fromStdString(card->name());
+            QString providerId = QString::fromStdString(card->provider_id());
+            CardItem *cardItem = zone->getCard(card->id());
+            if (!cardItem) {
+                continue;
+            }
+            cardItem->setCardRef({cardName, providerId});
+            emit logRevealCards(player, zone, card->id(), cardName, player, true, 1);
+        }
+    } else {
+        bool showZoneView = true;
+        QString cardName;
+        auto cardId = event.card_id_size() == 0 ? -1 : event.card_id(0);
+        if (cardList.size() == 1) {
+            cardName = QString::fromStdString(cardList.first()->name());
+
+            // Handle case of revealing top card of library in-place
+            if (cardId == 0 && dynamic_cast<PileZoneLogic *>(zone)) {
+                auto card = zone->getCards().first();
+                QString providerId = QString::fromStdString(cardList.first()->provider_id());
+                card->setCardRef({cardName, providerId});
+
+                emit zone->updateGraphics();
+                showZoneView = false;
+            }
+        }
+
+        if (!options.testFlag(SKIP_REVEAL_WINDOW) && showZoneView && !cardList.isEmpty()) {
+            emit player->requestRevealedZoneView(player, zone, cardList, event.grant_write_access());
+        }
+
+        emit logRevealCards(player, zone, cardId, cardName, otherPlayer, false,
+                            event.has_number_of_cards() ? event.number_of_cards() : cardList.size(),
+                            event.grant_write_access());
+    }
+}
+
+void PlayerEventHandler::eventChangeZoneProperties(const Event_ChangeZoneProperties &event)
+{
+    CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
+    if (!zone) {
+        return;
+    }
+
+    if (event.has_always_reveal_top_card()) {
+        zone->setAlwaysRevealTopCard(event.always_reveal_top_card());
+        emit logAlwaysRevealTopCard(player, zone, event.always_reveal_top_card());
+    }
+    if (event.has_always_look_at_top_card()) {
+        zone->setAlwaysRevealTopCard(event.always_look_at_top_card());
+        emit logAlwaysLookAtTopCard(player, zone, event.always_look_at_top_card());
+    }
+}
+
+void PlayerEventHandler::eventGameLogNotice(const Event_GameLogNotice &event)
+{
+    Event_GameLogNotice::NoticeType type = event.notice_type();
+    switch (type) {
+        case Event_GameLogNotice::UNDO_DRAW_FAILED:
+            emit logUndoDrawFailed(player);
+            break;
+        default:
+            qWarning() << "Received Event_GameLogNotice with unknown noticeType: " << type;
+    }
+}
+
+void PlayerEventHandler::processGameEvent(GameEvent::GameEventType type,
+                                          const GameEvent &event,
+                                          const GameEventContext &context,
+                                          EventProcessingOptions options)
+{
+    switch (type) {
+        case GameEvent::GAME_SAY:
+            eventGameSay(event.GetExtension(Event_GameSay::ext));
+            break;
+        case GameEvent::SHUFFLE:
+            eventShuffle(event.GetExtension(Event_Shuffle::ext));
+            break;
+        case GameEvent::ROLL_DIE:
+            eventRollDie(event.GetExtension(Event_RollDie::ext));
+            break;
+        case GameEvent::CREATE_ARROW:
+            eventCreateArrow(event.GetExtension(Event_CreateArrow::ext));
+            break;
+        case GameEvent::DELETE_ARROW:
+            eventDeleteArrow(event.GetExtension(Event_DeleteArrow::ext));
+            break;
+        case GameEvent::CREATE_TOKEN:
+            eventCreateToken(event.GetExtension(Event_CreateToken::ext));
+            break;
+        case GameEvent::SET_CARD_ATTR:
+            eventSetCardAttr(event.GetExtension(Event_SetCardAttr::ext), context, options);
+            break;
+        case GameEvent::SET_CARD_COUNTER:
+            eventSetCardCounter(event.GetExtension(Event_SetCardCounter::ext));
+            break;
+        case GameEvent::CREATE_COUNTER:
+            eventCreateCounter(event.GetExtension(Event_CreateCounter::ext));
+            break;
+        case GameEvent::SET_COUNTER:
+            eventSetCounter(event.GetExtension(Event_SetCounter::ext));
+            break;
+        case GameEvent::DEL_COUNTER:
+            eventDelCounter(event.GetExtension(Event_DelCounter::ext));
+            break;
+        case GameEvent::DUMP_ZONE:
+            eventDumpZone(event.GetExtension(Event_DumpZone::ext));
+            break;
+        case GameEvent::MOVE_CARD:
+            eventMoveCard(event.GetExtension(Event_MoveCard::ext), context);
+            break;
+        case GameEvent::FLIP_CARD:
+            eventFlipCard(event.GetExtension(Event_FlipCard::ext));
+            break;
+        case GameEvent::DESTROY_CARD:
+            eventDestroyCard(event.GetExtension(Event_DestroyCard::ext));
+            break;
+        case GameEvent::ATTACH_CARD:
+            eventAttachCard(event.GetExtension(Event_AttachCard::ext));
+            break;
+        case GameEvent::DRAW_CARDS:
+            eventDrawCards(event.GetExtension(Event_DrawCards::ext));
+            break;
+        case GameEvent::REVEAL_CARDS:
+            eventRevealCards(event.GetExtension(Event_RevealCards::ext), options);
+            break;
+        case GameEvent::CHANGE_ZONE_PROPERTIES:
+            eventChangeZoneProperties(event.GetExtension(Event_ChangeZoneProperties::ext));
+            break;
+        case GameEvent::GAME_LOG_NOTICE:
+            eventGameLogNotice(event.GetExtension(Event_GameLogNotice::ext));
+            break;
+        default: {
+            qWarning() << "unhandled game event" << type;
+        }
+    }
+}

C++/cockatrice/src/game/player/player_event_handler.h

@@ -0,0 +1,129 @@
+/**
+ * @file player_event_handler.h
+ * @ingroup GameLogicPlayers
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_PLAYER_EVENT_HANDLER_H
+#define COCKATRICE_PLAYER_EVENT_HANDLER_H
+#include "event_processing_options.h"
+
+#include <QObject>
+#include <libcockatrice/protocol/pb/card_attributes.pb.h>
+#include <libcockatrice/protocol/pb/game_event.pb.h>
+#include <libcockatrice/protocol/pb/game_event_context.pb.h>
+
+class CardItem;
+class CardZoneLogic;
+class PlayerLogic;
+class Event_AttachCard;
+class Event_ChangeZoneProperties;
+class Event_CreateArrow;
+class Event_CreateCounter;
+class Event_CreateToken;
+class Event_DelCounter;
+class Event_DeleteArrow;
+class Event_DestroyCard;
+class Event_DrawCards;
+class Event_DumpZone;
+class Event_FlipCard;
+class Event_GameSay;
+class Event_MoveCard;
+class Event_RevealCards;
+class Event_RollDie;
+class Event_SetCardAttr;
+class Event_SetCardCounter;
+class Event_SetCounter;
+class Event_Shuffle;
+class Event_GameLogNotice;
+
+class PlayerEventHandler : public QObject
+{
+
+    Q_OBJECT
+signals:
+    void logSay(PlayerLogic *player, QString message);
+    void logShuffle(PlayerLogic *player, CardZoneLogic *zone, int start, int end);
+    void logRollDie(PlayerLogic *player, int sides, const QList<uint> &rolls);
+    void logCreateArrow(PlayerLogic *player,
+                        PlayerLogic *startPlayer,
+                        QString startCard,
+                        PlayerLogic *targetPlayer,
+                        QString targetCard,
+                        bool _playerTarget);
+    void logCreateToken(PlayerLogic *player, QString cardName, QString pt, bool faceDown);
+    void logDrawCards(PlayerLogic *player, int number, bool deckIsEmpty);
+    void logUndoDraw(PlayerLogic *player, QString cardName);
+    void logUndoDrawFailed(PlayerLogic *player);
+    void logMoveCard(PlayerLogic *player,
+                     CardItem *card,
+                     CardZoneLogic *startZone,
+                     int oldX,
+                     CardZoneLogic *targetZone,
+                     int newX);
+    void logFlipCard(PlayerLogic *player, QString cardName, bool faceDown);
+    void logDestroyCard(PlayerLogic *player, QString cardName);
+    void logAttachCard(PlayerLogic *player, QString cardName, PlayerLogic *targetPlayer, QString targetCardName);
+    void logUnattachCard(PlayerLogic *player, QString cardName);
+    void logSetCardCounter(PlayerLogic *player, QString cardName, int counterId, int value, int oldValue);
+    void logSetTapped(PlayerLogic *player, CardItem *card, bool tapped);
+    void logSetCounter(PlayerLogic *player, QString counterName, int value, int oldValue);
+    void logSetDoesntUntap(PlayerLogic *player, CardItem *card, bool doesntUntap);
+    void logSetPT(PlayerLogic *player, CardItem *card, QString newPT);
+    void logSetAnnotation(PlayerLogic *player, CardItem *card, QString newAnnotation);
+    void logDumpZone(PlayerLogic *player, CardZoneLogic *zone, int numberCards, bool isReversed = false);
+    void logRevealCards(PlayerLogic *player,
+                        CardZoneLogic *zone,
+                        int cardId,
+                        QString cardName,
+                        PlayerLogic *otherPlayer,
+                        bool faceDown,
+                        int amount,
+                        bool isLentToAnotherPlayer = false);
+    void logAlwaysRevealTopCard(PlayerLogic *player, CardZoneLogic *zone, bool reveal);
+    void logAlwaysLookAtTopCard(PlayerLogic *player, CardZoneLogic *zone, bool reveal);
+    void cardZoneChanged(CardItem *card, bool sameZone);
+    void requestCardMenuUpdate(const CardItem *card);
+
+public:
+    PlayerEventHandler(PlayerLogic *player);
+
+    void processGameEvent(GameEvent::GameEventType type,
+                          const GameEvent &event,
+                          const GameEventContext &context,
+                          EventProcessingOptions options);
+
+    void eventGameSay(const Event_GameSay &event);
+    void eventShuffle(const Event_Shuffle &event);
+    void eventRollDie(const Event_RollDie &event);
+    void eventCreateArrow(const Event_CreateArrow &event);
+    void eventDeleteArrow(const Event_DeleteArrow &event);
+    void eventCreateToken(const Event_CreateToken &event);
+    void
+    eventSetCardAttr(const Event_SetCardAttr &event, const GameEventContext &context, EventProcessingOptions options);
+    void eventSetCardCounter(const Event_SetCardCounter &event);
+    void eventCreateCounter(const Event_CreateCounter &event);
+    void eventSetCounter(const Event_SetCounter &event);
+    void eventDelCounter(const Event_DelCounter &event);
+    void eventDumpZone(const Event_DumpZone &event);
+    void eventMoveCard(const Event_MoveCard &event, const GameEventContext &context);
+    void eventFlipCard(const Event_FlipCard &event);
+    void eventDestroyCard(const Event_DestroyCard &event);
+    void eventAttachCard(const Event_AttachCard &event);
+    void eventDrawCards(const Event_DrawCards &event);
+    void eventRevealCards(const Event_RevealCards &event, EventProcessingOptions options);
+    void eventChangeZoneProperties(const Event_ChangeZoneProperties &event);
+    void eventGameLogNotice(const Event_GameLogNotice &event);
+
+private:
+    PlayerLogic *player;
+
+    void setCardAttrHelper(const GameEventContext &context,
+                           CardItem *card,
+                           CardAttribute attribute,
+                           const QString &avalue,
+                           bool allCards,
+                           EventProcessingOptions options);
+};
+
+#endif // COCKATRICE_PLAYER_EVENT_HANDLER_H

C++/cockatrice/src/game/player/player_info.cpp

@@ -0,0 +1,8 @@
+#include "player_info.h"
+
+PlayerInfo::PlayerInfo(const ServerInfo_User &info, int _id, bool _local, bool _judge)
+    : id(_id), local(_local), judge(_judge)
+{
+    userInfo = new ServerInfo_User;
+    userInfo->CopyFrom(info);
+}

C++/cockatrice/src/game/player/player_info.h

@@ -0,0 +1,59 @@
+/**
+ * @file player_info.h
+ * @ingroup GameLogicPlayers
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_PLAYER_INFO_H
+#define COCKATRICE_PLAYER_INFO_H
+
+#include "../../game_graphics/player/player_target.h"
+
+#include <QObject>
+#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
+
+class PlayerInfo : public QObject
+{
+    Q_OBJECT
+public:
+    PlayerInfo(const ServerInfo_User &info, int id, bool local, bool judge);
+
+    ServerInfo_User *userInfo;
+    int id;
+    bool local;
+    bool judge;
+
+    int getId() const
+    {
+        return id;
+    }
+    ServerInfo_User *getUserInfo() const
+    {
+        return userInfo;
+    }
+
+    void setLocal(bool _local)
+    {
+        local = _local;
+    }
+
+    bool getLocal() const
+    {
+        return local;
+    }
+    bool getLocalOrJudge() const
+    {
+        return local || judge;
+    }
+    bool getJudge() const
+    {
+        return judge;
+    }
+
+    QString getName() const
+    {
+        return QString::fromStdString(userInfo->name());
+    }
+};
+
+#endif // COCKATRICE_PLAYER_INFO_H

C++/cockatrice/src/game/player/player_logic.cpp

@@ -0,0 +1,336 @@
+#include "player_logic.h"
+
+#include "../../game_graphics/board/arrow_item.h"
+#include "../../game_graphics/board/card_item.h"
+#include "../../game_graphics/board/counter_general.h"
+#include "../../game_graphics/game_scene.h"
+#include "../../game_graphics/player/player_target.h"
+#include "../../game_graphics/zones/hand_zone.h"
+#include "../../game_graphics/zones/pile_zone.h"
+#include "../../game_graphics/zones/stack_zone.h"
+#include "../../game_graphics/zones/table_zone.h"
+#include "../../interface/theme_manager.h"
+#include "../../interface/widgets/tabs/tab_game.h"
+#include "../board/card_list.h"
+#include "player_actions.h"
+
+#include <QDebug>
+#include <QMenu>
+#include <QMetaType>
+#include <QPainter>
+#include <QtConcurrent>
+#include <libcockatrice/protocol/pb/command_attach_card.pb.h>
+#include <libcockatrice/protocol/pb/command_set_card_counter.pb.h>
+#include <libcockatrice/protocol/pb/event_create_arrow.pb.h>
+#include <libcockatrice/protocol/pb/event_create_counter.pb.h>
+#include <libcockatrice/protocol/pb/event_draw_cards.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_player.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_zone.pb.h>
+#include <libcockatrice/utility/color.h>
+
+PlayerLogic::PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool _judge, AbstractGame *_parent)
+    : QObject(_parent), game(_parent), playerInfo(new PlayerInfo(info, _id, _local, _judge)),
+      playerEventHandler(new PlayerEventHandler(this)), playerActions(new PlayerActions(this)), active(false),
+      conceded(false), zoneId(0), dialogSemaphore(false)
+{
+    initializeZones();
+}
+
+void PlayerLogic::initializeZones()
+{
+    addZone(new PileZoneLogic(this, ZoneNames::DECK, false, true, false, this));
+    addZone(new PileZoneLogic(this, ZoneNames::GRAVE, false, false, true, this));
+    addZone(new PileZoneLogic(this, ZoneNames::EXILE, false, false, true, this));
+    addZone(new PileZoneLogic(this, ZoneNames::SIDEBOARD, false, false, false, this));
+    addZone(new TableZoneLogic(this, ZoneNames::TABLE, true, false, true, this));
+    addZone(new StackZoneLogic(this, ZoneNames::STACK, true, false, true, this));
+    bool visibleHand = playerInfo->getLocalOrJudge() ||
+                       (game->getPlayerManager()->isSpectator() && game->getGameMetaInfo()->spectatorsOmniscient());
+    addZone(new HandZoneLogic(this, ZoneNames::HAND, false, false, visibleHand, this));
+}
+
+PlayerLogic::~PlayerLogic()
+{
+    qCInfo(PlayerLog) << "Player destructor:" << getPlayerInfo()->getName();
+
+    QMapIterator<QString, CardZoneLogic *> i(zones);
+    while (i.hasNext()) {
+        delete i.next().value();
+    }
+    zones.clear();
+
+    delete getPlayerInfo()->userInfo;
+}
+
+void PlayerLogic::clear()
+{
+    emit arrowsClearedLocally();
+
+    QMapIterator<QString, CardZoneLogic *> i(zones);
+    while (i.hasNext()) {
+        i.next().value()->clearContents();
+    }
+
+    clearCounters();
+}
+
+void PlayerLogic::setConceded(bool _conceded)
+{
+    if (conceded != _conceded) {
+        conceded = _conceded;
+
+        if (conceded) {
+            clear();
+        }
+        emit concededChanged(getPlayerInfo()->getId(), conceded);
+    }
+}
+
+void PlayerLogic::setZoneId(int _zoneId)
+{
+    if (zoneId != _zoneId) {
+        zoneId = _zoneId;
+        emit zoneIdChanged(zoneId);
+    }
+}
+
+void PlayerLogic::processPlayerInfo(const ServerInfo_Player &info)
+{
+    static QSet<QString> builtinZones{/* PileZones */
+                                      ZoneNames::DECK, ZoneNames::GRAVE, ZoneNames::EXILE, ZoneNames::SIDEBOARD,
+                                      /* TableZone */
+                                      ZoneNames::TABLE,
+                                      /* StackZone */
+                                      ZoneNames::STACK,
+                                      /* HandZone */
+                                      ZoneNames::HAND};
+    clearCounters();
+    emit arrowsClearedLocally();
+
+    QMutableMapIterator<QString, CardZoneLogic *> zoneIt(zones);
+    while (zoneIt.hasNext()) {
+        zoneIt.next().value()->clearContents();
+
+        if (!builtinZones.contains(zoneIt.key())) {
+            zoneIt.remove();
+        }
+    }
+
+    emit clearCustomZonesMenu();
+
+    const int zoneListSize = info.zone_list_size();
+    for (int i = 0; i < zoneListSize; ++i) {
+        const ServerInfo_Zone &zoneInfo = info.zone_list(i);
+
+        QString zoneName = QString::fromStdString(zoneInfo.name());
+        CardZoneLogic *zone = zones.value(zoneName, 0);
+        if (!zone) {
+            // Create a new CardZone if it doesn't exist
+
+            if (zoneInfo.with_coords()) {
+                // Visibility not currently supported for TableZone
+                zone = addZone(new TableZoneLogic(this, zoneName, true, false, true, this));
+            } else {
+                // Zones without coordinats are always treated as non-shufflable
+                // PileZones, although supporting alternate hand or stack zones
+                // might make sense in some scenarios.
+                bool contentsKnown;
+
+                switch (zoneInfo.type()) {
+                    case ServerInfo_Zone::PrivateZone:
+                        contentsKnown =
+                            playerInfo->getLocalOrJudge() || (game->getPlayerManager()->isSpectator() &&
+                                                              game->getGameMetaInfo()->spectatorsOmniscient());
+                        break;
+
+                    case ServerInfo_Zone::PublicZone:
+                        contentsKnown = true;
+                        break;
+
+                    case ServerInfo_Zone::HiddenZone:
+                        contentsKnown = false;
+                        break;
+                }
+
+                zone = addZone(new PileZoneLogic(this, zoneName, false, /* isShufflable */ false, contentsKnown, this));
+            }
+
+            // Non-builtin zones are hidden by default and can't be interacted
+            // with, except through menus.
+            emit zone->setGraphicsVisibility(false);
+
+            emit addViewCustomZoneActionToCustomZoneMenu(zoneName);
+
+            continue;
+        }
+
+        const int cardListSize = zoneInfo.card_list_size();
+        if (!cardListSize) {
+            for (int j = 0; j < zoneInfo.card_count(); ++j) {
+                zone->addCard(new CardItem(this), false, -1);
+            }
+        } else {
+            for (int j = 0; j < cardListSize; ++j) {
+                const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
+                auto *card = new CardItem(this);
+                card->processCardInfo(cardInfo);
+                zone->addCard(card, false, cardInfo.x(), cardInfo.y());
+            }
+        }
+        if (zoneInfo.has_always_reveal_top_card()) {
+            zone->setAlwaysRevealTopCard(zoneInfo.always_reveal_top_card());
+        }
+
+        zone->reorganizeCards();
+    }
+
+    const int counterListSize = info.counter_list_size();
+    for (int i = 0; i < counterListSize; ++i) {
+        addCounter(info.counter_list(i));
+    }
+
+    setConceded(info.properties().conceded());
+}
+
+void PlayerLogic::processCardAttachment(const ServerInfo_Player &info)
+{
+    const int zoneListSize = info.zone_list_size();
+    for (int i = 0; i < zoneListSize; ++i) {
+        const ServerInfo_Zone &zoneInfo = info.zone_list(i);
+        CardZoneLogic *zone = zones.value(QString::fromStdString(zoneInfo.name()), 0);
+        if (!zone) {
+            continue;
+        }
+
+        const int cardListSize = zoneInfo.card_list_size();
+        for (int j = 0; j < cardListSize; ++j) {
+            const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
+            if (cardInfo.has_attach_player_id()) {
+                CardItem *startCard = zone->getCard(cardInfo.id());
+                CardItem *targetCard =
+                    game->getCard(cardInfo.attach_player_id(), QString::fromStdString(cardInfo.attach_zone()),
+                                  cardInfo.attach_card_id());
+                if (!targetCard) {
+                    continue;
+                }
+
+                startCard->setAttachedTo(targetCard);
+            }
+        }
+    }
+
+    const int arrowListSize = info.arrow_list_size();
+    for (int i = 0; i < arrowListSize; ++i) {
+        emit arrowCreateRequested(QSharedPointer<ArrowData>::create(
+            ArrowData::fromProto(info.arrow_list(i), getPlayerInfo()->getId(), getPlayerInfo()->getLocal())));
+    }
+}
+
+void PlayerLogic::addCard(CardItem *card)
+{
+    emit newCardAdded(card);
+}
+
+void PlayerLogic::deleteCard(CardItem *card)
+{
+    if (card == nullptr) {
+        return;
+    } else if (dialogSemaphore) {
+        cardsToDelete.append(card);
+    } else {
+        card->deleteLater();
+    }
+}
+
+void PlayerLogic::setDeck(const DeckList &_deck)
+{
+    deck = _deck;
+
+    emit deckChanged();
+}
+
+CounterState *PlayerLogic::addCounter(const ServerInfo_Counter &counter)
+{
+    return addCounter(counter.id(), QString::fromStdString(counter.name()),
+                      convertColorToQColor(counter.counter_color()), counter.radius(), counter.count());
+}
+
+CounterState *PlayerLogic::addCounter(int id, const QString &name, const QColor &color, int radius, int value)
+{
+    if (counters.contains(id)) {
+        return nullptr;
+    }
+    auto *state = new CounterState(id, name, color, radius, value, this);
+    counters.insert(id, state);
+    emit counterAdded(state);
+    return state;
+}
+
+void PlayerLogic::delCounter(int id)
+{
+    auto *state = counters.take(id);
+    if (!state) {
+        return;
+    }
+    emit counterRemoved(id);
+    state->deleteLater();
+}
+
+void PlayerLogic::clearCounters()
+{
+    for (int id : counters.keys()) {
+        emit counterRemoved(id);
+    }
+    qDeleteAll(counters);
+    counters.clear();
+}
+
+CounterState *PlayerLogic::getLifeCounter() const
+{
+    for (auto *s : counters.values()) {
+        if (s->getName() == "life") {
+            return s;
+        }
+    }
+    return nullptr;
+}
+
+bool PlayerLogic::clearCardsToDelete()
+{
+    if (cardsToDelete.isEmpty()) {
+        return false;
+    }
+
+    for (auto &i : cardsToDelete) {
+        if (i != nullptr) {
+            i->deleteLater();
+        }
+    }
+    cardsToDelete.clear();
+
+    return true;
+}
+
+void PlayerLogic::setActive(bool _active)
+{
+    active = _active;
+    emit activeChanged(active);
+}
+void PlayerLogic::onRequestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed)
+{
+    emit requestZoneViewToggle(this, zoneName, numberCards, isReversed);
+}
+
+void PlayerLogic::updateZones()
+{
+    getTableZone()->reorganizeCards();
+}
+
+void PlayerLogic::setGameStarted()
+{
+    if (playerInfo->local) {
+        emit resetTopCardMenuActions();
+    }
+    setConceded(false);
+}

C++/cockatrice/src/game/player/player_logic.h

@@ -0,0 +1,259 @@
+/**
+ * @file player.h
+ * @ingroup GameLogicPlayers
+ */
+//! \todo Document this file.
+
+#ifndef PLAYER_H
+#define PLAYER_H
+
+#include "../../game_graphics/player/player_area.h"
+#include "../../interface/widgets/menus/tearoff_menu.h"
+#include "../board/arrow_data.h"
+#include "../interface/deck_loader/loaded_deck.h"
+#include "../zones/hand_zone_logic.h"
+#include "../zones/pile_zone_logic.h"
+#include "../zones/stack_zone_logic.h"
+#include "../zones/table_zone_logic.h"
+#include "player_event_handler.h"
+#include "player_info.h"
+
+#include <QInputDialog>
+#include <QLoggingCategory>
+#include <QMap>
+#include <QTimer>
+#include <libcockatrice/filters/filter_string.h>
+#include <libcockatrice/protocol/pb/card_attributes.pb.h>
+#include <libcockatrice/protocol/pb/game_event.pb.h>
+#include <libcockatrice/utility/zone_names.h>
+
+inline Q_LOGGING_CATEGORY(PlayerLog, "player");
+
+namespace google
+{
+namespace protobuf
+{
+class Message;
+}
+} // namespace google
+class AbstractCardItem;
+class AbstractGame;
+class ArrowItem;
+class ArrowTarget;
+class CardDatabase;
+class CardZone;
+class CommandContainer;
+class GameCommand;
+class GameEvent;
+class PlayerInfo;
+class PlayerEventHandler;
+class PlayerActions;
+class PlayerMenu;
+class QAction;
+class QMenu;
+class ServerInfo_Arrow;
+class ServerInfo_Card;
+class ServerInfo_Counter;
+class ServerInfo_Player;
+class ServerInfo_User;
+class TabGame;
+
+const int MAX_TOKENS_PER_DIALOG = 99;
+
+class PlayerLogic : public QObject
+{
+    Q_OBJECT
+
+signals:
+    void openDeckEditor(const LoadedDeck &deck);
+    void requestZoneViewToggle(PlayerLogic *player, const QString &zoneName, int numberCards, bool isReversed);
+    void requestRevealedZoneView(PlayerLogic *player,
+                                 CardZoneLogic *zone,
+                                 const QList<const ServerInfo_Card *> &cardList,
+                                 bool withWritePermission);
+    void deckChanged();
+    void newCardAdded(AbstractCardItem *card);
+    void requestCardMenuUpdate(const CardItem *card);
+    void counterAdded(CounterState *state);
+    void counterRemoved(int counterId);
+    void rearrangeCounters();
+    void activeChanged(bool active);
+    void zoneIdChanged(int zoneId);
+    void concededChanged(int playerId, bool conceded);
+    void clearCustomZonesMenu();
+    void addViewCustomZoneActionToCustomZoneMenu(QString zoneName);
+    void resetTopCardMenuActions();
+    void arrowCreateRequested(QSharedPointer<ArrowData> data);
+    void arrowDeleteRequested(int creatorId, int arrowId);
+    void arrowDeleted(int creatorId, int arrowId);
+    void arrowsClearedLocally(); // fires on clear() and processPlayerInfo
+
+public slots:
+    void setActive(bool _active);
+    void onRequestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed);
+
+public:
+    PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool _judge, AbstractGame *_parent);
+    ~PlayerLogic() override;
+
+    void initializeZones();
+    void updateZones();
+    void clear();
+
+    void processPlayerInfo(const ServerInfo_Player &info);
+    void processCardAttachment(const ServerInfo_Player &info);
+
+    void addCard(CardItem *c);
+    void deleteCard(CardItem *c);
+
+    bool clearCardsToDelete();
+
+    bool getActive() const
+    {
+        return active;
+    }
+
+    AbstractGame *getGame() const
+    {
+        return game;
+    }
+
+    [[nodiscard]] PlayerActions *getPlayerActions() const
+    {
+        return playerActions;
+    }
+
+    [[nodiscard]] PlayerEventHandler *getPlayerEventHandler() const
+    {
+        return playerEventHandler;
+    }
+
+    [[nodiscard]] PlayerInfo *getPlayerInfo() const
+    {
+        return playerInfo;
+    }
+
+    void setDeck(const DeckList &_deck);
+
+    [[nodiscard]] const DeckList &getDeck() const
+    {
+        return deck;
+    }
+
+    template <typename T> T *addZone(T *zone)
+    {
+        zones.insert(zone->getName(), zone);
+        return zone;
+    }
+
+    CardZoneLogic *getZone(const QString zoneName)
+    {
+        return zones.value(zoneName);
+    }
+
+    const QMap<QString, CardZoneLogic *> &getZones() const
+    {
+        return zones;
+    }
+
+    PileZoneLogic *getDeckZone()
+    {
+        return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::DECK));
+    }
+
+    PileZoneLogic *getGraveZone()
+    {
+        return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::GRAVE));
+    }
+
+    PileZoneLogic *getRfgZone()
+    {
+        return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::EXILE));
+    }
+
+    PileZoneLogic *getSideboardZone()
+    {
+        return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::SIDEBOARD));
+    }
+
+    TableZoneLogic *getTableZone()
+    {
+        return qobject_cast<TableZoneLogic *>(zones.value(ZoneNames::TABLE));
+    }
+
+    StackZoneLogic *getStackZone()
+    {
+        return qobject_cast<StackZoneLogic *>(zones.value(ZoneNames::STACK));
+    }
+
+    HandZoneLogic *getHandZone()
+    {
+        return qobject_cast<HandZoneLogic *>(zones.value(ZoneNames::HAND));
+    }
+
+    CounterState *addCounter(const ServerInfo_Counter &counter);
+    CounterState *addCounter(int id, const QString &name, const QColor &color, int radius, int value);
+    void delCounter(int counterId);
+    void clearCounters();
+
+    QMap<int, CounterState *> getCounters() const
+    {
+        return counters;
+    }
+
+    /**
+     * Gets the counter that represents the life total.
+     */
+    CounterState *getLifeCounter() const;
+
+    void setConceded(bool _conceded);
+    bool getConceded() const
+    {
+        return conceded;
+    }
+
+    void setGameStarted();
+
+    void setDialogSemaphore(const bool _active)
+    {
+        dialogSemaphore = _active;
+    }
+
+    int getZoneId() const
+    {
+        return zoneId;
+    }
+
+    void setZoneId(int _zoneId);
+
+private:
+    AbstractGame *game;
+    PlayerInfo *playerInfo;
+    PlayerEventHandler *playerEventHandler;
+    PlayerActions *playerActions;
+
+    bool active;
+    bool conceded;
+
+    DeckList deck;
+
+    int zoneId;
+    QMap<QString, CardZoneLogic *> zones;
+    QMap<int, CounterState *> counters;
+
+    bool dialogSemaphore;
+    QList<CardItem *> cardsToDelete;
+};
+
+class AnnotationDialog : public QInputDialog
+{
+    Q_OBJECT
+    void keyPressEvent(QKeyEvent *e) override;
+
+public:
+    explicit AnnotationDialog(QWidget *parent = nullptr) : QInputDialog(parent)
+    {
+    }
+};
+
+#endif

C++/cockatrice/src/game/player/player_manager.cpp

@@ -0,0 +1,86 @@
+#include "player_manager.h"
+
+#include "../abstract_game.h"
+#include "player_logic.h"
+
+PlayerManager::PlayerManager(AbstractGame *_game,
+                             int _localPlayerId,
+                             bool _localPlayerIsJudge,
+                             bool localPlayerIsSpectator)
+    : QObject(_game), game(_game), players(QMap<int, PlayerLogic *>()), localPlayerId(_localPlayerId),
+      localPlayerIsJudge(_localPlayerIsJudge), localPlayerIsSpectator(localPlayerIsSpectator)
+{
+}
+
+bool PlayerManager::isMainPlayerConceded() const
+{
+    PlayerLogic *player = players.value(localPlayerId, nullptr);
+    return player && player->getConceded();
+}
+
+PlayerLogic *PlayerManager::getActiveLocalPlayer(int activePlayer) const
+{
+    PlayerLogic *active = players.value(activePlayer, 0);
+    if (active) {
+        if (active->getPlayerInfo()->getLocal()) {
+            return active;
+        }
+    }
+
+    QMapIterator<int, PlayerLogic *> playerIterator(players);
+    while (playerIterator.hasNext()) {
+        PlayerLogic *temp = playerIterator.next().value();
+        if (temp->getPlayerInfo()->getLocal()) {
+            return temp;
+        }
+    }
+
+    return nullptr;
+}
+
+bool PlayerManager::isLocalPlayer(int playerId)
+{
+    return game->getGameState()->getIsLocalGame() || playerId == localPlayerId;
+}
+
+PlayerLogic *PlayerManager::addPlayer(int playerId, const ServerInfo_User &info)
+{
+    auto *newPlayer = new PlayerLogic(info, playerId, isLocalPlayer(playerId) || game->getGameState()->getIsLocalGame(),
+                                      isJudge(), getGame());
+    connect(newPlayer, &PlayerLogic::concededChanged, this, &PlayerManager::onPlayerConceded);
+    players.insert(playerId, newPlayer);
+    emit playerAdded(newPlayer);
+    emit playerCountChanged();
+    return newPlayer;
+}
+
+void PlayerManager::removePlayer(int playerId)
+{
+    PlayerLogic *player = getPlayer(playerId);
+    if (!player) {
+        return;
+    }
+    emit playerRemoved(player);
+    emit playerCountChanged();
+    players.remove(playerId);
+    player->deleteLater();
+}
+
+PlayerLogic *PlayerManager::getPlayer(int playerId) const
+{
+    PlayerLogic *player = players.value(playerId, 0);
+    if (!player) {
+        return nullptr;
+    }
+    return player;
+}
+
+void PlayerManager::onPlayerConceded(int playerId, bool conceded)
+{
+    // Everything else cares about this
+    if (conceded) {
+        emit playerConceded(playerId);
+    } else {
+        emit playerUnconceded(playerId);
+    }
+}

C++/cockatrice/src/game/player/player_manager.h

@@ -0,0 +1,120 @@
+/**
+ * @file player_manager.h
+ * @ingroup GameLogicPlayers
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_PLAYER_MANAGER_H
+#define COCKATRICE_PLAYER_MANAGER_H
+
+#include <QMap>
+#include <QObject>
+#include <libcockatrice/protocol/pb/serverinfo_playerproperties.pb.h>
+
+class AbstractGame;
+class PlayerLogic;
+class PlayerManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    PlayerManager(AbstractGame *_game, int _localPlayerId, bool _localPlayerIsJudge, bool localPlayerIsSpectator);
+
+    AbstractGame *game;
+    QMap<int, PlayerLogic *> players;
+    int localPlayerId;
+    bool localPlayerIsJudge;
+    bool localPlayerIsSpectator;
+    QMap<int, ServerInfo_User> spectators;
+
+    [[nodiscard]] bool isSpectator() const
+    {
+        return localPlayerIsSpectator;
+    }
+
+    [[nodiscard]] bool isJudge() const
+    {
+        return localPlayerIsJudge;
+    }
+
+    [[nodiscard]] int getLocalPlayerId() const
+    {
+        return localPlayerId;
+    }
+
+    [[nodiscard]] const QMap<int, PlayerLogic *> &getPlayers() const
+    {
+        return players;
+    }
+
+    [[nodiscard]] int getPlayerCount() const
+    {
+        return players.size();
+    }
+
+    [[nodiscard]] PlayerLogic *getActiveLocalPlayer(int activePlayer) const;
+    bool isLocalPlayer(int playerId);
+
+    PlayerLogic *addPlayer(int playerId, const ServerInfo_User &info);
+
+    void removePlayer(int playerId);
+
+    [[nodiscard]] PlayerLogic *getPlayer(int playerId) const;
+
+    void onPlayerConceded(int playerId, bool conceded);
+
+    [[nodiscard]] bool isMainPlayerConceded() const;
+
+    [[nodiscard]] bool isLocalPlayer(int playerId) const
+    {
+        return playerId == getLocalPlayerId();
+    }
+
+    [[nodiscard]] const QMap<int, ServerInfo_User> &getSpectators() const
+    {
+        return spectators;
+    }
+
+    [[nodiscard]] ServerInfo_User getSpectator(int playerId) const
+    {
+        return spectators.value(playerId);
+    }
+
+    [[nodiscard]] QString getSpectatorName(int spectatorId) const
+    {
+        return QString::fromStdString(spectators.value(spectatorId).name());
+    }
+
+    void addSpectator(int spectatorId, const ServerInfo_PlayerProperties &prop)
+    {
+        if (!spectators.contains(spectatorId)) {
+            spectators.insert(spectatorId, prop.user_info());
+            emit spectatorAdded(prop);
+        }
+    }
+
+    void removeSpectator(int spectatorId)
+    {
+        ServerInfo_User spectatorInfo = spectators.value(spectatorId);
+        spectators.remove(spectatorId);
+        emit spectatorRemoved(spectatorId, spectatorInfo);
+    }
+
+    [[nodiscard]] AbstractGame *getGame() const
+    {
+        return game;
+    }
+
+signals:
+    void playerAdded(PlayerLogic *player);
+    void playerRemoved(PlayerLogic *player);
+    void activeLocalPlayerConceded();
+    void activeLocalPlayerUnconceded();
+    void playerConceded(int playerId);
+    void playerUnconceded(int playerId);
+    void playerCountChanged();
+    void spectatorAdded(ServerInfo_PlayerProperties spectator);
+    void spectatorRemoved(int spectatorId, ServerInfo_User spectator);
+};
+
+#endif // COCKATRICE_PLAYER_MANAGER_H

C++/cockatrice/src/game/replay.cpp

@@ -0,0 +1,11 @@
+#include "replay.h"
+
+#include "../interface/widgets/tabs/tab_game.h"
+
+Replay::Replay(QObject *_parent, GameReplay *_replay, bool isLocalGame) : AbstractGame(_parent)
+{
+    gameState = new GameState(this, 0, -1, isLocalGame, {}, false, false, -1, false);
+    connect(gameMetaInfo, &GameMetaInfo::startedChanged, gameState, &GameState::onStartedChanged);
+    playerManager = new PlayerManager(this, -1, false, true);
+    loadReplay(_replay);
+}

C++/cockatrice/src/game/replay.h

@@ -0,0 +1,21 @@
+/**
+ * @file replay.h
+ * @ingroup GameLogic
+ * @ingroup Replay
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_REPLAY_H
+#define COCKATRICE_REPLAY_H
+
+#include "abstract_game.h"
+
+class Replay : public AbstractGame
+{
+    Q_OBJECT
+
+public:
+    explicit Replay(QObject *_parent, GameReplay *_replay, bool isLocalGame);
+};
+
+#endif // COCKATRICE_REPLAY_H

C++/cockatrice/src/game/zones/card_zone_algorithms.h

@@ -0,0 +1,45 @@
+#ifndef COCKATRICE_CARD_ZONE_ALGORITHMS_H
+#define COCKATRICE_CARD_ZONE_ALGORITHMS_H
+
+namespace CardZoneAlgorithms
+{
+
+/**
+ * Shared insertion logic for zones where cards become visible on add and follow
+ * the standard pattern: clamp index, insert, clear identity if contents unknown,
+ * reset state, show card.
+ *
+ * Zones with different post-add behavior (signal connections, positional resets,
+ * hidden cards, or coordinate-based placement) should NOT use this — implement
+ * addCardImpl directly instead.
+ *
+ * Template parameters allow testing with lightweight mocks that avoid Qt graphics
+ * dependencies.
+ *
+ * @tparam CardList Must provide: size() -> int, insert(int, CardType*),
+ *                  getContentsKnown() -> bool
+ * @tparam CardType Must provide: setId(int), setCardRef(CardRefType),
+ *                  resetState(bool), setVisible(bool)
+ * @param keepAnnotations Forwarded to card->resetState(). Stack-like zones preserve
+ *                        annotations across zone transitions; hand-like zones clear them.
+ */
+template <typename CardList, typename CardType>
+void addCardToList(CardList &cards, CardType *card, int x, bool keepAnnotations)
+{
+    if (x < 0 || x >= cards.size()) {
+        x = static_cast<int>(cards.size());
+    }
+    cards.insert(x, card);
+
+    if (!cards.getContentsKnown()) {
+        card->setId(-1);
+        card->setCardRef({});
+    }
+
+    card->resetState(keepAnnotations);
+    card->setVisible(true);
+}
+
+} // namespace CardZoneAlgorithms
+
+#endif // COCKATRICE_CARD_ZONE_ALGORITHMS_H

C++/cockatrice/src/game/zones/card_zone_logic.cpp

@@ -0,0 +1,221 @@
+#include "card_zone_logic.h"
+
+#include "../../game_graphics/board/card_item.h"
+#include "../../game_graphics/zones/view_zone.h"
+#include "../player/player_actions.h"
+#include "../player/player_logic.h"
+#include "view_zone_logic.h"
+
+#include <QAction>
+#include <QDebug>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <libcockatrice/protocol/pb/command_move_card.pb.h>
+#include <libcockatrice/utility/zone_names.h>
+
+/**
+ * @param _player the player that the zone belongs to
+ * @param _name internal name of the zone
+ * @param _hasCardAttr whether cards in the zone can have attributes set on them
+ * @param _isShufflable whether it makes sense to shuffle this zone by default after viewing it
+ * @param _contentsKnown whether the cards in the zone are known to the client
+ * @param parent the parent QObject.
+ */
+CardZoneLogic::CardZoneLogic(PlayerLogic *_player,
+                             const QString &_name,
+                             bool _hasCardAttr,
+                             bool _isShufflable,
+                             bool _contentsKnown,
+                             QObject *parent)
+    : QObject(parent), player(_player), name(_name), cards(_contentsKnown), views{}, hasCardAttr(_hasCardAttr),
+      isShufflable(_isShufflable)
+{
+    // If we join a game before the card db finishes loading, the cards might have the wrong printings.
+    // Force refresh all cards in the zone when db finishes loading to fix that.
+    connect(CardDatabaseManager::getInstance(), &CardDatabase::cardDatabaseLoadingFinished, this,
+            &CardZoneLogic::refreshCardInfos);
+}
+
+void CardZoneLogic::addCard(CardItem *card, const bool reorganize, const int x, const int y)
+{
+    if (!card) {
+        qCWarning(CardZoneLog) << "CardZoneLogic::addCard() card is null; this shouldn't normally happen";
+        return;
+    }
+
+    for (auto *view : views) {
+        if (qobject_cast<ZoneViewZoneLogic *>(view->getLogic())->prepareAddCard(x)) {
+            auto copy = new CardItem(player, nullptr, card->getCardRef(), card->getId());
+            copy->setFaceDown(card->getFaceDown());
+
+            view->getLogic()->addCard(copy, reorganize, x, y);
+        }
+    }
+
+    card->setZone(this);
+    emit cardAdded(card);
+    addCardImpl(card, x, y);
+
+    if (reorganize) {
+        emit reorganizeCards();
+    }
+
+    emit cardCountChanged();
+}
+
+CardItem *CardZoneLogic::takeCard(int position, int cardId, bool toNewZone)
+{
+    if (position == -1) {
+        // position == -1 means either that the zone is indexed by card id
+        // or that it doesn't matter which card you take.
+        for (int i = 0; i < cards.size(); ++i) {
+            if (cards[i]->getId() == cardId) {
+                position = i;
+                break;
+            }
+        }
+        if (position == -1) {
+            position = 0;
+        }
+    }
+    if (position >= cards.size()) {
+        return nullptr;
+    }
+
+    for (auto *view : views) {
+        qobject_cast<ZoneViewZoneLogic *>(view->getLogic())->removeCard(position, toNewZone);
+    }
+
+    CardItem *c = cards.takeAt(position);
+
+    c->setId(cardId);
+
+    emit reorganizeCards();
+    emit cardCountChanged();
+    return c;
+}
+
+CardItem *CardZoneLogic::getCard(int cardId)
+{
+    CardItem *c = cards.findCard(cardId);
+    if (!c) {
+        qCWarning(CardZoneLog) << "CardZoneLogic::getCard: card id=" << cardId << "not found";
+        return nullptr;
+    }
+    // If the card's id is -1, this zone is invisible,
+    // so we need to give the card an id as it comes out.
+    // It can be assumed that in an invisible zone, all cards are equal.
+    if (c->getId() == -1) {
+        c->setId(cardId);
+    }
+    return c;
+}
+
+void CardZoneLogic::removeCard(CardItem *card)
+{
+    if (!card) {
+        qCWarning(CardZoneLog) << "CardZoneLogic::removeCard: card is null, this shouldn't normally happen";
+        return;
+    }
+
+    cards.removeOne(card);
+
+    emit reorganizeCards();
+    emit cardCountChanged();
+    player->deleteCard(card);
+}
+
+void CardZoneLogic::refreshCardInfos()
+{
+    for (const auto &cardItem : cards) {
+        cardItem->refreshCardInfo();
+    }
+}
+
+void CardZoneLogic::moveAllToZone()
+{
+    QList<QVariant> data = static_cast<QAction *>(sender())->data().toList();
+    if (data.length() < 2) {
+        return;
+    }
+    QString targetZone = data[0].toString();
+    int targetX = data[1].toInt();
+
+    Command_MoveCard cmd;
+    cmd.set_start_zone(getName().toStdString());
+    cmd.set_target_player_id(player->getPlayerInfo()->getId());
+    cmd.set_target_zone(targetZone.toStdString());
+    cmd.set_x(targetX);
+
+    for (int i = 0; i < cards.size(); ++i) {
+        cmd.mutable_cards_to_move()->add_card()->set_card_id(cards[i]->getId());
+    }
+
+    player->getPlayerActions()->sendGameCommand(cmd);
+}
+
+void CardZoneLogic::clearContents()
+{
+    // First gather the cards into a safe temporary list.
+    const CardList toClear = cards;
+
+    // Detach and notify attached cards and zones *before* deleting anything.
+    for (CardItem *card : toClear) {
+        // If an incorrectly implemented server doesn't return attached cards to whom they belong before dropping a
+        // player, we have to return them to avoid a crash.
+        const QList<CardItem *> &attachedCards = card->getAttachedCards();
+        for (CardItem *attachedCard : attachedCards) {
+            emit attachedCard->getZone()->cardAdded(attachedCard);
+        }
+    }
+
+    // Now request deletions after all manipulations are done.
+    for (CardItem *card : toClear) {
+        player->deleteCard(card);
+    }
+
+    cards.clear();
+    emit cardCountChanged();
+}
+
+QString CardZoneLogic::getTranslatedName(bool theirOwn, GrammaticalCase gc) const
+{
+    QString ownerName = player->getPlayerInfo()->getName();
+    if (name == ZoneNames::HAND) {
+        return (theirOwn ? tr("their hand", "nominative") : tr("%1's hand", "nominative").arg(ownerName));
+    } else if (name == ZoneNames::DECK) {
+        switch (gc) {
+            case CaseLookAtZone:
+                return (theirOwn ? tr("their library", "look at zone")
+                                 : tr("%1's library", "look at zone").arg(ownerName));
+            case CaseTopCardsOfZone:
+                return (theirOwn ? tr("of their library", "top cards of zone,")
+                                 : tr("of %1's library", "top cards of zone").arg(ownerName));
+            case CaseRevealZone:
+                return (theirOwn ? tr("their library", "reveal zone")
+                                 : tr("%1's library", "reveal zone").arg(ownerName));
+            case CaseShuffleZone:
+                return (theirOwn ? tr("their library", "shuffle") : tr("%1's library", "shuffle").arg(ownerName));
+            default:
+                return (theirOwn ? tr("their library", "nominative") : tr("%1's library", "nominative").arg(ownerName));
+        }
+    } else if (name == ZoneNames::GRAVE) {
+        return (theirOwn ? tr("their graveyard", "nominative") : tr("%1's graveyard", "nominative").arg(ownerName));
+    } else if (name == ZoneNames::EXILE) {
+        return (theirOwn ? tr("their exile", "nominative") : tr("%1's exile", "nominative").arg(ownerName));
+    } else if (name == ZoneNames::SIDEBOARD) {
+        switch (gc) {
+            case CaseLookAtZone:
+                return (theirOwn ? tr("their sideboard", "look at zone")
+                                 : tr("%1's sideboard", "look at zone").arg(ownerName));
+            case CaseNominative:
+                return (theirOwn ? tr("their sideboard", "nominative")
+                                 : tr("%1's sideboard", "nominative").arg(ownerName));
+            default:
+                break;
+        }
+    } else {
+        return (theirOwn ? tr("their custom zone '%1'", "nominative").arg(name)
+                         : tr("%1's custom zone '%2'", "nominative").arg(ownerName).arg(name));
+    }
+    return QString();
+}

C++/cockatrice/src/game/zones/card_zone_logic.h

@@ -0,0 +1,119 @@
+/**
+ * @file card_zone_logic.h
+ * @ingroup GameLogicZones
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_CARD_ZONE_LOGIC_H
+#define COCKATRICE_CARD_ZONE_LOGIC_H
+
+#include "../../client/translation.h"
+#include "../board/card_list.h"
+
+#include <QLoggingCategory>
+#include <QObject>
+
+inline Q_LOGGING_CATEGORY(CardZoneLogicLog, "card_zone_logic");
+
+class PlayerLogic;
+class ZoneViewZone;
+class QMenu;
+class QAction;
+class QPainter;
+class CardDragItem;
+
+class CardZoneLogic : public QObject
+{
+    Q_OBJECT
+
+signals:
+    void cardAdded(CardItem *addedCard);
+    void cardCountChanged();
+    void reorganizeCards();
+    void updateGraphics();
+    void setGraphicsVisibility(bool visible);
+    void retranslateUi();
+
+public:
+    explicit CardZoneLogic(PlayerLogic *_player,
+                           const QString &_name,
+                           bool _hasCardAttr,
+                           bool _isShufflable,
+                           bool _contentsKnown,
+                           QObject *parent = nullptr);
+
+    void addCard(CardItem *card, bool reorganize, int x, int y = -1);
+    // getCard() finds a card by id.
+    CardItem *getCard(int cardId);
+    void removeCard(CardItem *card);
+    // takeCard() finds a card by position and removes it from the zone and from all of its views.
+    virtual CardItem *takeCard(int position, int cardId, bool canResize = true);
+
+    void rawInsertCard(CardItem *card, int index)
+    {
+        cards.insert(index, card);
+    }
+
+    [[nodiscard]] const CardList &getCards() const
+    {
+        return cards;
+    }
+
+    void sortCards(const QList<CardList::SortOption> &options)
+    {
+        cards.sortBy(options);
+    }
+    [[nodiscard]] QString getName() const
+    {
+        return name;
+    }
+    [[nodiscard]] QString getTranslatedName(bool theirOwn, GrammaticalCase gc) const;
+    [[nodiscard]] PlayerLogic *getPlayer() const
+    {
+        return player;
+    }
+    [[nodiscard]] bool contentsKnown() const
+    {
+        return cards.getContentsKnown();
+    }
+    QList<ZoneViewZone *> &getViews()
+    {
+        return views;
+    }
+    void setAlwaysRevealTopCard(bool _alwaysRevealTopCard)
+    {
+        alwaysRevealTopCard = _alwaysRevealTopCard;
+    }
+    [[nodiscard]] bool getAlwaysRevealTopCard() const
+    {
+        return alwaysRevealTopCard;
+    }
+    [[nodiscard]] bool getHasCardAttr() const
+    {
+        return hasCardAttr;
+    }
+    [[nodiscard]] bool getIsShufflable() const
+    {
+        return isShufflable;
+    }
+    void clearContents();
+
+public slots:
+    void moveAllToZone();
+
+private slots:
+    void refreshCardInfos();
+
+protected:
+    PlayerLogic *player;
+    QString name;
+    CardList cards;
+    QList<ZoneViewZone *> views;
+    bool hasCardAttr;
+    bool isShufflable;
+    bool alwaysRevealTopCard;
+
+    virtual void addCardImpl(CardItem *card, int x, int y) = 0;
+};
+
+#endif // COCKATRICE_CARD_ZONE_LOGIC_H

C++/cockatrice/src/game/zones/hand_zone_logic.cpp

@@ -0,0 +1,19 @@
+#include "hand_zone_logic.h"
+
+#include "../../game_graphics/board/card_item.h"
+#include "card_zone_algorithms.h"
+
+HandZoneLogic::HandZoneLogic(PlayerLogic *_player,
+                             const QString &_name,
+                             bool _hasCardAttr,
+                             bool _isShufflable,
+                             bool _contentsKnown,
+                             QObject *parent)
+    : CardZoneLogic(_player, _name, _hasCardAttr, _isShufflable, _contentsKnown, parent)
+{
+}
+
+void HandZoneLogic::addCardImpl(CardItem *card, int x, int /*y*/)
+{
+    CardZoneAlgorithms::addCardToList(cards, card, x, false);
+}

C++/cockatrice/src/game/zones/hand_zone_logic.h

@@ -0,0 +1,26 @@
+/**
+ * @file hand_zone_logic.h
+ * @ingroup GameLogicZones
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_HAND_ZONE_LOGIC_H
+#define COCKATRICE_HAND_ZONE_LOGIC_H
+#include "card_zone_logic.h"
+
+class HandZoneLogic : public CardZoneLogic
+{
+    Q_OBJECT
+public:
+    HandZoneLogic(PlayerLogic *_player,
+                  const QString &_name,
+                  bool _hasCardAttr,
+                  bool _isShufflable,
+                  bool _contentsKnown,
+                  QObject *parent = nullptr);
+
+protected:
+    void addCardImpl(CardItem *card, int x, int y) override;
+};
+
+#endif // COCKATRICE_HAND_ZONE_LOGIC_H

C++/cockatrice/src/game/zones/pile_zone_logic.cpp

@@ -0,0 +1,34 @@
+#include "pile_zone_logic.h"
+
+#include "../../game_graphics/board/card_item.h"
+
+PileZoneLogic::PileZoneLogic(PlayerLogic *_player,
+                             const QString &_name,
+                             bool _hasCardAttr,
+                             bool _isShufflable,
+                             bool _contentsKnown,
+                             QObject *parent)
+    : CardZoneLogic(_player, _name, _hasCardAttr, _isShufflable, _contentsKnown, parent)
+{
+}
+
+void PileZoneLogic::addCardImpl(CardItem *card, int x, int /*y*/)
+{
+    connect(card, &CardItem::sigPixmapUpdated, this, &PileZoneLogic::callUpdate);
+    // if x is negative set it to add at end
+    if (x < 0 || x >= cards.size()) {
+        x = cards.size();
+    }
+    cards.insert(x, card);
+    card->setPos(0, 0);
+    if (!contentsKnown()) {
+        card->setCardRef({});
+        card->setId(-1);
+        // If we obscure a previously revealed card, its name has to be forgotten
+        if (cards.size() > x + 1) {
+            cards.at(x + 1)->setCardRef({});
+        }
+    }
+    card->setVisible(false);
+    card->resetState();
+}

C++/cockatrice/src/game/zones/pile_zone_logic.h

@@ -0,0 +1,31 @@
+/**
+ * @file pile_zone_logic.h
+ * @ingroup GameLogicZones
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_PILE_ZONE_LOGIC_H
+#define COCKATRICE_PILE_ZONE_LOGIC_H
+#include "card_zone_logic.h"
+
+class PileZoneLogic : public CardZoneLogic
+{
+
+    Q_OBJECT
+
+signals:
+    void callUpdate();
+
+public:
+    PileZoneLogic(PlayerLogic *_player,
+                  const QString &_name,
+                  bool _hasCardAttr,
+                  bool _isShufflable,
+                  bool _contentsKnown,
+                  QObject *parent = nullptr);
+
+protected:
+    void addCardImpl(CardItem *card, int x, int y) override;
+};
+
+#endif // COCKATRICE_PILE_ZONE_LOGIC_H

C++/cockatrice/src/game/zones/stack_zone_logic.cpp

@@ -0,0 +1,19 @@
+#include "stack_zone_logic.h"
+
+#include "../../game_graphics/board/card_item.h"
+#include "card_zone_algorithms.h"
+
+StackZoneLogic::StackZoneLogic(PlayerLogic *_player,
+                               const QString &_name,
+                               bool _hasCardAttr,
+                               bool _isShufflable,
+                               bool _contentsKnown,
+                               QObject *parent)
+    : CardZoneLogic(_player, _name, _hasCardAttr, _isShufflable, _contentsKnown, parent)
+{
+}
+
+void StackZoneLogic::addCardImpl(CardItem *card, int x, int /*y*/)
+{
+    CardZoneAlgorithms::addCardToList(cards, card, x, true);
+}

C++/cockatrice/src/game/zones/stack_zone_logic.h

@@ -0,0 +1,26 @@
+/**
+ * @file stack_zone_logic.h
+ * @ingroup GameLogicZones
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_STACK_ZONE_LOGIC_H
+#define COCKATRICE_STACK_ZONE_LOGIC_H
+#include "card_zone_logic.h"
+
+class StackZoneLogic : public CardZoneLogic
+{
+    Q_OBJECT
+public:
+    StackZoneLogic(PlayerLogic *_player,
+                   const QString &_name,
+                   bool _hasCardAttr,
+                   bool _isShufflable,
+                   bool _contentsKnown,
+                   QObject *parent = nullptr);
+
+protected:
+    void addCardImpl(CardItem *card, int x, int y) override;
+};
+
+#endif // COCKATRICE_STACK_ZONE_LOGIC_H

C++/cockatrice/src/game/zones/table_zone_logic.cpp

@@ -0,0 +1,36 @@
+#include "table_zone_logic.h"
+
+#include "../../game_graphics/board/card_item.h"
+
+TableZoneLogic::TableZoneLogic(PlayerLogic *_player,
+                               const QString &_name,
+                               bool _hasCardAttr,
+                               bool _isShufflable,
+                               bool _contentsKnown,
+                               QObject *parent)
+    : CardZoneLogic(_player, _name, _hasCardAttr, _isShufflable, _contentsKnown, parent)
+{
+}
+
+void TableZoneLogic::addCardImpl(CardItem *card, int _x, int _y)
+{
+    cards.append(card);
+    if (!card->getFaceDown() && card->getPT().isEmpty()) {
+        card->setPT(card->getCardInfo().getPowTough());
+    }
+    if (card->getCardInfo().getUiAttributes().cipt && card->getCardInfo().getUiAttributes().landscapeOrientation) {
+        card->setDoesntUntap(true);
+    }
+    card->setGridPoint(QPoint(_x, _y));
+    card->setVisible(true);
+}
+
+CardItem *TableZoneLogic::takeCard(int position, int cardId, bool toNewZone)
+{
+    CardItem *result = CardZoneLogic::takeCard(position, cardId);
+
+    if (toNewZone) {
+        emit contentSizeChanged();
+    }
+    return result;
+}

C++/cockatrice/src/game/zones/table_zone_logic.h

@@ -0,0 +1,40 @@
+/**
+ * @file table_zone_logic.h
+ * @ingroup GameLogicZones
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_TABLE_ZONE_LOGIC_H
+#define COCKATRICE_TABLE_ZONE_LOGIC_H
+#include "card_zone_logic.h"
+
+class TableZoneLogic : public CardZoneLogic
+{
+    Q_OBJECT
+signals:
+    void contentSizeChanged();
+    void toggleTapped();
+
+public:
+    TableZoneLogic(PlayerLogic *_player,
+                   const QString &_name,
+                   bool _hasCardAttr,
+                   bool _isShufflable,
+                   bool _contentsKnown,
+                   QObject *parent = nullptr);
+
+protected:
+    void addCardImpl(CardItem *card, int x, int y) override;
+
+    /**
+     *  @brief Removes a card from view.
+     *
+     *  @param position card position
+     *  @param cardId id of card to take
+     *  @param toNewZone Whether the destination of the card is not the same as the starting zone. Defaults to true
+     *  @return CardItem that has been removed
+     */
+    CardItem *takeCard(int position, int cardId, bool toNewZone = true) override;
+};
+
+#endif // COCKATRICE_TABLE_ZONE_LOGIC_H

C++/cockatrice/src/game/zones/view_zone_logic.cpp

@@ -0,0 +1,165 @@
+#include "view_zone_logic.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../game_graphics/board/card_item.h"
+
+/**
+ * @param _player the player that the cards are revealed to.
+ * @param _origZone the zone the cards were revealed from.
+ * @param _revealZone if false, the cards will be face down.
+ * @param _writeableRevealZone whether the player can interact with the revealed cards.
+ */
+ZoneViewZoneLogic::ZoneViewZoneLogic(PlayerLogic *_player,
+                                     CardZoneLogic *_origZone,
+                                     int _numberCards,
+                                     bool _revealZone,
+                                     bool _writeableRevealZone,
+                                     bool _isReversed,
+                                     QObject *parent)
+    : CardZoneLogic(_player, _origZone->getName(), false, false, true, parent), origZone(_origZone),
+      numberCards(_numberCards), revealZone(_revealZone), writeableRevealZone(_writeableRevealZone),
+      isReversed(_isReversed)
+{
+}
+
+/**
+ * Checks if inserting a card at the given position requires an actual new card to be created and added to the view.
+ * Also does any cardId updates that would be required if a card is inserted in that position.
+ *
+ * Note that this method can end up modifying the cardIds despite returning false.
+ * (for example, if the card is inserted into a hidden portion of the deck while the view is reversed)
+ *
+ * Make sure to call this method once before calling addCard(), so that you skip creating a new CardItem and calling
+ * addCard() if it's not required.
+ *
+ * @param x The position to insert the card at.
+ * @return Whether to proceed with calling addCard.
+ */
+bool ZoneViewZoneLogic::prepareAddCard(int x)
+{
+    bool doInsert = false;
+    if (!isReversed) {
+        if (x <= cards.size() || cards.size() == -1) {
+            doInsert = true;
+        }
+    } else {
+        // map x (which is in origZone indexes) to this viewZone's cardList index
+        int firstId = cards.isEmpty() ? origZone->getCards().size() : cards.front()->getId();
+        int insertionIndex = x - firstId;
+        if (insertionIndex >= 0) {
+            // card was put into a portion of the deck that's in the view
+            doInsert = true;
+        } else {
+            // card was put into a portion of the deck that's not in the view; update ids but don't insert card
+            updateCardIds(ADD_CARD);
+        }
+    }
+
+    // autoclose check is done both here and in removeCard
+
+    if (cards.isEmpty() && !doInsert && SettingsCache::instance().getCloseEmptyCardView()) {
+        emit closeView();
+    }
+
+    return doInsert;
+}
+
+/**
+ * Make sure prepareAddCard() was called before calling addCard().
+ * This method assumes we already checked that the card is being inserted into the visible portion
+ */
+void ZoneViewZoneLogic::addCardImpl(CardItem *card, int x, int /*y*/)
+{
+    if (!isReversed) {
+        // if x is negative set it to add at end
+        // if x is out-of-bounds then also set it to add at the end
+        if (x < 0 || x >= cards.size()) {
+            x = cards.size();
+        }
+        cards.insert(x, card);
+    } else {
+        // map x (which is in origZone indexes) to this viewZone's cardList index
+        int firstId = cards.isEmpty() ? origZone->getCards().size() : cards.front()->getId();
+        int insertionIndex = x - firstId;
+        // qMin to prevent out-of-bounds error when bottoming a card that is already in the view
+        cards.insert(qMin(insertionIndex, cards.size()), card);
+    }
+
+    updateCardIds(ADD_CARD);
+    reorganizeCards();
+}
+
+void ZoneViewZoneLogic::updateCardIds(CardAction action)
+{
+    if (origZone->contentsKnown()) {
+        return;
+    }
+
+    if (cards.isEmpty()) {
+        return;
+    }
+
+    int cardCount = cards.size();
+
+    auto startId = 0;
+
+    if (isReversed) {
+        // the card has not been added to origZone's cardList at this point
+        startId = origZone->getCards().size() - cardCount;
+        switch (action) {
+            case INITIALIZE:
+                break;
+            case ADD_CARD:
+                startId += 1;
+                break;
+            case REMOVE_CARD:
+                startId -= 1;
+                break;
+        }
+    }
+
+    for (int i = 0; i < cardCount; ++i) {
+        cards[i]->setId(i + startId);
+    }
+}
+
+void ZoneViewZoneLogic::removeCard(int position, bool toNewZone)
+{
+    if (isReversed) {
+        position -= cards.first()->getId();
+        if (position < 0 || position >= cards.size()) {
+            updateCardIds(REMOVE_CARD);
+            return;
+        }
+    }
+
+    if (position >= cards.size()) {
+        return;
+    }
+
+    CardItem *card = cards.takeAt(position);
+    card->deleteLater();
+
+    // The toNewZone check is to prevent the view from auto-closing if the view contains only a single card and that
+    // card gets dragged within the view.
+    // Another autoclose check is done in prepareAddCard so that the view autocloses if the last card was moved to an
+    // unrevealed portion of the same zone.
+    if (cards.isEmpty() && SettingsCache::instance().getCloseEmptyCardView() && toNewZone) {
+        emit closeView();
+        return;
+    }
+
+    updateCardIds(REMOVE_CARD);
+    reorganizeCards();
+}
+
+void ZoneViewZoneLogic::setWriteableRevealZone(bool _writeableRevealZone)
+{
+
+    if (writeableRevealZone && !_writeableRevealZone) {
+        emit addToViews();
+    } else if (!writeableRevealZone && _writeableRevealZone) {
+        emit removeFromViews();
+    }
+    writeableRevealZone = _writeableRevealZone;
+}

C++/cockatrice/src/game/zones/view_zone_logic.h

@@ -0,0 +1,71 @@
+/**
+ * @file view_zone_logic.h
+ * @ingroup GameLogicZones
+ */
+//! \todo Document this file.
+
+#ifndef COCKATRICE_VIEW_ZONE_LOGIC_H
+#define COCKATRICE_VIEW_ZONE_LOGIC_H
+#include "card_zone_logic.h"
+
+class ZoneViewZoneLogic : public CardZoneLogic
+{
+    Q_OBJECT
+signals:
+    void addToViews();
+    void removeFromViews();
+    void closeView();
+
+private:
+    CardZoneLogic *origZone;
+    int numberCards;
+    bool revealZone, writeableRevealZone;
+    bool isReversed;
+
+public:
+    enum CardAction
+    {
+        INITIALIZE,
+        ADD_CARD,
+        REMOVE_CARD
+    };
+
+    ZoneViewZoneLogic(PlayerLogic *_player,
+                      CardZoneLogic *_origZone,
+                      int _numberCards,
+                      bool _revealZone,
+                      bool _writeableRevealZone,
+                      bool _isReversed,
+                      QObject *parent = nullptr);
+
+    bool prepareAddCard(int x);
+    void removeCard(int position, bool toNewZone);
+    void updateCardIds(CardAction action);
+    int getNumberCards() const
+    {
+        return numberCards;
+    }
+    bool getRevealZone() const
+    {
+        return revealZone;
+    }
+    bool getWriteableRevealZone() const
+    {
+        return writeableRevealZone;
+    }
+    void setWriteableRevealZone(bool _writeableRevealZone);
+    bool getIsReversed() const
+    {
+        return isReversed;
+    }
+
+    CardZoneLogic *getOriginalZone() const
+    {
+        return origZone;
+    }
+
+protected:
+    void addCardImpl(CardItem *card, int x, int y) override;
+};
+
+#endif // COCKATRICE_VIEW_ZONE_LOGIC_H

C++/cockatrice/src/game_graphics/board/abstract_card_drag_item.cpp

@@ -0,0 +1,72 @@
+#include "abstract_card_drag_item.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../z_values.h"
+
+#include <QCursor>
+#include <QDebug>
+#include <QGraphicsSceneMouseEvent>
+#include <QPainter>
+
+const QColor GHOST_MASK = QColor(255, 255, 255, 50);
+
+AbstractCardDragItem::AbstractCardDragItem(AbstractCardItem *_item,
+                                           const QPointF &_hotSpot,
+                                           AbstractCardDragItem *parentDrag)
+    : QGraphicsItem(), item(_item), hotSpot(_hotSpot)
+{
+    if (parentDrag) {
+        parentDrag->addChildDrag(this);
+        setZValue(ZValues::childDragZValue(hotSpot.x(), hotSpot.y()));
+        connect(parentDrag, &QObject::destroyed, this, &AbstractCardDragItem::deleteLater);
+    } else {
+        hotSpot = QPointF{qBound(0.0, hotSpot.x(), CardDimensions::WIDTH_F - 1),
+                          qBound(0.0, hotSpot.y(), CardDimensions::HEIGHT_F - 1)};
+        setCursor(Qt::ClosedHandCursor);
+        setZValue(ZValues::DRAG_ITEM);
+    }
+    if (item->getTapped()) {
+        setTransform(QTransform()
+                         .translate(CardDimensions::WIDTH_HALF_F, CardDimensions::HEIGHT_HALF_F)
+                         .rotate(90)
+                         .translate(-CardDimensions::WIDTH_HALF_F, -CardDimensions::HEIGHT_HALF_F));
+    }
+
+    setCacheMode(DeviceCoordinateCache);
+
+    connect(&SettingsCache::instance(), &SettingsCache::roundCardCornersChanged, this, [this](bool _roundCardCorners) {
+        Q_UNUSED(_roundCardCorners);
+
+        prepareGeometryChange();
+        update();
+    });
+
+    connect(item, &QObject::destroyed, this, &AbstractCardDragItem::deleteLater);
+}
+
+QPainterPath AbstractCardDragItem::shape() const
+{
+    QPainterPath shape;
+    qreal cardCornerRadius = SettingsCache::instance().getRoundCardCorners() ? 0.05 * CardDimensions::WIDTH_F : 0.0;
+    shape.addRoundedRect(boundingRect(), cardCornerRadius, cardCornerRadius);
+    return shape;
+}
+
+void AbstractCardDragItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+    item->paint(painter, option, widget);
+
+    // adds a mask to the card so it looks like the card hasnt been placed yet
+    painter->fillPath(shape(), GHOST_MASK);
+}
+
+void AbstractCardDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    event->accept();
+    updatePosition(event->scenePos());
+}
+
+void AbstractCardDragItem::addChildDrag(AbstractCardDragItem *child)
+{
+    childDrags << child;
+}

C++/cockatrice/src/game_graphics/board/abstract_card_drag_item.h

@@ -0,0 +1,56 @@
+/**
+ * @file abstract_card_drag_item.h
+ * @ingroup GameGraphicsCards
+ */
+//! \todo Document this file.
+
+#ifndef ABSTRACTCARDDRAGITEM_H
+#define ABSTRACTCARDDRAGITEM_H
+
+#include "abstract_card_item.h"
+
+class QGraphicsScene;
+class CardZone;
+class CardInfo;
+
+class AbstractCardDragItem : public QObject, public QGraphicsItem
+{
+    Q_OBJECT
+    Q_INTERFACES(QGraphicsItem)
+protected:
+    AbstractCardItem *item;
+    QPointF hotSpot;
+    QList<AbstractCardDragItem *> childDrags;
+
+public:
+    enum
+    {
+        Type = typeCardDrag
+    };
+    [[nodiscard]] int type() const override
+    {
+        return Type;
+    }
+    AbstractCardDragItem(AbstractCardItem *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag = 0);
+    [[nodiscard]] QRectF boundingRect() const override
+    {
+        return QRectF(0, 0, CardDimensions::WIDTH_F, CardDimensions::HEIGHT_F);
+    }
+    [[nodiscard]] QPainterPath shape() const override;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    [[nodiscard]] AbstractCardItem *getItem() const
+    {
+        return item;
+    }
+    [[nodiscard]] QPointF getHotSpot() const
+    {
+        return hotSpot;
+    }
+    void addChildDrag(AbstractCardDragItem *child);
+    virtual void updatePosition(const QPointF &cursorScenePos) = 0;
+
+protected:
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
+};
+
+#endif

C++/cockatrice/src/game_graphics/board/abstract_card_item.cpp

@@ -0,0 +1,349 @@
+#include "abstract_card_item.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../interface/card_picture_loader/card_picture_loader.h"
+#include "../game_scene.h"
+#include "../z_values.h"
+
+#include <QCursor>
+#include <QGraphicsScene>
+#include <QGraphicsSceneMouseEvent>
+#include <QPainter>
+#include <algorithm>
+#include <libcockatrice/card/database/card_database.h>
+#include <libcockatrice/card/database/card_database_manager.h>
+
+AbstractCardItem::AbstractCardItem(QGraphicsItem *parent, const CardRef &cardRef, PlayerLogic *_owner, int _id)
+    : ArrowTarget(_owner, parent), id(_id), cardRef(cardRef), tapped(false), facedown(false), tapAngle(0),
+      bgColor(Qt::transparent), isHovered(false), realZValue(0)
+{
+    setCursor(Qt::OpenHandCursor);
+    setFlag(ItemIsSelectable);
+    setCacheMode(DeviceCoordinateCache);
+
+    connect(&SettingsCache::instance(), &SettingsCache::displayCardNamesChanged, this, [this] { update(); });
+    refreshCardInfo();
+
+    connect(&SettingsCache::instance(), &SettingsCache::roundCardCornersChanged, this, [this](bool _roundCardCorners) {
+        Q_UNUSED(_roundCardCorners);
+
+        prepareGeometryChange();
+        update();
+    });
+}
+
+AbstractCardItem::~AbstractCardItem()
+{
+    emit deleteCardInfoPopup(cardRef.name);
+}
+
+QRectF AbstractCardItem::boundingRect() const
+{
+    return QRectF(0, 0, CardDimensions::WIDTH_F, CardDimensions::HEIGHT_F);
+}
+
+QPainterPath AbstractCardItem::shape() const
+{
+    QPainterPath shape;
+    qreal cardCornerRadius = SettingsCache::instance().getRoundCardCorners() ? 0.05 * CardDimensions::WIDTH_F : 0.0;
+    shape.addRoundedRect(boundingRect(), cardCornerRadius, cardCornerRadius);
+    return shape;
+}
+
+void AbstractCardItem::pixmapUpdated()
+{
+    update();
+    emit sigPixmapUpdated();
+}
+
+void AbstractCardItem::refreshCardInfo()
+{
+    exactCard = CardDatabaseManager::query()->getCard(cardRef);
+
+    if (!exactCard && !cardRef.name.isEmpty()) {
+        CardInfo::UiAttributes attributes = {.tableRow = -1};
+        auto info = CardInfo::newInstance(cardRef.name, "", true, {}, {}, {}, {}, attributes);
+        exactCard = ExactCard(info);
+    }
+    if (exactCard) {
+        connect(exactCard.getCardPtr().data(), &CardInfo::pixmapUpdated, this, &AbstractCardItem::pixmapUpdated);
+    }
+
+    cacheBgColor();
+    update();
+}
+
+/**
+ * Convenience method to get the CardInfo of the exactCard
+ * @return A const reference to the CardInfo, or an empty CardInfo if card was null
+ */
+const CardInfo &AbstractCardItem::getCardInfo() const
+{
+    return exactCard.getInfo();
+}
+
+void AbstractCardItem::setRealZValue(qreal _zValue)
+{
+    realZValue = _zValue;
+    // During hover, zValue is overridden to HOVERED_CARD. Layout operations
+    // like reorganizeCards() call setRealZValue() on all cards including the
+    // hovered one — skip setZValue() here to avoid clobbering the override.
+    if (!isHovered) {
+        setZValue(_zValue);
+    }
+}
+
+QSizeF AbstractCardItem::getTranslatedSize(QPainter *painter) const
+{
+    return QSizeF(painter->combinedTransform().map(QLineF(0, 0, boundingRect().width(), 0)).length(),
+                  painter->combinedTransform().map(QLineF(0, 0, 0, boundingRect().height())).length());
+}
+
+void AbstractCardItem::transformPainter(QPainter *painter, const QSizeF &translatedSize, int angle)
+{
+    const int MAX_FONT_SIZE = SettingsCache::instance().getMaxFontSize();
+    const int fontSize = std::max(9, MAX_FONT_SIZE);
+
+    QRectF totalBoundingRect = painter->combinedTransform().mapRect(boundingRect());
+
+    int scale = resetPainterTransform(painter);
+
+    painter->translate(totalBoundingRect.width() / 2, totalBoundingRect.height() / 2);
+    painter->rotate(angle);
+    painter->translate(-translatedSize.width() / 2, -translatedSize.height() / 2);
+
+    QFont f;
+    f.setPixelSize(fontSize * scale);
+
+    painter->setFont(f);
+}
+
+void AbstractCardItem::paintPicture(QPainter *painter, const QSizeF &translatedSize, int angle)
+{
+    qreal scaleFactor = translatedSize.width() / boundingRect().width();
+    QPixmap translatedPixmap;
+    bool paintImage = true;
+
+    if (facedown || cardRef.name.isEmpty()) {
+        // never reveal card color, always paint the card back
+        CardPictureLoader::getCardBackPixmap(translatedPixmap, translatedSize.toSize());
+    } else {
+        // don't even spend time trying to load the picture if our size is too small
+        if (translatedSize.width() > 10) {
+            CardPictureLoader::getPixmap(translatedPixmap, exactCard, translatedSize.toSize());
+            if (translatedPixmap.isNull()) {
+                paintImage = false;
+            }
+        } else {
+            paintImage = false;
+        }
+    }
+
+    painter->save();
+
+    if (paintImage) {
+        painter->save();
+        painter->setClipPath(shape());
+        painter->drawPixmap(boundingRect(), translatedPixmap, QRectF({0, 0}, translatedPixmap.size()));
+        painter->restore();
+    } else {
+        painter->setBrush(bgColor);
+        painter->drawPath(shape());
+    }
+
+    if (translatedPixmap.isNull() || SettingsCache::instance().getDisplayCardNames() || facedown) {
+        painter->save();
+        transformPainter(painter, translatedSize, angle);
+        painter->setPen(Qt::white);
+        painter->setBackground(Qt::black);
+        painter->setBackgroundMode(Qt::OpaqueMode);
+        QString nameStr;
+        if (facedown) {
+            nameStr = "# " + QString::number(id);
+        } else {
+            QString prefix = "";
+            if (SettingsCache::instance().debug().getShowCardId()) {
+                prefix = "#" + QString::number(id) + " ";
+            }
+            nameStr = prefix + cardRef.name;
+        }
+        painter->drawText(QRectF(3 * scaleFactor, 3 * scaleFactor, translatedSize.width() - 6 * scaleFactor,
+                                 translatedSize.height() - 6 * scaleFactor),
+                          Qt::AlignTop | Qt::AlignLeft | Qt::TextWrapAnywhere, nameStr);
+        painter->restore();
+    }
+
+    painter->restore();
+}
+
+void AbstractCardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
+{
+    painter->save();
+
+    QSizeF translatedSize = getTranslatedSize(painter);
+    paintPicture(painter, translatedSize, tapAngle);
+
+    painter->setRenderHint(QPainter::Antialiasing, false);
+
+    if (isSelected() || isHovered) {
+        QPen pen;
+        if (isHovered) {
+            pen.setColor(Qt::yellow);
+        }
+        if (isSelected()) {
+            pen.setColor(Qt::red);
+        }
+        pen.setWidth(0); // Cosmetic pen
+        painter->setPen(pen);
+        painter->drawPath(shape());
+    }
+
+    painter->restore();
+}
+
+void AbstractCardItem::setCardRef(const CardRef &_cardRef)
+{
+    if (cardRef == _cardRef) {
+        return;
+    }
+
+    emit deleteCardInfoPopup(cardRef.name);
+    if (exactCard) {
+        disconnect(exactCard.getCardPtr().data(), nullptr, this, nullptr);
+    }
+    cardRef = _cardRef;
+
+    refreshCardInfo();
+}
+
+void AbstractCardItem::setHovered(bool _hovered)
+{
+    if (isHovered == _hovered) {
+        return;
+    }
+
+    if (_hovered) {
+        processHoverEvent();
+    } else {
+        // Mark the hovered card's current scene footprint dirty so overlapped
+        // sibling zones (e.g. StackZone) repaint after the card moves away.
+        if (scene()) {
+            scene()->update(sceneBoundingRect());
+        }
+    }
+
+    isHovered = _hovered;
+    setZValue(_hovered ? ZValues::HOVERED_CARD : realZValue);
+    setScale(_hovered && SettingsCache::instance().getScaleCards() ? 1.1 : 1);
+    setTransformOriginPoint(_hovered ? CardDimensions::WIDTH_HALF_F : 0, _hovered ? CardDimensions::HEIGHT_HALF_F : 0);
+    update();
+}
+
+void AbstractCardItem::setColor(const QString &_color)
+{
+    color = _color;
+    cacheBgColor();
+    update();
+}
+
+void AbstractCardItem::cacheBgColor()
+{
+    QChar colorChar;
+    if (color.isEmpty()) {
+        colorChar = exactCard.getInfo().getColorChar();
+    } else {
+        colorChar = color.at(0);
+    }
+
+    switch (colorChar.toLower().toLatin1()) {
+        case 'b':
+            bgColor = QColor(0, 0, 0);
+            break;
+        case 'u':
+            bgColor = QColor(0, 140, 180);
+            break;
+        case 'w':
+            bgColor = QColor(255, 250, 140);
+            break;
+        case 'r':
+            bgColor = QColor(230, 0, 0);
+            break;
+        case 'g':
+            bgColor = QColor(0, 160, 0);
+            break;
+        case 'm':
+            bgColor = QColor(250, 190, 30);
+            break;
+        default:
+            bgColor = QColor(230, 230, 230);
+            break;
+    }
+}
+
+void AbstractCardItem::setTapped(bool _tapped, bool canAnimate)
+{
+    if (tapped == _tapped) {
+        return;
+    }
+
+    tapped = _tapped;
+    if (SettingsCache::instance().getTapAnimation() && canAnimate) {
+        static_cast<GameScene *>(scene())->registerAnimationItem(this);
+    } else {
+        tapAngle = tapped ? 90 : 0;
+        setTransform(QTransform()
+                         .translate(CardDimensions::WIDTH_HALF_F, CardDimensions::HEIGHT_HALF_F)
+                         .rotate(tapAngle)
+                         .translate(-CardDimensions::WIDTH_HALF_F, -CardDimensions::HEIGHT_HALF_F));
+        update();
+    }
+}
+
+void AbstractCardItem::setFaceDown(bool _facedown)
+{
+    facedown = _facedown;
+    update();
+}
+
+void AbstractCardItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    if ((event->modifiers() & Qt::AltModifier) && event->button() == Qt::LeftButton) {
+        emit cardShiftClicked(cardRef.name);
+    } else if ((event->modifiers() & Qt::ControlModifier)) {
+        setSelected(!isSelected());
+    } else if (!isSelected()) {
+        scene()->clearSelection();
+        setSelected(true);
+    }
+    if (event->button() == Qt::LeftButton) {
+        setCursor(Qt::ClosedHandCursor);
+    } else if (event->button() == Qt::MiddleButton) {
+        emit showCardInfoPopup(event->screenPos(), cardRef);
+    }
+    event->accept();
+}
+
+void AbstractCardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::MiddleButton) {
+        emit deleteCardInfoPopup(cardRef.name);
+    }
+
+    // This function ensures the parent function doesn't mess around with our selection.
+    event->accept();
+}
+
+void AbstractCardItem::processHoverEvent()
+{
+    emit hovered(this);
+}
+
+QVariant AbstractCardItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    if (change == ItemSelectedHasChanged) {
+        update();
+        return value;
+    } else {
+        return ArrowTarget::itemChange(change, value);
+    }
+}

C++/cockatrice/src/game_graphics/board/abstract_card_item.h

@@ -0,0 +1,137 @@
+/**
+ * @file abstract_card_item.h
+ * @ingroup GameGraphicsCards
+ * @brief Base class for graphical card items, providing shared rendering, identity, and interaction logic.
+ */
+
+#ifndef ABSTRACTCARDITEM_H
+#define ABSTRACTCARDITEM_H
+
+#include "../card_dimensions.h"
+#include "arrow_target.h"
+#include "graphics_item_type.h"
+
+#include <libcockatrice/card/printing/exact_card.h>
+#include <libcockatrice/utility/card_ref.h>
+
+class PlayerLogic;
+
+class AbstractCardItem : public ArrowTarget
+{
+    Q_OBJECT
+protected:
+    ExactCard exactCard;
+    int id;
+    CardRef cardRef;
+    bool tapped;
+    bool facedown;
+    int tapAngle;
+    QString color;
+    QColor bgColor;
+
+private:
+    bool isHovered;
+    qreal realZValue;
+private slots:
+    void pixmapUpdated();
+
+public slots:
+    void refreshCardInfo();
+
+signals:
+    void hovered(AbstractCardItem *card);
+    void showCardInfoPopup(const QPoint &pos, const CardRef &cardRef);
+    void deleteCardInfoPopup(QString cardName);
+    void sigPixmapUpdated();
+    void cardShiftClicked(QString cardName);
+    void rightClicked(AbstractCardItem *card, QPoint screenPos);
+    void playSelected(AbstractCardItem *card);
+    void playSelectedFaceDown(AbstractCardItem *card);
+    void hideSelected(AbstractCardItem *card);
+    void selectionChanged(AbstractCardItem *card, bool selected);
+
+public:
+    enum
+    {
+        Type = typeCard
+    };
+    int type() const override
+    {
+        return Type;
+    }
+    explicit AbstractCardItem(QGraphicsItem *parent = nullptr,
+                              const CardRef &cardRef = {},
+                              PlayerLogic *_owner = nullptr,
+                              int _id = -1);
+    ~AbstractCardItem() override;
+    QRectF boundingRect() const override;
+    QPainterPath shape() const override;
+    QSizeF getTranslatedSize(QPainter *painter) const;
+    void paintPicture(QPainter *painter, const QSizeF &translatedSize, int angle);
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    ExactCard getCard() const
+    {
+        return exactCard;
+    }
+    const CardInfo &getCardInfo() const;
+    int getId() const
+    {
+        return id;
+    }
+    void setId(int _id)
+    {
+        id = _id;
+    }
+    QString getName() const
+    {
+        return cardRef.name;
+    }
+    QString getProviderId() const
+    {
+        return cardRef.providerId;
+    }
+    void setCardRef(const CardRef &_cardRef);
+    CardRef getCardRef() const
+    {
+        return cardRef;
+    }
+    qreal getRealZValue() const
+    {
+        return realZValue;
+    }
+    void setRealZValue(qreal _zValue);
+    void setHovered(bool _hovered);
+    bool getIsHovered() const
+    {
+        return isHovered;
+    }
+    QString getColor() const
+    {
+        return color;
+    }
+    void setColor(const QString &_color);
+    bool getTapped() const
+    {
+        return tapped;
+    }
+    void setTapped(bool _tapped, bool canAnimate = false);
+    bool getFaceDown() const
+    {
+        return facedown;
+    }
+    void setFaceDown(bool _facedown);
+    void processHoverEvent();
+    void deleteCardInfoPopup()
+    {
+        emit deleteCardInfoPopup(cardRef.name);
+    }
+
+protected:
+    void transformPainter(QPainter *painter, const QSizeF &translatedSize, int angle);
+    void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
+    QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) override;
+    void cacheBgColor();
+};
+
+#endif

C++/cockatrice/src/game_graphics/board/abstract_counter.cpp

@@ -0,0 +1,229 @@
+#include "abstract_counter.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../../game_graphics/board/translate_counter_name.h"
+#include "../../interface/widgets/tabs/tab_game.h"
+
+#include <QAction>
+#include <QApplication>
+#include <QGraphicsSceneMouseEvent>
+#include <QGraphicsView>
+#include <QKeyEvent>
+#include <QMenu>
+#include <QString>
+#include <libcockatrice/protocol/pb/command_inc_counter.pb.h>
+#include <libcockatrice/protocol/pb/command_set_counter.pb.h>
+#include <libcockatrice/utility/expression.h>
+
+AbstractCounter::AbstractCounter(CounterState *state,
+                                 PlayerLogic *_player,
+                                 bool _shownInCounterArea,
+                                 bool _useNameForShortcut,
+                                 QGraphicsItem *parent)
+    : QGraphicsItem(parent), player(_player), id(state->getId()), name(state->getName()), value(state->getValue()),
+      color(state->getColor()), radius(state->getRadius()), useNameForShortcut(_useNameForShortcut),
+      shownInCounterArea(_shownInCounterArea)
+{
+    setAcceptHoverEvents(true);
+
+    connect(state, &CounterState::valueChanged, this, [this](int, int newValue) {
+        value = newValue;
+        update();
+    });
+
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
+        menu = new TearOffMenu(TranslateCounterName::getDisplayName(state->getName()));
+        aSet = new QAction(this);
+        connect(aSet, &QAction::triggered, this, &AbstractCounter::setCounter);
+        menu->addAction(aSet);
+        menu->addSeparator();
+        for (int i = 10; i >= -10; --i) {
+            if (i == 0) {
+                menu->addSeparator();
+                continue;
+            }
+            auto *a = new QAction(QString(i < 0 ? "%1" : "+%1").arg(i), this);
+            if (i == -1) {
+                aDec = a;
+            }
+            if (i == 1) {
+                aInc = a;
+            }
+            a->setData(i);
+            connect(a, &QAction::triggered, this, &AbstractCounter::incrementCounter);
+            menu->addAction(a);
+        }
+    } else {
+        menu = nullptr;
+    }
+
+    connect(&SettingsCache::instance().shortcuts(), &ShortcutsSettings::shortCutChanged, this,
+            &AbstractCounter::refreshShortcuts);
+    refreshShortcuts();
+    retranslateUi();
+}
+
+AbstractCounter::~AbstractCounter()
+{
+    delete menu;
+}
+
+void AbstractCounter::delCounter()
+{
+    if (dialogSemaphore) {
+        deleteAfterDialog = true;
+    } else {
+        deleteLater();
+    }
+}
+
+void AbstractCounter::retranslateUi()
+{
+    if (aSet) {
+        aSet->setText(tr("&Set counter..."));
+    }
+}
+
+void AbstractCounter::setShortcutsActive()
+{
+    if (!menu || !player->getPlayerInfo()->getLocal()) {
+        return;
+    }
+    ShortcutsSettings &sc = SettingsCache::instance().shortcuts();
+    shortcutActive = true;
+    if (name == "life") {
+        aSet->setShortcuts(sc.getShortcut("Player/aSet"));
+        aDec->setShortcuts(sc.getShortcut("Player/aDec"));
+        aInc->setShortcuts(sc.getShortcut("Player/aInc"));
+    } else if (useNameForShortcut) {
+        aSet->setShortcuts(sc.getShortcut("Player/aSetCounter_" + name));
+        aDec->setShortcuts(sc.getShortcut("Player/aDecCounter_" + name));
+        aInc->setShortcuts(sc.getShortcut("Player/aIncCounter_" + name));
+    }
+}
+
+void AbstractCounter::setShortcutsInactive()
+{
+    if (!menu) {
+        return;
+    }
+
+    shortcutActive = false;
+    if (name == "life" || useNameForShortcut) {
+        aSet->setShortcut(QKeySequence());
+        aDec->setShortcut(QKeySequence());
+        aInc->setShortcut(QKeySequence());
+    }
+}
+
+void AbstractCounter::refreshShortcuts()
+{
+    if (shortcutActive) {
+        setShortcutsActive();
+    }
+}
+
+void AbstractCounter::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (!isUnderMouse() || !player->getPlayerInfo()->getLocalOrJudge()) {
+        event->ignore();
+        return;
+    }
+
+    if (event->button() == Qt::MiddleButton || QApplication::keyboardModifiers() & Qt::ShiftModifier) {
+        if (menu) {
+            menu->exec(event->screenPos());
+        }
+    } else {
+        Command_IncCounter cmd;
+        cmd.set_counter_id(id);
+        cmd.set_delta(event->button() == Qt::LeftButton ? 1 : -1);
+        player->getPlayerActions()->sendGameCommand(cmd);
+    }
+    event->accept();
+}
+
+void AbstractCounter::hoverEnterEvent(QGraphicsSceneHoverEvent *)
+{
+    hovered = true;
+    update();
+}
+void AbstractCounter::hoverLeaveEvent(QGraphicsSceneHoverEvent *)
+{
+    hovered = false;
+    update();
+}
+
+void AbstractCounter::incrementCounter()
+{
+    Command_IncCounter cmd;
+    cmd.set_counter_id(id);
+    cmd.set_delta(static_cast<QAction *>(sender())->data().toInt());
+    player->getPlayerActions()->sendGameCommand(cmd);
+}
+
+void AbstractCounter::setCounter()
+{
+    QWidget *parent = nullptr;
+    if (auto *view = scene() ? scene()->views().value(0) : nullptr) {
+        parent = view->window();
+    }
+
+    dialogSemaphore = true;
+    AbstractCounterDialog dlg(name, QString::number(value), parent);
+    const int ok = dlg.exec();
+    dialogSemaphore = false;
+
+    if (deleteAfterDialog) {
+        deleteLater();
+        return;
+    }
+    if (!ok) {
+        return;
+    }
+
+    Expression exp(value);
+    Command_SetCounter cmd;
+    cmd.set_counter_id(id);
+    cmd.set_value(static_cast<int>(exp.parse(dlg.textValue())));
+    player->getPlayerActions()->sendGameCommand(cmd);
+}
+
+AbstractCounterDialog::AbstractCounterDialog(const QString &name, const QString &value, QWidget *parent)
+    : QInputDialog(parent)
+{
+    setWindowTitle(tr("Set counter"));
+    setLabelText(tr("New value for counter '%1':").arg(name));
+    setTextValue(value);
+    qApp->installEventFilter(this);
+}
+
+bool AbstractCounterDialog::eventFilter(QObject *obj, QEvent *event)
+{
+    Q_UNUSED(obj);
+    if (event->type() == QEvent::KeyPress) {
+        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
+        switch (keyEvent->key()) {
+            case Qt::Key_Up:
+                changeValue(+1);
+                return true;
+            case Qt::Key_Down:
+                changeValue(-1);
+                return true;
+        }
+    }
+    return false;
+}
+
+void AbstractCounterDialog::changeValue(int diff)
+{
+    bool ok;
+    int curValue = textValue().toInt(&ok);
+    if (!ok) {
+        return;
+    }
+    curValue += diff;
+    setTextValue(QString::number(curValue));
+}

C++/cockatrice/src/game_graphics/board/abstract_counter.h

@@ -0,0 +1,109 @@
+/**
+ * @file abstract_counter.h
+ * @ingroup GameGraphicsPlayers
+ */
+//! \todo Document this file.
+
+#ifndef COUNTER_H
+#define COUNTER_H
+
+#include "../../game/board/counter_state.h"
+#include "../../interface/widgets/menus/tearoff_menu.h"
+#include "../player/menu/abstract_player_component.h"
+
+#include <QGraphicsItem>
+#include <QInputDialog>
+
+class PlayerLogic;
+class QAction;
+class QKeyEvent;
+class QMenu;
+class QString;
+
+class AbstractCounter : public QObject, public QGraphicsItem, public AbstractPlayerComponent
+{
+    Q_OBJECT
+    Q_INTERFACES(QGraphicsItem)
+
+protected:
+    PlayerLogic *player;
+    int id;
+    QString name;
+    int value;
+    QColor color;
+    int radius;
+    bool hovered = false;
+    bool useNameForShortcut;
+
+    void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override;
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;
+
+private:
+    QAction *aSet = nullptr, *aDec = nullptr, *aInc = nullptr;
+    TearOffMenu *menu = nullptr;
+    bool dialogSemaphore = false;
+    bool deleteAfterDialog = false;
+    bool shownInCounterArea;
+    bool shortcutActive = false;
+
+private slots:
+    void refreshShortcuts();
+    void incrementCounter();
+    void setCounter();
+
+public:
+    AbstractCounter(CounterState *state,
+                    PlayerLogic *player,
+                    bool shownInCounterArea,
+                    bool useNameForShortcut = false,
+                    QGraphicsItem *parent = nullptr);
+    ~AbstractCounter() override;
+
+    void retranslateUi() override;
+    void setShortcutsActive() override;
+    void setShortcutsInactive() override;
+    void delCounter();
+
+    QMenu *getMenu() const
+    {
+        return menu;
+    }
+    int getId() const
+    {
+        return id;
+    }
+    QString getName() const
+    {
+        return name;
+    }
+    QColor getColor() const
+    {
+        return color;
+    }
+    int getRadius() const
+    {
+        return radius;
+    }
+    int getValue() const
+    {
+        return value;
+    }
+    bool getShownInCounterArea() const
+    {
+        return shownInCounterArea;
+    }
+};
+
+class AbstractCounterDialog : public QInputDialog
+{
+    Q_OBJECT
+public:
+    AbstractCounterDialog(const QString &name, const QString &value, QWidget *parent = nullptr);
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *event) override;
+    void changeValue(int diff);
+};
+
+#endif

C++/cockatrice/src/game_graphics/board/abstract_graphics_item.cpp

@@ -0,0 +1,62 @@
+#include "abstract_graphics_item.h"
+
+#include <QPainter>
+
+void AbstractGraphicsItem::paintNumberEllipse(int number,
+                                              int fontSize,
+                                              const QColor &color,
+                                              int position,
+                                              int count,
+                                              QPainter *painter)
+{
+    painter->save();
+
+    QString numStr = QString::number(number);
+    QFont font("Serif");
+    font.setPixelSize(fontSize);
+    font.setWeight(QFont::Bold);
+
+    QFontMetrics fm(font);
+    double w = 1.3 * fm.horizontalAdvance(numStr);
+    double h = fm.height() * 1.3;
+    if (w < h) {
+        w = h;
+    }
+
+    painter->setPen(QColor(255, 255, 255, 0));
+    painter->setBrush(QBrush(QColor(color)));
+
+    QRectF textRect;
+    if (position == -1) {
+        textRect = QRectF((boundingRect().width() - w) / 2.0, (boundingRect().height() - h) / 2.0, w, h);
+    } else {
+        qreal xOffset = 10;
+        qreal yOffset = 20;
+        qreal spacing = 2;
+        if (position < 2) {
+            textRect = QRectF(count == 1 ? ((boundingRect().width() - w) / 2.0)
+                                         : (position % 2 == 0 ? xOffset : (boundingRect().width() - xOffset - w)),
+                              yOffset, w, h);
+        } else {
+            textRect = QRectF(count == 3 ? ((boundingRect().width() - w) / 2.0)
+                                         : (position % 2 == 0 ? xOffset : (boundingRect().width() - xOffset - w)),
+                              yOffset + (spacing + h) * (position / 2), w, h);
+        }
+    }
+
+    painter->drawEllipse(textRect);
+
+    painter->setPen(Qt::black);
+    painter->setFont(font);
+    painter->drawText(textRect, Qt::AlignCenter, numStr);
+
+    painter->restore();
+}
+
+int resetPainterTransform(QPainter *painter)
+{
+    painter->resetTransform();
+    auto tx = painter->deviceTransform().inverted();
+    painter->setTransform(tx);
+    return tx.isScaling() ? 1.0 / tx.m11() : 1;
+}

C++/cockatrice/src/game_graphics/board/abstract_graphics_item.h

@@ -0,0 +1,30 @@
+/**
+ * @file abstract_graphics_item.h
+ * @ingroup GameGraphics
+ */
+//! \todo Document this file.
+
+#ifndef ABSTRACTGRAPHICSITEM_H
+#define ABSTRACTGRAPHICSITEM_H
+
+#include <QGraphicsItem>
+
+/**
+ * Parent class of all objects that appear in a game.
+ */
+class AbstractGraphicsItem : public QGraphicsObject
+{
+    Q_OBJECT
+
+protected:
+    void paintNumberEllipse(int number, int radius, const QColor &color, int position, int count, QPainter *painter);
+
+public:
+    explicit AbstractGraphicsItem(QGraphicsItem *parent = nullptr) : QGraphicsObject(parent)
+    {
+    }
+};
+
+int resetPainterTransform(QPainter *painter);
+
+#endif

C++/cockatrice/src/game_graphics/board/arrow_item.cpp

@@ -0,0 +1,392 @@
+#define _USE_MATH_DEFINES
+#include "arrow_item.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player/player_target.h"
+#include "../z_values.h"
+#include "../zones/card_zone.h"
+#include "card_item.h"
+
+#include <QDebug>
+#include <QGraphicsScene>
+#include <QGraphicsSceneMouseEvent>
+#include <QPainter>
+#include <QtMath>
+#include <libcockatrice/card/card_info.h>
+#include <libcockatrice/protocol/pb/command_attach_card.pb.h>
+#include <libcockatrice/protocol/pb/command_create_arrow.pb.h>
+#include <libcockatrice/protocol/pb/command_delete_arrow.pb.h>
+#include <libcockatrice/utility/color.h>
+#include <libcockatrice/utility/zone_names.h>
+
+ArrowItem::ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startItem, ArrowTarget *_targetItem)
+    : data(std::move(_data)), startItem(_startItem), targetItem(_targetItem)
+{
+    setZValue(ZValues::ARROWS);
+
+    auto doUpdate = [this]() {
+        if (startItem && targetItem) {
+            updatePath();
+        }
+    };
+
+    if (startItem) {
+        connect(startItem, &ArrowTarget::scenePositionChanged, this, doUpdate);
+        connect(startItem, &QObject::destroyed, this, &ArrowItem::onTargetDestroyed);
+    }
+    if (targetItem) {
+        connect(targetItem, &ArrowTarget::scenePositionChanged, this, doUpdate);
+        connect(targetItem, &QObject::destroyed, this, &ArrowItem::onTargetDestroyed);
+    }
+
+    if (startItem && targetItem) {
+        updatePath();
+    }
+}
+
+void ArrowItem::onTargetDestroyed()
+{
+    emit requestDeletion(data->creatorId, data->id);
+}
+
+void ArrowItem::delArrow()
+{
+    if (targetItem) {
+        targetItem->setBeingPointedAt(false);
+    }
+    deleteLater();
+}
+
+void ArrowItem::updatePath()
+{
+    if (!targetItem) {
+        return;
+    }
+
+    QPointF endPoint = targetItem->mapToScene(
+        QPointF(targetItem->boundingRect().width() / 2, targetItem->boundingRect().height() / 2));
+    updatePath(endPoint);
+}
+
+void ArrowItem::updatePath(const QPointF &endPoint)
+{
+    const double arrowWidth = 15.0;
+    const double headWidth = 40.0;
+    const double headLength =
+        headWidth / qPow(2, 0.5); // aka headWidth / sqrt (2) but this produces a compile error with MSVC++
+    const double phi = 15;
+
+    if (!startItem) {
+        return;
+    }
+
+    QPointF startPoint =
+        startItem->mapToScene(QPointF(startItem->boundingRect().width() / 2, startItem->boundingRect().height() / 2));
+    QLineF line(startPoint, endPoint);
+    qreal lineLength = line.length();
+
+    prepareGeometryChange();
+    if (lineLength < 30) {
+        path = QPainterPath();
+    } else {
+        QPointF c(lineLength / 2, qTan(phi * M_PI / 180) * lineLength);
+
+        QPainterPath centerLine;
+        centerLine.moveTo(0, 0);
+        centerLine.quadTo(c, QPointF(lineLength, 0));
+
+        double percentage = 1 - headLength / lineLength;
+        QPointF arrowBodyEndPoint = centerLine.pointAtPercent(percentage);
+        QLineF testLine(arrowBodyEndPoint, centerLine.pointAtPercent(percentage + 0.001));
+        qreal alpha = testLine.angle() - 90;
+        QPointF endPoint1 =
+            arrowBodyEndPoint + arrowWidth / 2 * QPointF(qCos(alpha * M_PI / 180), -qSin(alpha * M_PI / 180));
+        QPointF endPoint2 =
+            arrowBodyEndPoint + arrowWidth / 2 * QPointF(-qCos(alpha * M_PI / 180), qSin(alpha * M_PI / 180));
+        QPointF point1 =
+            endPoint1 + (headWidth - arrowWidth) / 2 * QPointF(qCos(alpha * M_PI / 180), -qSin(alpha * M_PI / 180));
+        QPointF point2 =
+            endPoint2 + (headWidth - arrowWidth) / 2 * QPointF(-qCos(alpha * M_PI / 180), qSin(alpha * M_PI / 180));
+
+        path = QPainterPath(-arrowWidth / 2 * QPointF(qCos((phi - 90) * M_PI / 180), qSin((phi - 90) * M_PI / 180)));
+        path.quadTo(c, endPoint1);
+        path.lineTo(point1);
+        path.lineTo(QPointF(lineLength, 0));
+        path.lineTo(point2);
+        path.lineTo(endPoint2);
+        path.quadTo(c, arrowWidth / 2 * QPointF(qCos((phi - 90) * M_PI / 180), qSin((phi - 90) * M_PI / 180)));
+        path.lineTo(-arrowWidth / 2 * QPointF(qCos((phi - 90) * M_PI / 180), qSin((phi - 90) * M_PI / 180)));
+    }
+
+    setPos(startPoint);
+    setTransform(QTransform().rotate(-line.angle()));
+}
+
+void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
+{
+    QColor paintColor(data->color);
+    if (fullColor) {
+        paintColor.setAlpha(200);
+    } else {
+        paintColor.setAlpha(150);
+    }
+    painter->setBrush(paintColor);
+    painter->drawPath(path);
+}
+
+void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (!data->isLocalCreator) {
+        event->ignore();
+        return;
+    }
+
+    for (auto *item : scene()->items(event->scenePos())) {
+        if (qgraphicsitem_cast<CardItem *>(item)) {
+            event->ignore();
+            return;
+        }
+    }
+
+    event->accept();
+    if (event->button() == Qt::RightButton) {
+        emit requestDeletion(data->creatorId, data->id);
+    }
+}
+
+// ArrowDragItem
+
+ArrowDragItem::ArrowDragItem(PlayerLogic *_owner, ArrowTarget *_startItem, const QColor &_color, int _deleteInPhase)
+    : ArrowItem(QSharedPointer<ArrowData>::create(ArrowData{.creatorId = _owner->getPlayerInfo()->getId(),
+                                                            .isLocalCreator = true,
+                                                            .id = -1,
+                                                            .color = _color}),
+                _startItem,
+                nullptr),
+      player(_owner), deleteInPhase(_deleteInPhase)
+{
+}
+
+void ArrowDragItem::addChildArrow(ArrowDragItem *child)
+{
+    childArrows.append(child);
+}
+
+void ArrowDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (targetLocked || !startItem) {
+        return;
+    }
+
+    const QPointF endPos = event->scenePos();
+
+    ArrowTarget *cursorItem = nullptr;
+    qreal cursorItemZ = -1;
+    for (auto *item : scene()->items(endPos)) {
+        ArrowTarget *candidate = nullptr;
+        if (auto *card = qgraphicsitem_cast<CardItem *>(item)) {
+            candidate = card;
+        } else if (auto *pt = qgraphicsitem_cast<PlayerTarget *>(item)) {
+            candidate = pt;
+        }
+
+        if (candidate && candidate->zValue() > cursorItemZ) {
+            cursorItem = candidate;
+            cursorItemZ = candidate->zValue();
+        }
+    }
+
+    if (cursorItem != targetItem) {
+        if (targetItem) {
+            disconnect(positionConnection);
+            targetItem->setBeingPointedAt(false);
+        }
+
+        targetItem = cursorItem;
+        fullColor = (cursorItem != nullptr);
+
+        if (cursorItem && cursorItem != startItem) {
+            cursorItem->setBeingPointedAt(true);
+            positionConnection =
+                connect(cursorItem, &ArrowTarget::scenePositionChanged, this, [this]() { updatePath(); });
+        }
+    }
+
+    targetItem ? updatePath() : updatePath(endPos);
+    update();
+
+    for (auto *child : childArrows) {
+        child->mouseMoveEvent(event);
+    }
+}
+
+void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (!startItem) {
+        return;
+    }
+
+    if (targetItem && targetItem != startItem) {
+        CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem);
+        // For now, we can safely assume that the start item is always a card.
+        // The target item can be a player as well.
+        if (!startCard) {
+            delArrow();
+            return;
+        }
+
+        CardZoneLogic *startZone = startCard->getZone();
+
+        Command_CreateArrow cmd;
+        cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(data->color));
+        cmd.set_start_player_id(startZone->getPlayer()->getPlayerInfo()->getId());
+        cmd.set_start_zone(startZone->getName().toStdString());
+        cmd.set_start_card_id(startCard->getId());
+
+        if (auto *targetCard = qgraphicsitem_cast<CardItem *>(targetItem)) {
+            CardZoneLogic *targetZone = targetCard->getZone();
+            cmd.set_target_player_id(targetZone->getPlayer()->getPlayerInfo()->getId());
+            cmd.set_target_zone(targetZone->getName().toStdString());
+            cmd.set_target_card_id(targetCard->getId());
+        } else if (auto *targetPlayer = qgraphicsitem_cast<PlayerTarget *>(targetItem)) {
+            cmd.set_target_player_id(targetPlayer->getOwner()->getPlayerInfo()->getId());
+        } else {
+            delArrow();
+            return;
+        }
+
+        // if the card is in hand then we will move the card to stack or table as part of drawing the arrow
+        if (startZone->getName() == ZoneNames::HAND) {
+            startCard->playCard(false);
+            CardInfoPtr ci = startCard->getCard().getCardPtr();
+            bool playToStack = SettingsCache::instance().getPlayToStack();
+            if (ci && ((!playToStack && ci->getUiAttributes().tableRow == 3) ||
+                       (playToStack && ci->getUiAttributes().tableRow != 0 &&
+                        startCard->getZone()->getName() != ZoneNames::STACK))) {
+                cmd.set_start_zone(ZoneNames::STACK);
+            } else {
+                cmd.set_start_zone(playToStack ? ZoneNames::STACK : ZoneNames::TABLE);
+            }
+        }
+
+        if (deleteInPhase != 0) {
+            cmd.set_delete_in_phase(deleteInPhase);
+        }
+
+        player->getPlayerActions()->sendGameCommand(cmd);
+    }
+
+    delArrow();
+    for (auto *child : childArrows) {
+        child->mouseReleaseEvent(event);
+    }
+}
+
+// ArrowAttachItem
+ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem)
+    : ArrowItem(
+          QSharedPointer<ArrowData>::create(ArrowData{.creatorId = _startItem->getOwner()->getPlayerInfo()->getId(),
+                                                      .isLocalCreator = true,
+                                                      .id = -1,
+                                                      .color = Qt::green}),
+          _startItem,
+          nullptr),
+      player(_startItem->getOwner())
+{
+}
+
+void ArrowAttachItem::addChildArrow(ArrowAttachItem *child)
+{
+    childArrows.append(child);
+}
+
+void ArrowAttachItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (targetLocked || !startItem) {
+        return;
+    }
+
+    const QPointF endPos = event->scenePos();
+
+    ArrowTarget *cursorItem = nullptr;
+    qreal cursorItemZ = -1;
+    for (auto *item : scene()->items(endPos)) {
+        if (auto *card = qgraphicsitem_cast<CardItem *>(item)) {
+            if (card->zValue() > cursorItemZ) {
+                cursorItem = card;
+                cursorItemZ = card->zValue();
+            }
+        }
+    }
+
+    if (cursorItem != targetItem) {
+        if (targetItem) {
+            disconnect(positionConnection);
+            targetItem->setBeingPointedAt(false);
+        }
+
+        targetItem = cursorItem;
+        fullColor = (cursorItem != nullptr);
+
+        if (cursorItem && cursorItem != startItem) {
+            cursorItem->setBeingPointedAt(true);
+            positionConnection =
+                connect(cursorItem, &ArrowTarget::scenePositionChanged, this, [this]() { updatePath(); });
+        }
+    }
+
+    targetItem ? updatePath() : updatePath(endPos);
+    update();
+
+    for (auto *child : childArrows) {
+        child->mouseMoveEvent(event);
+    }
+}
+
+void ArrowAttachItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (!startItem) {
+        return;
+    }
+
+    // Attaching could move startItem under the current cursor position, causing all children to retarget to it right
+    // before they are processed. Prevent that.
+    for (auto *child : childArrows) {
+        child->setTargetLocked(true);
+    }
+
+    if (targetItem && targetItem != startItem) {
+        auto *startCard = qgraphicsitem_cast<CardItem *>(startItem);
+        auto *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
+        if (startCard && targetCard) {
+            attachCards(startCard, targetCard);
+        }
+    }
+
+    delArrow();
+    for (auto *child : childArrows) {
+        child->mouseReleaseEvent(event);
+    }
+}
+
+void ArrowAttachItem::attachCards(CardItem *startCard, const CardItem *targetCard)
+{
+    if (targetCard->getAttachedTo() || targetCard->getZone()->getName() != ZoneNames::TABLE) {
+        return;
+    }
+
+    // move card onto table first if attaching from some other zone
+    if (startCard->getZone()->getName() != ZoneNames::TABLE) {
+        player->getPlayerActions()->playCardToTable(startCard, false);
+    }
+
+    Command_AttachCard cmd;
+    cmd.set_start_zone(ZoneNames::TABLE);
+    cmd.set_card_id(startCard->getId());
+    cmd.set_target_player_id(targetCard->getZone()->getPlayer()->getPlayerInfo()->getId());
+    cmd.set_target_zone(targetCard->getZone()->getName().toStdString());
+    cmd.set_target_card_id(targetCard->getId());
+    player->getPlayerActions()->sendGameCommand(cmd);
+}

C++/cockatrice/src/game_graphics/board/arrow_item.h

@@ -0,0 +1,109 @@
+#ifndef ARROWITEM_H
+#define ARROWITEM_H
+
+#include "../../game/board/arrow_data.h"
+#include "arrow_target.h"
+
+#include <QGraphicsItem>
+#include <QPointer>
+#include <QSharedPointer>
+
+class CardItem;
+class QGraphicsSceneMouseEvent;
+class PlayerLogic;
+
+class ArrowItem : public QObject, public QGraphicsItem
+{
+    Q_OBJECT
+    Q_INTERFACES(QGraphicsItem)
+signals:
+    void requestDeletion(int creatorId, int id);
+
+private:
+    QPainterPath path;
+
+protected:
+    QSharedPointer<const ArrowData> data;
+    QPointer<ArrowTarget> startItem;
+    QPointer<ArrowTarget> targetItem;
+    bool targetLocked = false;
+    bool fullColor = true;
+
+    void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
+
+public:
+    ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startItem, ArrowTarget *_targetItem);
+
+    void onTargetDestroyed();
+    void delArrow();
+    void updatePath();
+    void updatePath(const QPointF &endPoint);
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    [[nodiscard]] QRectF boundingRect() const override
+    {
+        return path.boundingRect();
+    }
+    [[nodiscard]] QPainterPath shape() const override
+    {
+        return path;
+    }
+    [[nodiscard]] int getId() const
+    {
+        return data->id;
+    }
+    [[nodiscard]] int getCreatorId() const
+    {
+        return data->creatorId;
+    }
+    [[nodiscard]] ArrowTarget *getStartItem() const
+    {
+        return startItem;
+    }
+    [[nodiscard]] ArrowTarget *getTargetItem() const
+    {
+        return targetItem;
+    }
+    void setTargetLocked(bool _targetLocked)
+    {
+        targetLocked = _targetLocked;
+    }
+};
+
+class ArrowDragItem : public ArrowItem
+{
+    Q_OBJECT
+private:
+    PlayerLogic *player;
+    int deleteInPhase;
+    QList<ArrowDragItem *> childArrows;
+    QMetaObject::Connection positionConnection;
+
+public:
+    ArrowDragItem(PlayerLogic *_owner, ArrowTarget *_startItem, const QColor &_color, int _deleteInPhase);
+    void addChildArrow(ArrowDragItem *child);
+
+protected:
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
+};
+
+class ArrowAttachItem : public ArrowItem
+{
+    Q_OBJECT
+private:
+    PlayerLogic *player;
+    QList<ArrowAttachItem *> childArrows;
+    QMetaObject::Connection positionConnection;
+    void attachCards(CardItem *startCard, const CardItem *targetCard);
+
+public:
+    explicit ArrowAttachItem(ArrowTarget *_startItem);
+    void addChildArrow(ArrowAttachItem *child);
+
+protected:
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
+};
+
+#endif

C++/cockatrice/src/game_graphics/board/arrow_target.cpp

@@ -0,0 +1,23 @@
+#include "arrow_target.h"
+
+#include "../../game/player/player_logic.h"
+#include "arrow_item.h"
+
+ArrowTarget::ArrowTarget(PlayerLogic *_owner, QGraphicsItem *parent) : AbstractGraphicsItem(parent), owner(_owner)
+{
+    setFlag(ItemSendsScenePositionChanges);
+}
+
+void ArrowTarget::setBeingPointedAt(bool _beingPointedAt)
+{
+    beingPointedAt = _beingPointedAt;
+    update();
+}
+
+QVariant ArrowTarget::itemChange(GraphicsItemChange change, const QVariant &value)
+{
+    if (change == ItemScenePositionHasChanged) {
+        emit scenePositionChanged();
+    }
+    return AbstractGraphicsItem::itemChange(change, value);
+}

C++/cockatrice/src/game_graphics/board/arrow_target.h

@@ -0,0 +1,47 @@
+/**
+ * @file arrow_target.h
+ * @ingroup GameGraphics
+ */
+//! \todo Document this file.
+
+#ifndef ARROWTARGET_H
+#define ARROWTARGET_H
+
+#include "abstract_graphics_item.h"
+
+#include <QList>
+
+class PlayerLogic;
+class ArrowItem;
+
+class ArrowTarget : public AbstractGraphicsItem
+{
+    Q_OBJECT
+protected:
+    PlayerLogic *owner;
+
+private:
+    bool beingPointedAt = false;
+
+signals:
+    void scenePositionChanged();
+
+public:
+    explicit ArrowTarget(PlayerLogic *_owner, QGraphicsItem *parent = nullptr);
+    ~ArrowTarget() override = default;
+
+    [[nodiscard]] PlayerLogic *getOwner() const
+    {
+        return owner;
+    }
+
+    void setBeingPointedAt(bool _beingPointedAt);
+    [[nodiscard]] bool getBeingPointedAt() const
+    {
+        return beingPointedAt;
+    }
+
+protected:
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
+};
+#endif

C++/cockatrice/src/game_graphics/board/card_drag_item.cpp

@@ -0,0 +1,144 @@
+#include "card_drag_item.h"
+
+#include "../game_scene.h"
+#include "../zones/card_zone.h"
+#include "../zones/table_zone.h"
+#include "../zones/view_zone.h"
+#include "card_item.h"
+
+#include <QCursor>
+#include <QGraphicsSceneMouseEvent>
+#include <QPainter>
+
+CardDragItem::CardDragItem(CardItem *_item,
+                           int _id,
+                           const QPointF &_hotSpot,
+                           bool _forceFaceDown,
+                           AbstractCardDragItem *parentDrag)
+    : AbstractCardDragItem(_item, _hotSpot, parentDrag), id(_id), forceFaceDown(_forceFaceDown), occupied(false),
+      currentZone(0)
+{
+}
+
+void CardDragItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+    AbstractCardDragItem::paint(painter, option, widget);
+
+    if (occupied) {
+        painter->fillPath(shape(), QColor(200, 0, 0, 100));
+    }
+}
+
+void CardDragItem::updatePosition(const QPointF &cursorScenePos)
+{
+    QList<QGraphicsItem *> colliding =
+        scene()->items(cursorScenePos, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder,
+                       static_cast<GameScene *>(scene())->getViewTransform());
+
+    CardZone *cardZone = 0;
+    ZoneViewZone *zoneViewZone = 0;
+    for (int i = colliding.size() - 1; i >= 0; i--) {
+        CardZone *temp = qgraphicsitem_cast<CardZone *>(colliding.at(i));
+        if (!cardZone) {
+            cardZone = temp;
+        }
+        if (!zoneViewZone) {
+            zoneViewZone = qobject_cast<ZoneViewZone *>(temp);
+        }
+    }
+    CardZone *cursorZone = 0;
+    if (zoneViewZone) {
+        cursorZone = zoneViewZone;
+    } else if (cardZone) {
+        cursorZone = cardZone;
+    }
+
+    // Always update the current zone, even if its null, to cancel the drag
+    // instead of dropping cards into an non-intuitive location.
+    currentZone = cursorZone;
+
+    if (!cursorZone) {
+        // Avoid the cards getting stuck visually when not over
+        // any zone.
+        QPointF newPos = cursorScenePos - hotSpot;
+
+        if (newPos != pos()) {
+            for (int i = 0; i < childDrags.size(); i++) {
+                childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot());
+            }
+            setPos(newPos);
+        }
+
+        return;
+    }
+
+    QPointF zonePos = currentZone->scenePos();
+    QPointF cursorPosInZone = cursorScenePos - zonePos;
+
+    // If we are on a Table, we center the card around the cursor, because we
+    // snap it into place and no longer see it being dragged.
+    //
+    // For other zones (where we do display the card under the cursor), we use
+    // the hotspot to feel like the card was dragged at the corresponding
+    // position.
+    TableZone *tableZone = qobject_cast<TableZone *>(cursorZone);
+    QPointF closestGridPoint;
+    if (tableZone) {
+        closestGridPoint = tableZone->closestGridPoint(cursorPosInZone);
+    } else {
+        closestGridPoint = cursorPosInZone - hotSpot;
+    }
+
+    QPointF newPos = zonePos + closestGridPoint;
+
+    if (newPos != pos()) {
+        for (int i = 0; i < childDrags.size(); i++) {
+            childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot());
+        }
+        setPos(newPos);
+
+        bool newOccupied = false;
+        TableZone *table = qobject_cast<TableZone *>(cursorZone);
+        if (table) {
+            if (table->getCardFromCoords(closestGridPoint)) {
+                newOccupied = true;
+            }
+        }
+        if (newOccupied != occupied) {
+            occupied = newOccupied;
+            update();
+        }
+    }
+}
+
+void CardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    setCursor(Qt::OpenHandCursor);
+    QGraphicsScene *sc = scene();
+    QPointF sp = pos();
+    sc->removeItem(this);
+
+    QList<CardDragItem *> dragItemList;
+    CardZoneLogic *startZone = static_cast<CardItem *>(item)->getZone();
+    if (currentZone && !(static_cast<CardItem *>(item)->getAttachedTo() && (startZone == currentZone->getLogic()))) {
+        if (!occupied) {
+            dragItemList.append(this);
+        }
+
+        for (int i = 0; i < childDrags.size(); i++) {
+            CardDragItem *c = static_cast<CardDragItem *>(childDrags[i]);
+            if (!occupied &&
+                !(static_cast<CardItem *>(c->item)->getAttachedTo() && (startZone == currentZone->getLogic())) &&
+                !c->occupied) {
+                dragItemList.append(c);
+            }
+            sc->removeItem(c);
+        }
+    }
+
+    if (currentZone) {
+        currentZone->handleDropEvent(dragItemList, startZone, (sp - currentZone->scenePos()).toPoint());
+    }
+
+    event->accept();
+}

C++/cockatrice/src/game_graphics/board/card_drag_item.h

@@ -0,0 +1,44 @@
+/**
+ * @file card_drag_item.h
+ * @ingroup GameGraphicsCards
+ */
+//! \todo Document this file.
+
+#ifndef CARDDRAGITEM_H
+#define CARDDRAGITEM_H
+
+#include "abstract_card_drag_item.h"
+
+class CardItem;
+
+class CardDragItem : public AbstractCardDragItem
+{
+    Q_OBJECT
+private:
+    int id;
+    bool forceFaceDown;
+    bool occupied;
+    CardZone *currentZone;
+
+public:
+    CardDragItem(CardItem *_item,
+                 int _id,
+                 const QPointF &_hotSpot,
+                 bool _forceFaceDown,
+                 AbstractCardDragItem *parentDrag = 0);
+    int getId() const
+    {
+        return id;
+    }
+    bool isForceFaceDown() const
+    {
+        return forceFaceDown;
+    }
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    void updatePosition(const QPointF &cursorScenePos) override;
+
+protected:
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
+};
+
+#endif

C++/cockatrice/src/game_graphics/board/card_item.cpp

@@ -0,0 +1,541 @@
+#include "card_item.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../game/phase.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../../game/zones/view_zone_logic.h"
+#include "../../interface/widgets/tabs/tab_game.h"
+#include "../game_scene.h"
+#include "../zones/table_zone.h"
+#include "../zones/view_zone.h"
+#include "arrow_item.h"
+#include "card_drag_item.h"
+
+#include <../../client/settings/card_counter_settings.h>
+#include <QApplication>
+#include <QGraphicsSceneMouseEvent>
+#include <QMenu>
+#include <QPainter>
+#include <libcockatrice/card/card_info.h>
+#include <libcockatrice/protocol/pb/serverinfo_card.pb.h>
+
+CardItem::CardItem(PlayerLogic *_owner,
+                   QGraphicsItem *parent,
+                   const CardRef &cardRef,
+                   int _cardid,
+                   CardZoneLogic *_zone)
+    : AbstractCardItem(parent, cardRef, _owner, _cardid), state(new CardState(this, _zone)), dragItem(nullptr)
+{
+    owner->addCard(this);
+
+    connect(&SettingsCache::instance().cardCounters(), &CardCounterSettings::colorChanged, this, [this](int counterId) {
+        if (state->getCounters().contains(counterId)) {
+            update();
+        }
+    });
+}
+
+void CardItem::prepareDelete()
+{
+    if (owner != nullptr) {
+        if (owner->getGame()->getActiveCard() == this) {
+            emit owner->requestCardMenuUpdate(nullptr);
+            owner->getGame()->setActiveCard(nullptr);
+        }
+        owner = nullptr;
+    }
+
+    while (!attachedCards.isEmpty()) {
+        attachedCards.first()->setZone(nullptr); // so that it won't try to call reorganizeCards()
+        attachedCards.first()->setAttachedTo(nullptr);
+    }
+
+    if (state->getAttachedTo() != nullptr) {
+        state->getAttachedTo()->removeAttachedCard(this);
+        state->setAttachedTo(nullptr);
+    }
+}
+
+void CardItem::deleteLater()
+{
+    prepareDelete();
+    if (scene()) {
+        static_cast<GameScene *>(scene())->unregisterAnimationItem(this);
+    }
+    AbstractCardItem::deleteLater();
+}
+
+void CardItem::setZone(CardZoneLogic *_zone)
+{
+    state->setZone(_zone);
+}
+
+void CardItem::retranslateUi()
+{
+}
+
+void CardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+    auto &cardCounterSettings = SettingsCache::instance().cardCounters();
+
+    painter->save();
+    AbstractCardItem::paint(painter, option, widget);
+
+    int i = 0;
+    QMapIterator<int, int> counterIterator(state->getCounters());
+    while (counterIterator.hasNext()) {
+        counterIterator.next();
+        QColor _color = cardCounterSettings.color(counterIterator.key());
+
+        paintNumberEllipse(counterIterator.value(), 14, _color, i, state->getCounters().size(), painter);
+        ++i;
+    }
+
+    QSizeF translatedSize = getTranslatedSize(painter);
+    qreal scaleFactor = translatedSize.width() / boundingRect().width();
+
+    if (!state->getPT().isEmpty()) {
+        painter->save();
+        transformPainter(painter, translatedSize, tapAngle);
+
+        if (!getFaceDown() && state->getPT() == exactCard.getInfo().getPowTough()) {
+            painter->setPen(Qt::white);
+        } else {
+            painter->setPen(QColor(255, 150, 0)); // dark orange
+        }
+
+        painter->setBackground(Qt::black);
+        painter->setBackgroundMode(Qt::OpaqueMode);
+
+        painter->drawText(QRectF(4 * scaleFactor, 4 * scaleFactor, translatedSize.width() - 10 * scaleFactor,
+                                 translatedSize.height() - 8 * scaleFactor),
+                          Qt::AlignRight | Qt::AlignBottom, state->getPT());
+        painter->restore();
+    }
+
+    if (!state->getAnnotation().isEmpty()) {
+        painter->save();
+
+        transformPainter(painter, translatedSize, tapAngle);
+        painter->setBackground(Qt::black);
+        painter->setBackgroundMode(Qt::OpaqueMode);
+        painter->setPen(Qt::white);
+
+        painter->drawText(QRectF(4 * scaleFactor, 4 * scaleFactor, translatedSize.width() - 8 * scaleFactor,
+                                 translatedSize.height() - 8 * scaleFactor),
+                          Qt::AlignCenter | Qt::TextWrapAnywhere, state->getAnnotation());
+        painter->restore();
+    }
+
+    if (getBeingPointedAt()) {
+        painter->fillPath(shape(), QBrush(QColor(255, 0, 0, 100)));
+    }
+
+    if (state->getDoesntUntap()) {
+        painter->save();
+
+        painter->setRenderHint(QPainter::Antialiasing, false);
+
+        QPen pen;
+        pen.setColor(Qt::magenta);
+        pen.setWidth(0); // Cosmetic pen
+        painter->setPen(pen);
+        painter->drawPath(shape());
+
+        painter->restore();
+    }
+
+    painter->restore();
+}
+
+void CardItem::setAttacking(bool _attacking)
+{
+    state->setAttacking(_attacking);
+    update();
+}
+
+void CardItem::setCounter(int _id, int _value)
+{
+    state->setCounter(_id, _value);
+    update();
+}
+
+void CardItem::setAnnotation(const QString &_annotation)
+{
+    state->setAnnotation(_annotation);
+    update();
+}
+
+void CardItem::setDoesntUntap(bool _doesntUntap)
+{
+    state->setDoesntUntap(_doesntUntap);
+    update();
+}
+
+void CardItem::setPT(const QString &_pt)
+{
+    state->setPT(_pt);
+    update();
+}
+
+void CardItem::setAttachedTo(CardItem *_attachedTo)
+{
+    if (state->getAttachedTo() != nullptr) {
+        state->getAttachedTo()->removeAttachedCard(this);
+    }
+
+    gridPoint.setX(-1);
+    state->setAttachedTo(_attachedTo);
+    if (state->getAttachedTo() != nullptr) {
+        // If the zone is being torn down, it might already be null by the time a card tries to un-attach all its
+        // attached cards
+        if (state->getAttachedTo()->getZone() == nullptr) {
+            deleteLater();
+        } else {
+            emit state->getAttachedTo()->getZone()->cardAdded(this);
+            state->getAttachedTo()->addAttachedCard(this);
+            if (state->getZone() != state->getAttachedTo()->getZone()) {
+                state->getAttachedTo()->getZone()->reorganizeCards();
+            }
+        }
+    } else {
+        // If the zone is being torn down, it might already be null by the time a card tries to un-attach all its
+        // attached cards
+        if (state->getZone() == nullptr) {
+            deleteLater();
+        } else {
+            emit state->getZone()->cardAdded(this);
+        }
+    }
+
+    if (state->getZone() != nullptr) {
+        state->getZone()->reorganizeCards();
+    }
+}
+
+/**
+ * @brief Resets the fields that should be reset after a zone transition
+ */
+void CardItem::resetState(bool keepAnnotations)
+{
+    state->resetState(keepAnnotations);
+    attachedCards.clear();
+    setTapped(false, false);
+    setDoesntUntap(false);
+    if (scene()) {
+        static_cast<GameScene *>(scene())->unregisterAnimationItem(this);
+    }
+    update();
+}
+
+void CardItem::processCardInfo(const ServerInfo_Card &_info)
+{
+    state->clearCounters();
+    const int counterListSize = _info.counter_list_size();
+    for (int i = 0; i < counterListSize; ++i) {
+        const ServerInfo_CardCounter &counterInfo = _info.counter_list(i);
+        state->insertCounter(counterInfo.id(), counterInfo.value());
+    }
+
+    setId(_info.id());
+    setCardRef({QString::fromStdString(_info.name()), QString::fromStdString(_info.provider_id())});
+    setAttacking(_info.attacking());
+    setFaceDown(_info.face_down());
+    setPT(QString::fromStdString(_info.pt()));
+    setAnnotation(QString::fromStdString(_info.annotation()));
+    setColor(QString::fromStdString(_info.color()));
+    setTapped(_info.tapped());
+    setDestroyOnZoneChange(_info.destroy_on_zone_change());
+    setDoesntUntap(_info.doesnt_untap());
+}
+
+CardDragItem *CardItem::createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool forceFaceDown)
+{
+    deleteDragItem();
+    dragItem = new CardDragItem(this, _id, _pos, forceFaceDown);
+    dragItem->setVisible(false);
+    scene()->addItem(dragItem);
+    dragItem->updatePosition(_scenePos);
+    dragItem->setVisible(true);
+
+    return dragItem;
+}
+
+void CardItem::deleteDragItem()
+{
+    if (dragItem) {
+        dragItem->deleteLater();
+    }
+    dragItem = nullptr;
+}
+
+void CardItem::drawArrow(const QColor &arrowColor)
+{
+    if (owner->getGame()->getPlayerManager()->isSpectator()) {
+        return;
+    }
+
+    auto *game = owner->getGame();
+    PlayerLogic *arrowOwner = game->getPlayerManager()->getActiveLocalPlayer(game->getGameState()->getActivePlayer());
+    int phase = 0; // 0 means to not set the phase
+    if (SettingsCache::instance().getDoNotDeleteArrowsInSubPhases()) {
+        int currentPhase = game->getGameState()->getCurrentPhase();
+        phase = Phases::getLastSubphase(currentPhase) + 1;
+    }
+    ArrowDragItem *arrow = new ArrowDragItem(arrowOwner, this, arrowColor, phase);
+    scene()->addItem(arrow);
+    arrow->grabMouse();
+
+    for (const auto &item : scene()->selectedItems()) {
+        CardItem *card = qgraphicsitem_cast<CardItem *>(item);
+        if (card == nullptr || card == this) {
+            continue;
+        }
+        if (card->getZone() != state->getZone()) {
+            continue;
+        }
+
+        ArrowDragItem *childArrow = new ArrowDragItem(arrowOwner, card, arrowColor, phase);
+        scene()->addItem(childArrow);
+        arrow->addChildArrow(childArrow);
+    }
+}
+
+void CardItem::drawAttachArrow()
+{
+    if (owner->getGame()->getPlayerManager()->isSpectator()) {
+        return;
+    }
+
+    auto *arrow = new ArrowAttachItem(this);
+    scene()->addItem(arrow);
+    arrow->grabMouse();
+
+    for (const auto &item : scene()->selectedItems()) {
+        CardItem *card = qgraphicsitem_cast<CardItem *>(item);
+        if (card == nullptr) {
+            continue;
+        }
+        if (card->getZone() != state->getZone()) {
+            continue;
+        }
+
+        ArrowAttachItem *childArrow = new ArrowAttachItem(card);
+        scene()->addItem(childArrow);
+        arrow->addChildArrow(childArrow);
+    }
+}
+
+void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->buttons().testFlag(Qt::RightButton)) {
+        if ((event->screenPos() - event->buttonDownScreenPos(Qt::RightButton)).manhattanLength() <
+            2 * QApplication::startDragDistance()) {
+            return;
+        }
+
+        QColor arrowColor = Qt::red;
+        if (event->modifiers().testFlag(Qt::ControlModifier)) {
+            arrowColor = Qt::yellow;
+        } else if (event->modifiers().testFlag(Qt::AltModifier)) {
+            arrowColor = Qt::blue;
+        } else if (event->modifiers().testFlag(Qt::ShiftModifier)) {
+            arrowColor = Qt::green;
+        }
+
+        drawArrow(arrowColor);
+    } else if (event->buttons().testFlag(Qt::LeftButton)) {
+        if ((event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)).manhattanLength() <
+            2 * QApplication::startDragDistance()) {
+            return;
+        }
+        if (const ZoneViewZoneLogic *view = qobject_cast<const ZoneViewZoneLogic *>(state->getZone())) {
+            if (view->getRevealZone() && !view->getWriteableRevealZone()) {
+                return;
+            }
+        } else if (!owner->getPlayerInfo()->getLocalOrJudge()) {
+            return;
+        }
+
+        bool forceFaceDown = event->modifiers().testFlag(Qt::ShiftModifier);
+
+        // Use the buttonDownPos to align the hot spot with the position when
+        // the user originally clicked
+        createDragItem(id, event->buttonDownPos(Qt::LeftButton), event->scenePos(), forceFaceDown);
+        dragItem->grabMouse();
+
+        int childIndex = 0;
+        for (const auto &item : scene()->selectedItems()) {
+            CardItem *card = static_cast<CardItem *>(item);
+            if ((card == this) || (card->getZone() != state->getZone())) {
+                continue;
+            }
+            ++childIndex;
+            QPointF childPos;
+            if (state->getZone()->getHasCardAttr()) {
+                childPos = card->pos() - pos();
+            } else {
+                childPos = QPointF(childIndex * CardDimensions::WIDTH_HALF_F, 0);
+            }
+            CardDragItem *drag =
+                new CardDragItem(card, card->getId(), childPos, card->getFaceDown() || forceFaceDown, dragItem);
+            drag->setPos(dragItem->pos() + childPos);
+            scene()->addItem(drag);
+        }
+    }
+    setCursor(Qt::OpenHandCursor);
+}
+
+void CardItem::playCard(bool faceDown)
+{
+    // Do nothing if the card belongs to another player
+    if (!owner->getPlayerInfo()->getLocalOrJudge()) {
+        return;
+    }
+
+    TableZoneLogic *tz = qobject_cast<TableZoneLogic *>(state->getZone());
+    if (tz) {
+        emit tz->toggleTapped();
+    } else {
+        if (SettingsCache::instance().getClickPlaysAllSelected()) {
+            if (faceDown) {
+                emit playSelectedFaceDown(this);
+            } else {
+                emit playSelected(this);
+            }
+        } else {
+            state->getZone()->getPlayer()->getPlayerActions()->playCard(this, faceDown);
+        }
+    }
+}
+
+QVariantList CardItem::parsePT(const QString &pt)
+{
+    QVariantList ptList = QVariantList();
+    if (!pt.isEmpty()) {
+        int sep = pt.indexOf('/');
+        if (sep == 0) {
+            ptList.append(QVariant(pt.mid(1))); // cut off starting '/' and take full string
+        } else {
+            int start = 0;
+            for (;;) {
+                QString item = pt.mid(start, sep - start);
+                if (item.isEmpty()) {
+                    ptList.append(QVariant(QString()));
+                } else if (item[0] == '+') {
+                    ptList.append(QVariant(item.mid(1).toInt())); // add as int
+                } else if (item[0] == '-') {
+                    ptList.append(QVariant(item.toInt())); // add as int
+                } else {
+                    ptList.append(QVariant(item)); // add as qstring
+                }
+                if (sep == -1) {
+                    break;
+                }
+                start = sep + 1;
+                sep = pt.indexOf('/', start);
+            }
+        }
+    }
+    return ptList;
+}
+
+/**
+ * @brief returns true if the zone is a unwritable reveal zone view (eg a card reveal window). Will return false if zone
+ * is nullptr.
+ */
+static bool isUnwritableRevealZone(CardZoneLogic *zone)
+{
+    if (auto *view = qobject_cast<ZoneViewZoneLogic *>(zone)) {
+        return view->getRevealZone() && !view->getWriteableRevealZone();
+    }
+    return false;
+}
+
+/**
+ * This method is called when a "click to play" is done on the card.
+ * This is either triggered by a single click or double click, depending on the settings.
+ *
+ * @param shiftHeld if the shift key was held during the click
+ */
+void CardItem::handleClickedToPlay(bool shiftHeld)
+{
+    if (isUnwritableRevealZone(state->getZone())) {
+        if (SettingsCache::instance().getClickPlaysAllSelected()) {
+            emit hideSelected(this);
+        } else {
+            state->getZone()->removeCard(this);
+        }
+    } else {
+        playCard(shiftHeld);
+    }
+}
+
+void CardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (event->button() == Qt::RightButton && owner != nullptr) {
+        emit rightClicked(this, event->screenPos());
+        return;
+    }
+    if ((event->modifiers() != Qt::AltModifier) && (event->button() == Qt::LeftButton) &&
+        (!SettingsCache::instance().getDoubleClickToPlay())) {
+        handleClickedToPlay(event->modifiers().testFlag(Qt::ShiftModifier));
+    }
+    if (owner != nullptr) {
+        setCursor(Qt::OpenHandCursor);
+    }
+    AbstractCardItem::mouseReleaseEvent(event);
+}
+
+void CardItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
+{
+    if ((event->modifiers() != Qt::AltModifier) && (event->buttons() == Qt::LeftButton) &&
+        (SettingsCache::instance().getDoubleClickToPlay())) {
+        handleClickedToPlay(event->modifiers().testFlag(Qt::ShiftModifier));
+    }
+    event->accept();
+}
+
+bool CardItem::animationEvent()
+{
+    int rotation = ROTATION_DEGREES_PER_FRAME;
+    bool animationIncomplete = true;
+    if (!tapped) {
+        rotation *= -1;
+    }
+
+    tapAngle += rotation;
+    if (tapped && (tapAngle > 90)) {
+        tapAngle = 90;
+        animationIncomplete = false;
+    }
+    if (!tapped && (tapAngle < 0)) {
+        tapAngle = 0;
+        animationIncomplete = false;
+    }
+
+    setTransform(QTransform()
+                     .translate(CardDimensions::WIDTH_HALF_F, CardDimensions::HEIGHT_HALF_F)
+                     .rotate(tapAngle)
+                     .translate(-CardDimensions::WIDTH_HALF_F, -CardDimensions::HEIGHT_HALF_F));
+    setHovered(false);
+    update();
+
+    return animationIncomplete;
+}
+
+QVariant CardItem::itemChange(GraphicsItemChange change, const QVariant &value)
+{
+    if ((change == ItemSelectedHasChanged) && owner != nullptr) {
+        bool selected = value.toBool();
+
+        if (selected) {
+            owner->getGame()->setActiveCard(this);
+        }
+
+        emit selectionChanged(this, selected);
+    }
+
+    return AbstractCardItem::itemChange(change, value);
+}