[Game] Move graphics out of game and into game_graphics (#6928)

* [Game][Player] Pull out graphics_items out of player_logic Took 25 seconds Took 9 minutes * [Game] Move graphics files into game_graphics Took 1 minute Took 2 minutes Took 23 seconds Took 1 minute Took 2 seconds * Include. Took 4 minutes Took 3 minutes Took 4 minutes Took 1 minute Took 3 minutes --------- Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>
2026-06-30 18:43:55 -07:00 · 2026-06-09 09:51:13 +02:00 · 2026-06-09 09:51:13 +02:00 · da4ba222c0
commit da4ba222c0
parent cbfd286908
116 changed files with 208 additions and 198 deletions
--- a/cockatrice/src/game_graphics/deckview/deck_view.cpp
+++ b/cockatrice/src/game_graphics/deckview/deck_view.cpp
@ -0,0 +1,556 @@
+#include "deck_view.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../interface/theme_manager.h"
+
+#include <QApplication>
+#include <QGraphicsSceneMouseEvent>
+#include <QMouseEvent>
+#include <QtMath>
+#include <algorithm>
+#include <libcockatrice/card/card_info.h>
+#include <libcockatrice/deck_list/deck_list.h>
+#include <libcockatrice/deck_list/tree/deck_list_card_node.h>
+
+DeckViewCardDragItem::DeckViewCardDragItem(DeckViewCard *_item,
+                                           const QPointF &_hotSpot,
+                                           AbstractCardDragItem *parentDrag)
+    : AbstractCardDragItem(_item, _hotSpot, parentDrag), currentZone(0)
+{
+}
+
+void DeckViewCardDragItem::updatePosition(const QPointF &cursorScenePos)
+{
+    QList<QGraphicsItem *> colliding = scene()->items(cursorScenePos);
+
+    DeckViewCardContainer *cursorZone = 0;
+    for (int i = colliding.size() - 1; i >= 0; i--) {
+        if ((cursorZone = qgraphicsitem_cast<DeckViewCardContainer *>(colliding.at(i)))) {
+            break;
+        }
+    }
+    if (!cursorZone) {
+        return;
+    }
+    currentZone = cursorZone;
+
+    QPointF newPos = cursorScenePos;
+    if (newPos != pos()) {
+        for (int i = 0; i < childDrags.size(); i++) {
+            childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot());
+        }
+        setPos(newPos);
+    }
+}
+
+void DeckViewCardDragItem::handleDrop(DeckViewCardContainer *target)
+{
+    auto *card = static_cast<DeckViewCard *>(item);
+    auto *start = static_cast<DeckViewCardContainer *>(item->parentItem());
+    start->removeCard(card);
+    target->addCard(card);
+    card->setParentItem(target);
+}
+
+void DeckViewCardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    setCursor(Qt::OpenHandCursor);
+    auto *sc = static_cast<DeckViewScene *>(scene());
+    sc->removeItem(this);
+
+    if (currentZone) {
+        handleDrop(currentZone);
+        for (int i = 0; i < childDrags.size(); i++) {
+            auto *c = static_cast<DeckViewCardDragItem *>(childDrags[i]);
+            c->handleDrop(currentZone);
+            sc->removeItem(c);
+        }
+
+        sc->updateContents();
+    }
+
+    event->accept();
+}
+
+DeckViewCard::DeckViewCard(QGraphicsItem *parent, const CardRef &cardRef, const QString &_originZone)
+    : AbstractCardItem(parent, cardRef, 0, -1), originZone(_originZone), dragItem(0)
+{
+    setAcceptHoverEvents(true);
+
+    connect(&SettingsCache::instance(), &SettingsCache::roundCardCornersChanged, this, [this](bool _roundCardCorners) {
+        Q_UNUSED(_roundCardCorners);
+
+        update();
+    });
+}
+
+DeckViewCard::~DeckViewCard()
+{
+    delete dragItem;
+}
+
+void DeckViewCard::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+    AbstractCardItem::paint(painter, option, widget);
+
+    painter->save();
+    QPen pen;
+    pen.setWidth(3);
+    pen.setJoinStyle(Qt::MiterJoin);
+    pen.setColor(originZone == DECK_ZONE_MAIN ? Qt::green : Qt::red);
+    painter->setPen(pen);
+    qreal cardRadius = SettingsCache::instance().getRoundCardCorners() ? 0.05 * (CardDimensions::WIDTH_F - 3) : 0.0;
+    painter->drawRoundedRect(QRectF(1.5, 1.5, CardDimensions::WIDTH_F - 3, CardDimensions::HEIGHT_F - 3), cardRadius,
+                             cardRadius);
+    painter->restore();
+}
+
+void DeckViewCard::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if ((event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)).manhattanLength() <
+        2 * QApplication::startDragDistance()) {
+        return;
+    }
+
+    if (static_cast<DeckViewScene *>(scene())->getLocked()) {
+        return;
+    }
+
+    delete dragItem;
+    dragItem = new DeckViewCardDragItem(this, event->pos());
+    scene()->addItem(dragItem);
+    dragItem->updatePosition(event->scenePos());
+    dragItem->grabMouse();
+
+    QList<QGraphicsItem *> sel = scene()->selectedItems();
+    int j = 0;
+    for (int i = 0; i < sel.size(); i++) {
+        auto *c = static_cast<DeckViewCard *>(sel.at(i));
+        if (c == this) {
+            continue;
+        }
+        ++j;
+        auto childPos = QPointF(j * CardDimensions::WIDTH_HALF_F, 0);
+        auto *drag = new DeckViewCardDragItem(c, childPos, dragItem);
+        drag->setPos(dragItem->pos() + childPos);
+        scene()->addItem(drag);
+    }
+    setCursor(Qt::OpenHandCursor);
+}
+
+void DeckView::mouseDoubleClickEvent(QMouseEvent *event)
+{
+    if (static_cast<DeckViewScene *>(scene())->getLocked()) {
+        return;
+    }
+
+    if (event->button() == Qt::LeftButton) {
+        QList<MoveCard_ToZone> result;
+        QList<QGraphicsItem *> sel = scene()->selectedItems();
+
+        for (int i = 0; i < sel.size(); i++) {
+            auto *c = static_cast<DeckViewCard *>(sel.at(i));
+            auto *zone = static_cast<DeckViewCardContainer *>(c->parentItem());
+            MoveCard_ToZone m;
+            m.set_card_name(c->getName().toStdString());
+            m.set_start_zone(zone->getName().toStdString());
+
+            if (zone->getName() == DECK_ZONE_MAIN) {
+                m.set_target_zone(DECK_ZONE_SIDE);
+            } else if (zone->getName() == DECK_ZONE_SIDE) {
+                m.set_target_zone(DECK_ZONE_MAIN);
+            } else { // Trying to move from another zone
+                m.set_target_zone(zone->getName().toStdString());
+            }
+
+            result.append(m);
+        }
+
+        deckViewScene->applySideboardPlan(result);
+        deckViewScene->rearrangeItems();
+        emit deckViewScene->sideboardPlanChanged();
+    }
+}
+
+void DeckViewCard::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
+{
+    event->accept();
+    processHoverEvent();
+}
+
+DeckViewCardContainer::DeckViewCardContainer(const QString &_name) : QGraphicsItem(), name(_name), width(0), height(0)
+{
+    setCacheMode(DeviceCoordinateCache);
+}
+
+QRectF DeckViewCardContainer::boundingRect() const
+{
+    return QRectF(0, 0, width, height);
+}
+
+void DeckViewCardContainer::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
+{
+    qreal totalTextWidth = getCardTypeTextWidth();
+
+    painter->fillRect(boundingRect(), themeManager->getBgBrush(ThemeManager::Table));
+    painter->setPen(QColor(255, 255, 255, 100));
+    painter->drawLine(QPointF(0, separatorY), QPointF(width, separatorY));
+
+    painter->setPen(QColor(Qt::white));
+    QFont f("Serif");
+    f.setStyleHint(QFont::Serif);
+    f.setPixelSize(24);
+    f.setWeight(QFont::Bold);
+    painter->setFont(f);
+    painter->drawText(10, 0, width - 20, separatorY, Qt::AlignLeft | Qt::AlignVCenter | Qt::TextSingleLine,
+                      InnerDecklistNode::visibleNameFromName(name) + QString(": %1").arg(cards.size()));
+
+    f.setPixelSize(16);
+    painter->setFont(f);
+    QList<QString> cardTypeList = cardsByType.uniqueKeys();
+    qreal yUntilNow = separatorY + paddingY;
+    for (int i = 0; i < cardTypeList.size(); ++i) {
+        if (i != 0) {
+            painter->setPen(QColor(255, 255, 255, 100));
+            painter->drawLine(QPointF(0, yUntilNow - paddingY / 2), QPointF(width, yUntilNow - paddingY / 2));
+        }
+        qreal thisRowHeight = CardDimensions::HEIGHT_F * currentRowsAndCols[i].first;
+        QRectF textRect(0, yUntilNow, totalTextWidth, thisRowHeight);
+        yUntilNow += thisRowHeight + paddingY;
+
+        QString displayString = QString("%1\n(%2)").arg(cardTypeList[i]).arg(cardsByType.count(cardTypeList[i]));
+
+        painter->setPen(Qt::white);
+        painter->drawText(textRect, Qt::AlignHCenter | Qt::AlignVCenter, displayString);
+    }
+}
+
+void DeckViewCardContainer::addCard(DeckViewCard *card)
+{
+    cards.append(card);
+    cardsByType.insert(card->getCard().isEmpty() ? "" : card->getCardInfo().getMainCardType(), card);
+}
+
+void DeckViewCardContainer::removeCard(DeckViewCard *card)
+{
+    cards.removeOne(card);
+    cardsByType.remove(card->getCard().isEmpty() ? "" : card->getCardInfo().getMainCardType(), card);
+}
+
+QList<QPair<int, int>> DeckViewCardContainer::getRowsAndCols() const
+{
+    QList<QPair<int, int>> result;
+    QList<QString> cardTypeList = cardsByType.uniqueKeys();
+    for (int i = 0; i < cardTypeList.size(); ++i) {
+        result.append(QPair<int, int>(1, cardsByType.count(cardTypeList[i])));
+    }
+    return result;
+}
+
+int DeckViewCardContainer::getCardTypeTextWidth() const
+{
+    QFont f("Serif");
+    f.setStyleHint(QFont::Serif);
+    f.setPixelSize(16);
+    f.setWeight(QFont::Bold);
+    QFontMetrics fm(f);
+
+    int maxCardTypeWidth = 0;
+    for (const auto &key : cardsByType.keys()) {
+        int cardTypeWidth = fm.size(Qt::TextSingleLine, key).width();
+        maxCardTypeWidth = qMax(maxCardTypeWidth, cardTypeWidth);
+    }
+
+    return maxCardTypeWidth + 15;
+}
+
+QSizeF DeckViewCardContainer::calculateBoundingRect(const QList<QPair<int, int>> &rowsAndCols) const
+{
+    qreal totalHeight = 0;
+    qreal totalWidth = 0;
+
+    // Calculate space needed for cards
+    for (int i = 0; i < rowsAndCols.size(); ++i) {
+        totalHeight += CardDimensions::HEIGHT_F * rowsAndCols[i].first + paddingY;
+        if (CardDimensions::WIDTH_F * rowsAndCols[i].second > totalWidth) {
+            totalWidth = CardDimensions::WIDTH_F * rowsAndCols[i].second;
+        }
+    }
+
+    return QSizeF(getCardTypeTextWidth() + totalWidth, totalHeight + separatorY + paddingY);
+}
+
+bool DeckViewCardContainer::sortCardsByName(DeckViewCard *c1, DeckViewCard *c2)
+{
+    if (c1 && c2) {
+        return c1->getName() < c2->getName();
+    }
+    return false;
+}
+
+void DeckViewCardContainer::rearrangeItems(const QList<QPair<int, int>> &rowsAndCols)
+{
+    currentRowsAndCols = rowsAndCols;
+
+    qreal yUntilNow = separatorY + paddingY;
+    qreal x = (qreal)getCardTypeTextWidth();
+    for (int i = 0; i < rowsAndCols.size(); ++i) {
+        const int tempRows = rowsAndCols[i].first;
+        const int tempCols = rowsAndCols[i].second;
+        QList<QString> cardTypeList = cardsByType.uniqueKeys();
+        QList<DeckViewCard *> row = cardsByType.values(cardTypeList[i]);
+        std::sort(row.begin(), row.end(), DeckViewCardContainer::sortCardsByName);
+        for (int j = 0; j < row.size(); ++j) {
+            DeckViewCard *card = row[j];
+            card->setPos(x + (j % tempCols) * CardDimensions::WIDTH_F,
+                         yUntilNow + (j / tempCols) * CardDimensions::HEIGHT_F);
+        }
+        yUntilNow += tempRows * CardDimensions::HEIGHT_F + paddingY;
+    }
+
+    prepareGeometryChange();
+    QSizeF bRect = calculateBoundingRect(rowsAndCols);
+    width = bRect.width();
+    height = bRect.height();
+}
+
+void DeckViewCardContainer::setWidth(qreal _width)
+{
+    prepareGeometryChange();
+    width = _width;
+    update();
+}
+
+DeckViewScene::DeckViewScene(QObject *parent) : QGraphicsScene(parent), locked(true), deck(0), optimalAspectRatio(1.0)
+{
+}
+
+DeckViewScene::~DeckViewScene()
+{
+    clearContents();
+    delete deck;
+}
+
+void DeckViewScene::clearContents()
+{
+    QMapIterator<QString, DeckViewCardContainer *> i(cardContainers);
+    while (i.hasNext()) {
+        delete i.next().value();
+    }
+    cardContainers.clear();
+}
+
+void DeckViewScene::setDeck(const DeckList &_deck)
+{
+    if (deck) {
+        delete deck;
+    }
+
+    deck = new DeckList(_deck.writeToString_Native());
+    rebuildTree();
+    applySideboardPlan(deck->getCurrentSideboardPlan());
+    rearrangeItems();
+}
+
+void DeckViewScene::rebuildTree()
+{
+    clearContents();
+
+    if (!deck) {
+        return;
+    }
+
+    for (auto *currentZone : deck->getZoneNodes()) {
+        DeckViewCardContainer *container = cardContainers.value(currentZone->getName(), 0);
+        if (!container) {
+            container = new DeckViewCardContainer(currentZone->getName());
+            cardContainers.insert(currentZone->getName(), container);
+            addItem(container);
+        }
+
+        for (int j = 0; j < currentZone->size(); j++) {
+            auto *currentCard = dynamic_cast<DecklistCardNode *>(currentZone->at(j));
+            if (!currentCard) {
+                continue;
+            }
+
+            for (int k = 0; k < currentCard->getNumber(); ++k) {
+                auto *newCard = new DeckViewCard(container, currentCard->toCardRef(), currentZone->getName());
+                container->addCard(newCard);
+                emit newCardAdded(newCard);
+            }
+        }
+    }
+}
+
+void DeckViewScene::applySideboardPlan(const QList<MoveCard_ToZone> &plan)
+{
+    for (int i = 0; i < plan.size(); ++i) {
+        const MoveCard_ToZone &m = plan[i];
+        DeckViewCardContainer *start = cardContainers.value(QString::fromStdString(m.start_zone()));
+        DeckViewCardContainer *target = cardContainers.value(QString::fromStdString(m.target_zone()));
+        if (!start || !target) {
+            continue;
+        }
+
+        DeckViewCard *card = 0;
+        const QList<DeckViewCard *> &cardList = start->getCards();
+        for (int j = 0; j < cardList.size(); ++j) {
+            if (cardList[j]->getName() == QString::fromStdString(m.card_name())) {
+                card = cardList[j];
+                break;
+            }
+        }
+        if (!card) {
+            continue;
+        }
+
+        start->removeCard(card);
+        target->addCard(card);
+        card->setParentItem(target);
+    }
+}
+
+void DeckViewScene::rearrangeItems()
+{
+    const int spacing = CardDimensions::HEIGHT / 3;
+    QList<DeckViewCardContainer *> contList = cardContainers.values();
+
+    // Initialize space requirements
+    QList<QList<QPair<int, int>>> rowsAndColsList;
+    QList<QList<int>> cardCountList;
+    for (int i = 0; i < contList.size(); ++i) {
+        QList<QPair<int, int>> rowsAndCols = contList[i]->getRowsAndCols();
+        rowsAndColsList.append(rowsAndCols);
+
+        cardCountList.append(QList<int>());
+        for (int j = 0; j < rowsAndCols.size(); ++j) {
+            cardCountList[i].append(rowsAndCols[j].second);
+        }
+    }
+
+    qreal totalHeight, totalWidth;
+    for (;;) {
+        // Calculate total size before this iteration
+        totalHeight = -spacing;
+        totalWidth = 0;
+        for (int i = 0; i < contList.size(); ++i) {
+            QSizeF contSize = contList[i]->calculateBoundingRect(rowsAndColsList[i]);
+            totalHeight += contSize.height() + spacing;
+            if (contSize.width() > totalWidth) {
+                totalWidth = contSize.width();
+            }
+        }
+
+        // We're done when the aspect ratio shifts from too high to too low.
+        if (totalWidth / totalHeight <= optimalAspectRatio) {
+            break;
+        }
+
+        // Find category with highest column count
+        int maxIndex1 = -1, maxIndex2 = -1, maxCols = 0;
+        for (int i = 0; i < rowsAndColsList.size(); ++i) {
+            for (int j = 0; j < rowsAndColsList[i].size(); ++j) {
+                if (rowsAndColsList[i][j].second > maxCols) {
+                    maxIndex1 = i;
+                    maxIndex2 = j;
+                    maxCols = rowsAndColsList[i][j].second;
+                }
+            }
+        }
+
+        // Add row to category
+        const int maxRows = rowsAndColsList[maxIndex1][maxIndex2].first;
+        const int maxCardCount = cardCountList[maxIndex1][maxIndex2];
+        rowsAndColsList[maxIndex1][maxIndex2] =
+            QPair<int, int>(maxRows + 1, (int)qCeil((qreal)maxCardCount / (qreal)(maxRows + 1)));
+    }
+
+    totalHeight = -spacing;
+    for (int i = 0; i < contList.size(); ++i) {
+        DeckViewCardContainer *c = contList[i];
+        c->rearrangeItems(rowsAndColsList[i]);
+        c->setPos(0, totalHeight + spacing);
+        totalHeight += c->boundingRect().height() + spacing;
+    }
+
+    totalWidth = totalHeight * optimalAspectRatio;
+    for (int i = 0; i < contList.size(); ++i) {
+        contList[i]->setWidth(totalWidth);
+    }
+
+    setSceneRect(QRectF(0, 0, totalWidth, totalHeight));
+}
+
+void DeckViewScene::updateContents()
+{
+    rearrangeItems();
+    emit sideboardPlanChanged();
+}
+
+QList<MoveCard_ToZone> DeckViewScene::getSideboardPlan() const
+{
+    QList<MoveCard_ToZone> result;
+    QMapIterator<QString, DeckViewCardContainer *> containerIterator(cardContainers);
+    while (containerIterator.hasNext()) {
+        DeckViewCardContainer *cont = containerIterator.next().value();
+        const QList<DeckViewCard *> cardList = cont->getCards();
+        for (int i = 0; i < cardList.size(); ++i) {
+            if (cardList[i]->getOriginZone() != cont->getName()) {
+                MoveCard_ToZone m;
+                m.set_card_name(cardList[i]->getName().toStdString());
+                m.set_start_zone(cardList[i]->getOriginZone().toStdString());
+                m.set_target_zone(cont->getName().toStdString());
+                result.append(m);
+            }
+        }
+    }
+    return result;
+}
+
+void DeckViewScene::resetSideboardPlan()
+{
+    rebuildTree();
+    rearrangeItems();
+}
+
+DeckView::DeckView(QWidget *parent) : QGraphicsView(parent)
+{
+    deckViewScene = new DeckViewScene(this);
+
+    setBackgroundBrush(QBrush(QColor(0, 0, 0)));
+    setDragMode(RubberBandDrag);
+    setRenderHints(QPainter::TextAntialiasing | QPainter::Antialiasing /* | QPainter::SmoothPixmapTransform*/);
+    setScene(deckViewScene);
+
+    connect(deckViewScene, &DeckViewScene::sceneRectChanged, this, &DeckView::updateSceneRect);
+    connect(deckViewScene, &DeckViewScene::newCardAdded, this, &DeckView::newCardAdded);
+    connect(deckViewScene, &DeckViewScene::sideboardPlanChanged, this, &DeckView::sideboardPlanChanged);
+}
+
+void DeckView::resizeEvent(QResizeEvent *event)
+{
+    QGraphicsView::resizeEvent(event);
+    deckViewScene->setOptimalAspectRatio((qreal)width() / (qreal)height());
+    deckViewScene->rearrangeItems();
+}
+
+void DeckView::updateSceneRect(const QRectF &rect)
+{
+    fitInView(rect, Qt::KeepAspectRatio);
+}
+
+void DeckView::setDeck(const DeckList &_deck)
+{
+    deckViewScene->setDeck(_deck);
+}
+
+void DeckView::clearDeck()
+{
+    deckViewScene->clearContents();
+}
+
+void DeckView::resetSideboardPlan()
+{
+    deckViewScene->resetSideboardPlan();
+}
--- a/cockatrice/src/game_graphics/deckview/deck_view.h
+++ b/cockatrice/src/game_graphics/deckview/deck_view.h
@ -0,0 +1,170 @@
+/**
+ * @file deck_view.h
+ * @ingroup Lobby
+ */
+//! \todo Document this file.
+
+#ifndef DECKVIEW_H
+#define DECKVIEW_H
+
+#include "../board/abstract_card_drag_item.h"
+
+#include <QGraphicsView>
+#include <QMap>
+#include <libcockatrice/protocol/pb/move_card_to_zone.pb.h>
+
+class DeckList;
+class InnerDecklistNode;
+class CardInfo;
+class DeckViewCardContainer;
+class DeckViewCardDragItem;
+class MoveCardToZone;
+
+class DeckViewCard : public AbstractCardItem
+{
+private:
+    QString originZone;
+    DeckViewCardDragItem *dragItem;
+
+public:
+    explicit DeckViewCard(QGraphicsItem *parent = nullptr,
+                          const CardRef &cardRef = {},
+                          const QString &_originZone = QString());
+    ~DeckViewCard() override;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    [[nodiscard]] const QString &getOriginZone() const
+    {
+        return originZone;
+    }
+
+protected:
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override;
+};
+
+class DeckViewCardDragItem : public AbstractCardDragItem
+{
+private:
+    DeckViewCardContainer *currentZone;
+    void handleDrop(DeckViewCardContainer *target);
+
+public:
+    DeckViewCardDragItem(DeckViewCard *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag = 0);
+    void updatePosition(const QPointF &cursorScenePos) override;
+
+protected:
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
+};
+
+class DeckViewCardContainer : public QGraphicsItem
+{
+private:
+    static const int separatorY = 20;
+    static const int paddingY = 10;
+    static bool sortCardsByName(DeckViewCard *c1, DeckViewCard *c2);
+
+    QString name;
+    QList<DeckViewCard *> cards;
+    QMultiMap<QString, DeckViewCard *> cardsByType;
+    QList<QPair<int, int>> currentRowsAndCols;
+    qreal width, height;
+    [[nodiscard]] int getCardTypeTextWidth() const;
+
+public:
+    enum
+    {
+        Type = typeDeckViewCardContainer
+    };
+    [[nodiscard]] int type() const override
+    {
+        return Type;
+    }
+    explicit DeckViewCardContainer(const QString &_name);
+    [[nodiscard]] QRectF boundingRect() const override;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+    void addCard(DeckViewCard *card);
+    void removeCard(DeckViewCard *card);
+    [[nodiscard]] const QList<DeckViewCard *> &getCards() const
+    {
+        return cards;
+    }
+    [[nodiscard]] const QString &getName() const
+    {
+        return name;
+    }
+    void setWidth(qreal _width);
+
+    [[nodiscard]] QList<QPair<int, int>> getRowsAndCols() const;
+    [[nodiscard]] QSizeF calculateBoundingRect(const QList<QPair<int, int>> &rowsAndCols) const;
+    void rearrangeItems(const QList<QPair<int, int>> &rowsAndCols);
+};
+
+class DeckViewScene : public QGraphicsScene
+{
+    Q_OBJECT
+signals:
+    void newCardAdded(AbstractCardItem *card);
+    void sideboardPlanChanged();
+
+private:
+    bool locked;
+    DeckList *deck;
+    QMap<QString, DeckViewCardContainer *> cardContainers;
+    qreal optimalAspectRatio;
+    void rebuildTree();
+
+public:
+    explicit DeckViewScene(QObject *parent = nullptr);
+    ~DeckViewScene() override;
+    void setLocked(bool _locked)
+    {
+        locked = _locked;
+    }
+    [[nodiscard]] bool getLocked() const
+    {
+        return locked;
+    }
+    void clearContents();
+    void setDeck(const DeckList &_deck);
+    void setOptimalAspectRatio(qreal _optimalAspectRatio)
+    {
+        optimalAspectRatio = _optimalAspectRatio;
+    }
+    void rearrangeItems();
+    void updateContents();
+    [[nodiscard]] QList<MoveCard_ToZone> getSideboardPlan() const;
+    void resetSideboardPlan();
+    void applySideboardPlan(const QList<MoveCard_ToZone> &plan);
+};
+
+class DeckView : public QGraphicsView
+{
+    Q_OBJECT
+private:
+    DeckViewScene *deckViewScene;
+
+protected:
+    void resizeEvent(QResizeEvent *event) override;
+public slots:
+    void updateSceneRect(const QRectF &rect);
+signals:
+    void newCardAdded(AbstractCardItem *card);
+    void sideboardPlanChanged();
+
+public:
+    explicit DeckView(QWidget *parent = nullptr);
+    void setDeck(const DeckList &_deck);
+    void clearDeck();
+    void setLocked(bool _locked)
+    {
+        deckViewScene->setLocked(_locked);
+    }
+    [[nodiscard]] QList<MoveCard_ToZone> getSideboardPlan() const
+    {
+        return deckViewScene->getSideboardPlan();
+    }
+    void mouseDoubleClickEvent(QMouseEvent *event) override;
+    void resetSideboardPlan();
+};
+
+#endif
--- a/cockatrice/src/game_graphics/deckview/deck_view_container.cpp
+++ b/cockatrice/src/game_graphics/deckview/deck_view_container.cpp
@ -0,0 +1,418 @@
+#include "deck_view_container.h"
+
+#include "../../client/settings/cache_settings.h"
+#include "../../interface/card_picture_loader/card_picture_loader.h"
+#include "../../interface/deck_loader/deck_loader.h"
+#include "../../interface/widgets/dialogs/dlg_load_deck.h"
+#include "../../interface/widgets/dialogs/dlg_load_deck_from_clipboard.h"
+#include "../../interface/widgets/dialogs/dlg_load_deck_from_website.h"
+#include "../../interface/widgets/dialogs/dlg_load_remote_deck.h"
+#include "../../interface/widgets/tabs/tab_game.h"
+#include "deck_view.h"
+
+#include <QMessageBox>
+#include <libcockatrice/card/database/card_database.h>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <libcockatrice/protocol/pb/command_deck_select.pb.h>
+#include <libcockatrice/protocol/pb/command_ready_start.pb.h>
+#include <libcockatrice/protocol/pb/command_set_sideboard_lock.pb.h>
+#include <libcockatrice/protocol/pb/command_set_sideboard_plan.pb.h>
+#include <libcockatrice/protocol/pb/response_deck_download.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
+#include <libcockatrice/utility/trice_limits.h>
+
+ToggleButton::ToggleButton(QWidget *parent) : QPushButton(parent), state(false)
+{
+}
+
+void ToggleButton::paintEvent(QPaintEvent *event)
+{
+    QPushButton::paintEvent(event);
+
+    QPainter painter(this);
+    QPen pen;
+    pen.setWidth(3);
+    pen.setJoinStyle(Qt::MiterJoin);
+    pen.setColor(state ? Qt::green : Qt::red);
+    painter.setPen(pen);
+    painter.drawRect(QRect(1, 1, width() - 3, height() - 3));
+}
+
+void ToggleButton::setState(bool _state)
+{
+    state = _state;
+    emit stateChanged();
+    update();
+}
+
+DeckViewContainer::DeckViewContainer(int _playerId, TabGame *parent)
+    : QWidget(nullptr), visualDeckStorageWidget(nullptr), parentGame(parent), playerId(_playerId)
+{
+    loadLocalButton = new QPushButton;
+    loadRemoteButton = new QPushButton;
+    loadFromClipboardButton = new QPushButton;
+    loadFromWebsiteButton = new QPushButton;
+    unloadDeckButton = new QPushButton;
+    readyStartButton = new ToggleButton;
+    forceStartGameButton = new QPushButton;
+    sideboardLockButton = new ToggleButton;
+
+    connect(loadLocalButton, &QPushButton::clicked, this, &DeckViewContainer::loadLocalDeck);
+    connect(loadRemoteButton, &QPushButton::clicked, this, &DeckViewContainer::loadRemoteDeck);
+    connect(loadFromClipboardButton, &QPushButton::clicked, this, &DeckViewContainer::loadFromClipboard);
+    connect(loadFromWebsiteButton, &QPushButton::clicked, this, &DeckViewContainer::loadFromWebsite);
+    connect(readyStartButton, &QPushButton::clicked, this, &DeckViewContainer::readyStart);
+    connect(unloadDeckButton, &QPushButton::clicked, this, &DeckViewContainer::unloadDeck);
+    connect(forceStartGameButton, &QPushButton::clicked, this, &DeckViewContainer::forceStart);
+    connect(sideboardLockButton, &QPushButton::clicked, this, &DeckViewContainer::sideboardLockButtonClicked);
+    connect(sideboardLockButton, &ToggleButton::stateChanged, this, &DeckViewContainer::updateSideboardLockButtonText);
+
+    auto *buttonHBox = new QHBoxLayout;
+    buttonHBox->addWidget(loadLocalButton);
+    buttonHBox->addWidget(loadRemoteButton);
+    buttonHBox->addWidget(loadFromClipboardButton);
+    buttonHBox->addWidget(loadFromWebsiteButton);
+    buttonHBox->addWidget(unloadDeckButton);
+    buttonHBox->addWidget(readyStartButton);
+    buttonHBox->addWidget(sideboardLockButton);
+    buttonHBox->addWidget(forceStartGameButton);
+
+    buttonHBox->setContentsMargins(11, 0, 11, 0);
+    buttonHBox->addStretch();
+
+    deckView = new DeckView;
+    connect(deckView, &DeckView::newCardAdded, this, &DeckViewContainer::newCardAdded);
+    connect(deckView, &DeckView::sideboardPlanChanged, this, &DeckViewContainer::sideboardPlanChanged);
+
+    deckViewLayout = new QVBoxLayout;
+    deckViewLayout->addLayout(buttonHBox);
+    deckViewLayout->addWidget(deckView);
+    deckViewLayout->setContentsMargins(0, 0, 0, 0);
+    setLayout(deckViewLayout);
+
+    retranslateUi();
+    connect(&SettingsCache::instance().shortcuts(), &ShortcutsSettings::shortCutChanged, this,
+            &DeckViewContainer::refreshShortcuts);
+    refreshShortcuts();
+
+    connect(&SettingsCache::instance(), &SettingsCache::visualDeckStorageInGameChanged, this,
+            &DeckViewContainer::setVisualDeckStorageExists);
+
+    switchToDeckSelectView();
+}
+
+/**
+ * Creates the VDS widget and inserts it into the layout. No-ops if the widget already exists
+ */
+void DeckViewContainer::tryCreateVisualDeckStorageWidget()
+{
+    if (visualDeckStorageWidget) {
+        return;
+    }
+
+    visualDeckStorageWidget = new VisualDeckStorageWidget(this);
+    connect(visualDeckStorageWidget, &VisualDeckStorageWidget::deckLoadRequested, this,
+            &DeckViewContainer::loadDeckFromFile);
+    connect(visualDeckStorageWidget, &VisualDeckStorageWidget::openDeckEditor, parentGame, &TabGame::openDeckEditor);
+
+    deckViewLayout->addWidget(visualDeckStorageWidget);
+}
+
+void DeckViewContainer::retranslateUi()
+{
+    loadLocalButton->setText(tr("Load deck..."));
+    loadRemoteButton->setText(tr("Load remote deck..."));
+    loadFromClipboardButton->setText(tr("Load from clipboard..."));
+    loadFromWebsiteButton->setText(tr("Load from website..."));
+    unloadDeckButton->setText(tr("Unload deck"));
+    readyStartButton->setText(tr("Ready to start"));
+    forceStartGameButton->setText(tr("Force start"));
+    updateSideboardLockButtonText();
+}
+
+static void setVisibility(QPushButton *button, bool visible)
+{
+    button->setHidden(!visible);
+    button->setEnabled(visible);
+}
+
+void DeckViewContainer::switchToDeckSelectView()
+{
+    if (SettingsCache::instance().getVisualDeckStorageInGame()) {
+        deckView->setHidden(true);
+
+        tryCreateVisualDeckStorageWidget();
+        visualDeckStorageWidget->setHidden(false);
+    } else {
+        deckView->setHidden(false);
+        if (visualDeckStorageWidget) {
+            visualDeckStorageWidget->setHidden(true);
+        }
+    }
+
+    deckViewLayout->update();
+
+    setVisibility(loadLocalButton, true);
+    setVisibility(loadRemoteButton, !parentGame->getGame()->getGameState()->getIsLocalGame());
+    setVisibility(loadFromClipboardButton, true);
+    setVisibility(loadFromWebsiteButton, true);
+    setVisibility(unloadDeckButton, false);
+    setVisibility(readyStartButton, false);
+    setVisibility(sideboardLockButton, false);
+    setVisibility(forceStartGameButton, false);
+
+    readyStartButton->setState(false);
+    sideboardLockButton->setState(false);
+
+    deckView->setLocked(true);
+
+    sendReadyStartCommand(false);
+}
+
+void DeckViewContainer::switchToDeckLoadedView()
+{
+    deckView->setHidden(false);
+    if (visualDeckStorageWidget) {
+        visualDeckStorageWidget->setHidden(true);
+    }
+
+    deckViewLayout->update();
+
+    setVisibility(loadLocalButton, false);
+    setVisibility(loadRemoteButton, false);
+    setVisibility(loadFromClipboardButton, false);
+    setVisibility(loadFromWebsiteButton, false);
+    setVisibility(unloadDeckButton, true);
+    setVisibility(readyStartButton, true);
+    setVisibility(sideboardLockButton, true);
+
+    if (parentGame->getGame()->isHost()) {
+        setVisibility(forceStartGameButton, true);
+    }
+}
+
+void DeckViewContainer::updateSideboardLockButtonText()
+{
+    if (sideboardLockButton->getState()) {
+        sideboardLockButton->setText(tr("Sideboard unlocked"));
+    } else {
+        sideboardLockButton->setText(tr("Sideboard locked"));
+    }
+    // setting text on a button removes its shortcut
+    ShortcutsSettings &shortcuts = SettingsCache::instance().shortcuts();
+    sideboardLockButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/sideboardLockButton"));
+}
+
+void DeckViewContainer::refreshShortcuts()
+{
+    ShortcutsSettings &shortcuts = SettingsCache::instance().shortcuts();
+    loadLocalButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadLocalButton"));
+    loadRemoteButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadRemoteButton"));
+    loadFromClipboardButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadFromClipboardButton"));
+    unloadDeckButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/unloadDeckButton"));
+    readyStartButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/readyStartButton"));
+    sideboardLockButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/sideboardLockButton"));
+    forceStartGameButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/forceStartGameButton"));
+}
+
+/**
+ * Updates the existence of the embedded Visual Deck Storage, destroying or creating it if needed.
+ * Note that this change is temporary; the VDS may get recreated when the view transitions to the deck select state,
+ * depending on current settings.
+ */
+void DeckViewContainer::setVisualDeckStorageExists(bool exists)
+{
+    if (exists) {
+        // view mode state isn't stored in a field, so we determine state by checking the button
+        if (loadLocalButton->isEnabled()) {
+            // We only need to handle the setting changing while in deck select state; tryCreate already gets called
+            // when switching from deck loaded to deck select state
+            tryCreateVisualDeckStorageWidget();
+            visualDeckStorageWidget->setHidden(false);
+            deckView->setHidden(true);
+        }
+    } else {
+        if (visualDeckStorageWidget) {
+            visualDeckStorageWidget->deleteLater();
+            visualDeckStorageWidget = nullptr;
+        }
+        deckView->setHidden(false);
+    }
+
+    deckViewLayout->update();
+}
+
+void DeckViewContainer::unloadDeck()
+{
+    deckView->clearDeck();
+    switchToDeckSelectView();
+}
+
+void DeckViewContainer::loadLocalDeck()
+{
+    DlgLoadDeck dialog(this);
+    if (!dialog.exec()) {
+        return;
+    }
+
+    loadDeckFromFile(dialog.selectedFiles().at(0));
+}
+
+void DeckViewContainer::loadDeckFromFile(const QString &filePath)
+{
+    DeckFileFormat::Format fmt = DeckFileFormat::getFormatFromName(filePath);
+
+    std::optional<LoadedDeck> deckOpt = DeckLoader::loadFromFile(filePath, fmt, true);
+
+    if (!deckOpt) {
+        QMessageBox::critical(this, tr("Error"), tr("The selected file could not be loaded."));
+        return;
+    }
+
+    loadDeckFromDeckList(deckOpt.value().deckList);
+}
+
+void DeckViewContainer::loadDeckFromDeckList(const DeckList &deck)
+{
+    QString deckString = deck.writeToString_Native();
+
+    if (deckString.length() > MAX_FILE_LENGTH) {
+        QMessageBox::critical(this, tr("Error"), tr("Deck is greater than maximum file size."));
+        return;
+    }
+
+    Command_DeckSelect cmd;
+    cmd.set_deck(deckString.toStdString());
+    PendingCommand *pend = parentGame->getGame()->getGameEventHandler()->prepareGameCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &DeckViewContainer::deckSelectFinished);
+    parentGame->getGame()->getGameEventHandler()->sendGameCommand(pend, playerId);
+}
+
+void DeckViewContainer::loadRemoteDeck()
+{
+    DlgLoadRemoteDeck dlg(parentGame->getGame()->getClientForPlayer(playerId), this);
+    if (dlg.exec()) {
+        Command_DeckSelect cmd;
+        cmd.set_deck_id(dlg.getDeckId());
+        PendingCommand *pend = parentGame->getGame()->getGameEventHandler()->prepareGameCommand(cmd);
+        connect(pend, &PendingCommand::finished, this, &DeckViewContainer::deckSelectFinished);
+        parentGame->getGame()->getGameEventHandler()->sendGameCommand(pend, playerId);
+    }
+}
+
+void DeckViewContainer::loadFromClipboard()
+{
+    auto dlg = DlgLoadDeckFromClipboard(this);
+
+    if (!dlg.exec()) {
+        return;
+    }
+
+    DeckList deck = dlg.getDeckList();
+    loadDeckFromDeckList(deck);
+}
+
+void DeckViewContainer::loadFromWebsite()
+{
+    auto dlg = DlgLoadDeckFromWebsite(this);
+
+    if (!dlg.exec()) {
+        return;
+    }
+
+    DeckList deck = dlg.getDeck();
+    loadDeckFromDeckList(deck);
+}
+
+void DeckViewContainer::deckSelectFinished(const Response &r)
+{
+    const Response_DeckDownload &resp = r.GetExtension(Response_DeckDownload::ext);
+    DeckList newDeck = DeckList(QString::fromStdString(resp.deck()));
+    CardPictureLoader::cacheCardPixmaps(CardDatabaseManager::query()->getCards(newDeck.getCardRefList()));
+    setDeck(newDeck);
+    switchToDeckLoadedView();
+}
+
+void DeckViewContainer::readyStart()
+{
+    sendReadyStartCommand(!readyStartButton->getState());
+}
+
+void DeckViewContainer::forceStart()
+{
+    const auto msg = tr("Are you sure you want to force start?\nThis will kick all non-ready players from the game.");
+    const auto res =
+        QMessageBox::question(this, tr("Cockatrice"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
+    if (res == QMessageBox::No) {
+        return;
+    }
+
+    Command_ReadyStart cmd;
+    cmd.set_force_start(true);
+    cmd.set_ready(true);
+    parentGame->getGame()->getGameEventHandler()->sendGameCommand(cmd, playerId);
+}
+
+void DeckViewContainer::sideboardLockButtonClicked()
+{
+    Command_SetSideboardLock cmd;
+    cmd.set_locked(sideboardLockButton->getState());
+
+    parentGame->getGame()->getGameEventHandler()->sendGameCommand(cmd, playerId);
+}
+
+void DeckViewContainer::sideboardPlanChanged()
+{
+    Command_SetSideboardPlan cmd;
+    const QList<MoveCard_ToZone> &newPlan = deckView->getSideboardPlan();
+    for (const auto &i : newPlan) {
+        cmd.add_move_list()->CopyFrom(i);
+    }
+    parentGame->getGame()->getGameEventHandler()->sendGameCommand(cmd, playerId);
+}
+
+/**
+ * Sends the basic ReadyStart command.
+ */
+void DeckViewContainer::sendReadyStartCommand(bool ready)
+{
+    Command_ReadyStart cmd;
+    cmd.set_ready(ready);
+    parentGame->getGame()->getGameEventHandler()->sendGameCommand(cmd, playerId);
+}
+
+/**
+ * Updates the buttons to make the client-side ready state match the given state.
+ *
+ * Notably, this method only updates the client and *does not* send a ReadyStart command to the server.
+ * This method is intended to be called upon receiving the response from a ReadyStart command.
+ */
+void DeckViewContainer::setReadyStart(bool ready)
+{
+    readyStartButton->setState(ready);
+    deckView->setLocked(ready || !sideboardLockButton->getState());
+    sideboardLockButton->setEnabled(!readyStartButton->getState() && readyStartButton->isEnabled());
+}
+
+/**
+ * Sends a ReadyStart command with ready=true to the server
+ */
+void DeckViewContainer::readyAndUpdate()
+{
+    sendReadyStartCommand(true);
+}
+
+void DeckViewContainer::setSideboardLocked(bool locked)
+{
+    sideboardLockButton->setState(!locked);
+    deckView->setLocked(readyStartButton->getState() || !sideboardLockButton->getState());
+    if (locked) {
+        deckView->resetSideboardPlan();
+    }
+}
+
+void DeckViewContainer::setDeck(const DeckList &deck)
+{
+    deckView->setDeck(deck);
+    switchToDeckLoadedView();
+}
--- a/cockatrice/src/game_graphics/deckview/deck_view_container.h
+++ b/cockatrice/src/game_graphics/deckview/deck_view_container.h
@ -0,0 +1,96 @@
+/**
+ * @file deck_view_container.h
+ * @ingroup Lobby
+ */
+//! \todo Document this file.
+
+#ifndef DECK_VIEW_CONTAINER_H
+#define DECK_VIEW_CONTAINER_H
+
+#include "../../interface/deck_loader/deck_loader.h"
+
+#include <QPushButton>
+
+class QVBoxLayout;
+class AbstractCardItem;
+class VisualDeckStorageWidget;
+class DeckPreviewWidget;
+class Response;
+class TabGame;
+class DeckView;
+
+/**
+ * Custom QButton implementation in order to have the red/green toggling square around the button
+ */
+class ToggleButton : public QPushButton
+{
+    Q_OBJECT
+private:
+    bool state;
+signals:
+    void stateChanged();
+
+public:
+    explicit ToggleButton(QWidget *parent = nullptr);
+    [[nodiscard]] bool getState() const
+    {
+        return state;
+    }
+    void setState(bool _state);
+
+protected:
+    void paintEvent(QPaintEvent *event) override;
+};
+
+/**
+ * This widget contains the deck selection view that is used before a game begins.
+ */
+class DeckViewContainer : public QWidget
+{
+    Q_OBJECT
+private:
+    QVBoxLayout *deckViewLayout;
+    QPushButton *loadLocalButton, *loadRemoteButton, *loadFromClipboardButton, *loadFromWebsiteButton;
+    QPushButton *unloadDeckButton, *forceStartGameButton;
+    ToggleButton *readyStartButton, *sideboardLockButton;
+    DeckView *deckView;
+    VisualDeckStorageWidget *visualDeckStorageWidget;
+    TabGame *parentGame;
+    int playerId;
+
+    void tryCreateVisualDeckStorageWidget();
+    void sendReadyStartCommand(bool ready);
+private slots:
+    void switchToDeckSelectView();
+    void switchToDeckLoadedView();
+    void loadLocalDeck();
+    void loadRemoteDeck();
+    void loadFromClipboard();
+    void loadFromWebsite();
+    void unloadDeck();
+    void readyStart();
+    void forceStart();
+    void deckSelectFinished(const Response &r);
+    void sideboardPlanChanged();
+    void sideboardLockButtonClicked();
+    void updateSideboardLockButtonText();
+    void refreshShortcuts();
+signals:
+    void newCardAdded(AbstractCardItem *card);
+    void notIdle();
+
+public:
+    DeckViewContainer(int _playerId, TabGame *parent);
+    void retranslateUi();
+    void setReadyStart(bool ready);
+    void readyAndUpdate();
+    void setSideboardLocked(bool locked);
+    void setDeck(const DeckList &deck);
+    void setVisualDeckStorageExists(bool exists);
+
+public slots:
+    void loadDeckFromFile(const QString &filePath);
+    void loadDeckFromDeckList(const DeckList &deck);
+};
+
+#endif // DECK_VIEW_CONTAINER_H
--- a/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.cpp
+++ b/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.cpp
@ -0,0 +1,66 @@
+#include "tabbed_deck_view_container.h"
+
+#include "../../interface/widgets/tabs/tab_game.h"
+#include "deck_view.h"
+
+TabbedDeckViewContainer::TabbedDeckViewContainer(int _playerId, TabGame *parent)
+    : QTabWidget(nullptr), playerId(_playerId), parentGame(parent)
+{
+    setTabsClosable(true);
+    connect(this, &QTabWidget::tabCloseRequested, this, &TabbedDeckViewContainer::closeTab);
+
+    playerDeckView = new DeckViewContainer(playerId, parentGame);
+    int playerTabIndex = addTab(playerDeckView, "Your Deck");
+    tabBar()->setTabButton(playerTabIndex, QTabBar::RightSide, nullptr);
+    updateTabBarVisibility();
+}
+
+void TabbedDeckViewContainer::addOpponentDeckView(const DeckList &opponentDeck, int opponentId, QString opponentName)
+{
+    if (opponentDeckViews.contains(opponentId)) {
+        opponentDeckViews[opponentId]->setDeck(opponentDeck);
+    } else {
+        auto *opponentDeckView = new DeckView(this);
+        connect(opponentDeckView, &DeckView::newCardAdded, playerDeckView, &DeckViewContainer::newCardAdded);
+
+        opponentDeckView->setDeck(opponentDeck);
+
+        addTab(opponentDeckView, QString("%1's Deck").arg(opponentName));
+
+        opponentDeckViews.insert(opponentId, opponentDeckView);
+    }
+    updateTabBarVisibility();
+}
+
+void TabbedDeckViewContainer::closeTab(int index)
+{
+    QWidget *widgetToClose = widget(index);
+
+    // Prevent removing the player tab
+    if (widgetToClose == playerDeckView) {
+        return;
+    }
+
+    // Remove it from map if it's an opponent
+    auto it = opponentDeckViews.begin();
+    while (it != opponentDeckViews.end()) {
+        if (it.value() == widgetToClose) {
+            it = opponentDeckViews.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    removeTab(index);
+    widgetToClose->deleteLater();
+    updateTabBarVisibility();
+}
+
+void TabbedDeckViewContainer::updateTabBarVisibility()
+{
+    if (tabBar()->count() <= 1) {
+        tabBar()->hide();
+    } else {
+        tabBar()->show();
+    }
+}
--- a/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.h
+++ b/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.h
@ -0,0 +1,29 @@
+/**
+ * @file tabbed_deck_view_container.h
+ * @ingroup Lobby
+ */
+//! \todo Document this file.
+
+#ifndef TABBED_DECK_VIEW_CONTAINER_H
+#define TABBED_DECK_VIEW_CONTAINER_H
+#include "deck_view_container.h"
+
+#include <QTabWidget>
+
+class TabbedDeckViewContainer : public QTabWidget
+{
+    Q_OBJECT
+
+public:
+    explicit TabbedDeckViewContainer(int _playerId, TabGame *parent);
+    void closeTab(int index);
+    void updateTabBarVisibility();
+    void addOpponentDeckView(const DeckList &opponentDeck, int opponentId, QString opponentName);
+    int playerId;
+    TabGame *parentGame;
+    DeckViewContainer *playerDeckView;
+
+    QMap<int, DeckView *> opponentDeckViews;
+};
+
+#endif // TABBED_DECK_VIEW_CONTAINER_H