diff --git a/cockatrice/src/player.cpp b/cockatrice/src/player.cpp
index b7cf0e33b..201a25f2b 100644
--- a/cockatrice/src/player.cpp
+++ b/cockatrice/src/player.cpp
@@ -2740,8 +2740,10 @@ qreal Player::getMinimumWidth() const
 
 void Player::setGameStarted()
 {
-    if (local)
+    if (local && aAlwaysRevealTopCard)
+    {
         aAlwaysRevealTopCard->setChecked(false);
+    }
     setConceded(false);
 }
 
diff --git a/cockatrice/src/player.h b/cockatrice/src/player.h
index e1f1d295a..2be1594d6 100644
--- a/cockatrice/src/player.h
+++ b/cockatrice/src/player.h
@@ -59,268 +59,276 @@ class PendingCommand;
 
 const int MAX_TOKENS_PER_DIALOG = 99;
 
-class PlayerArea : public QObject, public QGraphicsItem {
+class PlayerArea : public QObject, public QGraphicsItem
+{
     Q_OBJECT
     Q_INTERFACES(QGraphicsItem)
-private:
-    QRectF bRect;
-private slots:
-    void updateBg();
-public:
-    enum { Type = typeOther };
-    int type() const { return Type; }
-    
-    PlayerArea(QGraphicsItem *parent = 0);
-    QRectF boundingRect() const { return bRect; }
-    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-    
-    void setSize(qreal width, qreal height);
+    private:
+        QRectF bRect;
+
+    private slots:
+        void updateBg();
+
+    public:
+        enum { Type = typeOther };
+        int type() const override
+        { return Type; }
+
+        explicit PlayerArea(QGraphicsItem *parent = nullptr);
+        QRectF boundingRect() const override { return bRect; }
+        void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+
+        void setSize(qreal width, qreal height);
 };
 
-class Player : public QObject, public QGraphicsItem {
+class Player : public QObject, public QGraphicsItem
+{
     Q_OBJECT
     Q_INTERFACES(QGraphicsItem)
-signals:
-    void openDeckEditor(const DeckLoader *deck);
-    void newCardAdded(AbstractCardItem *card);
-    // Log events
-    void logSay(Player *player, QString message);
-    void logShuffle(Player *player, CardZone *zone);
-    void logRollDie(Player *player, int sides, int roll);
-    void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard, bool _playerTarget);
-    void logCreateToken(Player *player, QString cardName, QString pt);
-    void logDrawCards(Player *player, int number);
-    void logUndoDraw(Player *player, QString cardName);
-    void logMoveCard(Player *player, CardItem *card, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
-    void logFlipCard(Player *player, QString cardName, bool faceDown);
-    void logDestroyCard(Player *player, QString cardName);
-    void logAttachCard(Player *player, QString cardName, Player *targetPlayer, QString targetCardName);
-    void logUnattachCard(Player *player, QString cardName);
-    void logSetCardCounter(Player *player, QString cardName, int counterId, int value, int oldValue);
-    void logSetTapped(Player *player, CardItem *card, bool tapped);
-    void logSetCounter(Player *player, QString counterName, int value, int oldValue);
-    void logSetDoesntUntap(Player *player, CardItem *card, bool doesntUntap);
-    void logSetPT(Player *player, CardItem *card, QString newPT);
-    void logSetAnnotation(Player *player, CardItem *card, QString newAnnotation);
-    void logDumpZone(Player *player, CardZone *zone, int numberCards);
-    void logStopDumpZone(Player *player, CardZone *zone);
-    void logRevealCards(Player *player, CardZone *zone, int cardId, QString cardName, Player *otherPlayer, bool faceDown);
-    void logAlwaysRevealTopCard(Player *player, CardZone *zone, bool reveal);
-    
-    void sizeChanged();
-    void gameConceded();
-public slots:
-    void actUntapAll();
-    void actRollDie();
-    void actCreateToken();
-    void actCreateAnotherToken();
-    void actShuffle();
-    void actDrawCard();
-    void actDrawCards();
-    void actUndoDraw();
-    void actMulligan();
-    void actMoveTopCardToPlayFaceDown();
-    void actMoveTopCardsToGrave();
-    void actMoveTopCardsToExile();
-    void actMoveTopCardToBottom();
-    void actMoveBottomCardToGrave();
 
-    void actViewLibrary();
-    void actViewTopCards();
-    void actAlwaysRevealTopCard();
-    void actViewGraveyard();
-    void actRevealRandomGraveyardCard();
-    void actViewRfg();
-    void actViewSideboard();
-    
-    void actSayMessage();
-private slots:
-    void addPlayer(Player *player);
-    void removePlayer(Player *player);
-    void playerListActionTriggered();
-    
-    void updateBoundingRect();
-    void rearrangeZones();
-    
-    void actOpenDeckInDeckEditor();
-    void actCreatePredefinedToken();
-    void actCreateRelatedCard();
-    void actCreateAllRelatedCards();
-    void cardMenuAction();
-    void actMoveCardXCardsFromTop();
-    void actCardCounterTrigger();
-    void actAttach();
-    void actUnattach();
-    void actDrawArrow();
-    void actIncPT(int deltaP, int deltaT);
-    void actSetPT();
-    void actIncP();
-    void actDecP();
-    void actIncT();
-    void actDecT();
-    void actIncPT();
-    void actDecPT();
-    void actSetAnnotation();
-    void actPlay();
-    void actHide();
-    void actPlayFacedown();
-    void refreshShortcuts();
+    signals:
+        void openDeckEditor(const DeckLoader *deck);
+        void newCardAdded(AbstractCardItem *card);
+        // Log events
+        void logSay(Player *player, QString message);
+        void logShuffle(Player *player, CardZone *zone);
+        void logRollDie(Player *player, int sides, int roll);
+        void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard, bool _playerTarget);
+        void logCreateToken(Player *player, QString cardName, QString pt);
+        void logDrawCards(Player *player, int number);
+        void logUndoDraw(Player *player, QString cardName);
+        void logMoveCard(Player *player, CardItem *card, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
+        void logFlipCard(Player *player, QString cardName, bool faceDown);
+        void logDestroyCard(Player *player, QString cardName);
+        void logAttachCard(Player *player, QString cardName, Player *targetPlayer, QString targetCardName);
+        void logUnattachCard(Player *player, QString cardName);
+        void logSetCardCounter(Player *player, QString cardName, int counterId, int value, int oldValue);
+        void logSetTapped(Player *player, CardItem *card, bool tapped);
+        void logSetCounter(Player *player, QString counterName, int value, int oldValue);
+        void logSetDoesntUntap(Player *player, CardItem *card, bool doesntUntap);
+        void logSetPT(Player *player, CardItem *card, QString newPT);
+        void logSetAnnotation(Player *player, CardItem *card, QString newAnnotation);
+        void logDumpZone(Player *player, CardZone *zone, int numberCards);
+        void logStopDumpZone(Player *player, CardZone *zone);
+        void logRevealCards(Player *player, CardZone *zone, int cardId, QString cardName, Player *otherPlayer, bool faceDown);
+        void logAlwaysRevealTopCard(Player *player, CardZone *zone, bool reveal);
 
-private:
-    TabGame *game;
-    QMenu *playerMenu, *handMenu, *moveHandMenu, *graveMenu, *moveGraveMenu, *rfgMenu, *moveRfgMenu, *libraryMenu, *sbMenu, *countersMenu, *sayMenu, *createPredefinedTokenMenu,
-        *mRevealLibrary, *mRevealTopCard, *mRevealHand, *mRevealRandomHandCard, *mRevealRandomGraveyardCard;
-    QList<QMenu *> playerLists;
-    QList<QAction *> allPlayersActions;
-    QAction *aMoveHandToTopLibrary, *aMoveHandToBottomLibrary, *aMoveHandToGrave, *aMoveHandToRfg,
-        *aMoveGraveToTopLibrary, *aMoveGraveToBottomLibrary, *aMoveGraveToHand, *aMoveGraveToRfg,
-        *aMoveRfgToTopLibrary, *aMoveRfgToBottomLibrary, *aMoveRfgToHand, *aMoveRfgToGrave,
-        *aViewLibrary, *aViewTopCards, *aAlwaysRevealTopCard, *aOpenDeckInDeckEditor, *aMoveTopCardsToGrave, *aMoveTopCardsToExile, *aMoveTopCardToBottom,
-        *aViewGraveyard, *aViewRfg, *aViewSideboard,
-                *aDrawCard, *aDrawCards, *aUndoDraw, *aMulligan, *aShuffle, *aMoveTopToPlayFaceDown,
-        *aUntapAll, *aRollDie, *aCreateToken, *aCreateAnotherToken,
-        *aCardMenu, *aMoveBottomCardToGrave;
-    
-    QList<QAction *> aAddCounter, aSetCounter, aRemoveCounter;
-    QAction *aPlay, *aPlayFacedown,
-        *aHide,
-        *aTap, *aDoesntUntap, *aAttach, *aUnattach, *aDrawArrow, *aSetPT, *aIncP, *aDecP, *aIncT, *aDecT, *aIncPT, *aDecPT, *aSetAnnotation, *aFlip, *aPeek, *aClone,
-        *aMoveToTopLibrary, *aMoveToBottomLibrary, *aMoveToHand, *aMoveToGraveyard, *aMoveToExile, *aMoveToXfromTopOfLibrary;
+        void sizeChanged();
+        void gameConceded();
 
-    bool shortcutsActive;
-    int defaultNumberTopCards;
-    int defaultNumberTopCardsToPlaceBelow;
-    QString lastTokenName, lastTokenColor, lastTokenPT, lastTokenAnnotation;
-    bool lastTokenDestroy;
-    int lastTokenTableRow;
-    ServerInfo_User *userInfo;
-    int id;
-    bool active;
-    bool local;
-    bool mirrored;
-    bool handVisible;
-    bool conceded;
-    
-    bool dialogSemaphore;
-    bool clearCardsToDelete();
-    QList<CardItem *> cardsToDelete;
-    
-    DeckLoader *deck;
-    QStringList predefinedTokens;
-    
-    PlayerArea *playerArea;
-    QMap<QString, CardZone *> zones;
-    StackZone *stack;
-    TableZone *table;
-    HandZone *hand;
-    PlayerTarget *playerTarget;
-    
-    void setCardAttrHelper(const GameEventContext &context, CardItem *card, CardAttribute attribute, const QString &avalue, bool allCards);
-    void addRelatedCardActions(const CardItem *card, QMenu *cardMenu);
-    void createCard(const CardItem *sourceCard, const QString &dbCardName, bool attach = false);
-    void createAttachedCard(const CardItem *sourceCard, const QString &dbCardName);
-    bool createRelatedFromRelation(const CardItem *sourceCard, const CardRelation *cardRelation);
-    QString dbNameFromTokenDisplayName(const QString &tokenName);
+    public slots:
+        void actUntapAll();
+        void actRollDie();
+        void actCreateToken();
+        void actCreateAnotherToken();
+        void actShuffle();
+        void actDrawCard();
+        void actDrawCards();
+        void actUndoDraw();
+        void actMulligan();
+        void actMoveTopCardToPlayFaceDown();
+        void actMoveTopCardsToGrave();
+        void actMoveTopCardsToExile();
+        void actMoveTopCardToBottom();
+        void actMoveBottomCardToGrave();
 
-    QRectF bRect;
+        void actViewLibrary();
+        void actViewTopCards();
+        void actAlwaysRevealTopCard();
+        void actViewGraveyard();
+        void actRevealRandomGraveyardCard();
+        void actViewRfg();
+        void actViewSideboard();
 
-    QMap<int, AbstractCounter *> counters;
-    QMap<int, ArrowItem *> arrows;
-    void rearrangeCounters();
-    
-    void initSayMenu();
-    
-    void eventConnectionStateChanged(const Event_ConnectionStateChanged &event);
-    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);
-    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 eventStopDumpZone(const Event_StopDumpZone &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);
-    void eventChangeZoneProperties(const Event_ChangeZoneProperties &event);
-public:
-    static const int counterAreaWidth = 55;
-    enum CardMenuActionType { cmTap, cmUntap, cmDoesntUntap, cmFlip, cmPeek, cmClone, cmMoveToTopLibrary, cmMoveToBottomLibrary, cmMoveToHand, cmMoveToGraveyard, cmMoveToExile };
-    enum CardsToReveal {RANDOM_CARD_FROM_ZONE = -2};
+        void actSayMessage();
 
-    enum { Type = typeOther };
-    int type() const { return Type; }
-    QRectF boundingRect() const;
-    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-    
-    void playCard(CardItem *c, bool faceDown, bool tapped);
-    void addCard(CardItem *c);
-    void deleteCard(CardItem *c);
-    void addZone(CardZone *z);
+    private slots:
+        void addPlayer(Player *player);
+        void removePlayer(Player *player);
+        void playerListActionTriggered();
 
-    AbstractCounter *addCounter(const ServerInfo_Counter &counter);
-    AbstractCounter *addCounter(int counterId, const QString &name, QColor color, int radius, int value);
-    void delCounter(int counterId);
-    void clearCounters();
-    
-    ArrowItem *addArrow(const ServerInfo_Arrow &arrow);
-    ArrowItem *addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color);
-    void delArrow(int arrowId);
-    void removeArrow(ArrowItem *arrow);
-    void clearArrows();
-    PlayerTarget *getPlayerTarget() const { return playerTarget; }
+        void updateBoundingRect();
+        void rearrangeZones();
 
-    Player(const ServerInfo_User &info, int _id, bool _local, TabGame *_parent);
-    ~Player();
-    void retranslateUi();
-    void clear();
-    TabGame *getGame() const { return game; }
-    void setDeck(const DeckLoader &_deck);
-    QMenu *getPlayerMenu() const { return playerMenu; }
-    int getId() const { return id; }
-    QString getName() const;
-    ServerInfo_User *getUserInfo() const { return userInfo; }
-    bool getLocal() const { return local; }
-    bool getMirrored() const { return mirrored; }
-    const QMap<QString, CardZone *> &getZones() const { return zones; }
-    const QMap<int, ArrowItem *> &getArrows() const { return arrows; }
-    void setCardMenu(QMenu *menu);
-    QMenu *getCardMenu() const;
-    void updateCardMenu(const CardItem *card);
-    bool getActive() const { return active; }
-    void setActive(bool _active);
-    void setShortcutsActive();
-    void setShortcutsInactive();
-    void updateZones();
-    
-    void setConceded(bool _conceded);
-    bool getConceded() const { return conceded; }
+        void actOpenDeckInDeckEditor();
+        void actCreatePredefinedToken();
+        void actCreateRelatedCard();
+        void actCreateAllRelatedCards();
+        void cardMenuAction();
+        void actMoveCardXCardsFromTop();
+        void actCardCounterTrigger();
+        void actAttach();
+        void actUnattach();
+        void actDrawArrow();
+        void actIncPT(int deltaP, int deltaT);
+        void actSetPT();
+        void actIncP();
+        void actDecP();
+        void actIncT();
+        void actDecT();
+        void actIncPT();
+        void actDecPT();
+        void actSetAnnotation();
+        void actPlay();
+        void actHide();
+        void actPlayFacedown();
+        void refreshShortcuts();
 
-    void setGameStarted();
-    
-    qreal getMinimumWidth() const;
-    void setMirrored(bool _mirrored);
-    void processSceneSizeChange(int newPlayerWidth);
-    
-    void processPlayerInfo(const ServerInfo_Player &info);
-    void processCardAttachment(const ServerInfo_Player &info);
-    
-    void processGameEvent(GameEvent::GameEventType type, const GameEvent &event, const GameEventContext &context);
+    private:
+        TabGame *game;
+        QMenu *playerMenu, *handMenu, *moveHandMenu, *graveMenu, *moveGraveMenu, *rfgMenu, *moveRfgMenu, *libraryMenu, *sbMenu, *countersMenu, *sayMenu, *createPredefinedTokenMenu,
+            *mRevealLibrary, *mRevealTopCard, *mRevealHand, *mRevealRandomHandCard, *mRevealRandomGraveyardCard;
+        QList<QMenu *> playerLists;
+        QList<QAction *> allPlayersActions;
+        QAction *aMoveHandToTopLibrary, *aMoveHandToBottomLibrary, *aMoveHandToGrave, *aMoveHandToRfg,
+            *aMoveGraveToTopLibrary, *aMoveGraveToBottomLibrary, *aMoveGraveToHand, *aMoveGraveToRfg,
+            *aMoveRfgToTopLibrary, *aMoveRfgToBottomLibrary, *aMoveRfgToHand, *aMoveRfgToGrave,
+            *aViewLibrary, *aViewTopCards, *aAlwaysRevealTopCard, *aOpenDeckInDeckEditor, *aMoveTopCardsToGrave, *aMoveTopCardsToExile, *aMoveTopCardToBottom,
+            *aViewGraveyard, *aViewRfg, *aViewSideboard,
+                    *aDrawCard, *aDrawCards, *aUndoDraw, *aMulligan, *aShuffle, *aMoveTopToPlayFaceDown,
+            *aUntapAll, *aRollDie, *aCreateToken, *aCreateAnotherToken,
+            *aCardMenu, *aMoveBottomCardToGrave;
 
-    PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
-    PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList);
-    void sendGameCommand(PendingCommand *pend);
-    void sendGameCommand(const google::protobuf::Message &command);
+        QList<QAction *> aAddCounter, aSetCounter, aRemoveCounter;
+        QAction *aPlay, *aPlayFacedown,
+            *aHide,
+            *aTap, *aDoesntUntap, *aAttach, *aUnattach, *aDrawArrow, *aSetPT, *aIncP, *aDecP, *aIncT, *aDecT, *aIncPT, *aDecPT, *aSetAnnotation, *aFlip, *aPeek, *aClone,
+            *aMoveToTopLibrary, *aMoveToBottomLibrary, *aMoveToHand, *aMoveToGraveyard, *aMoveToExile, *aMoveToXfromTopOfLibrary;
 
-    void setLastToken(CardInfo *cardInfo);
+        bool shortcutsActive;
+        int defaultNumberTopCards;
+        int defaultNumberTopCardsToPlaceBelow;
+        QString lastTokenName, lastTokenColor, lastTokenPT, lastTokenAnnotation;
+        bool lastTokenDestroy;
+        int lastTokenTableRow;
+        ServerInfo_User *userInfo;
+        int id;
+        bool active;
+        bool local;
+        bool mirrored;
+        bool handVisible;
+        bool conceded;
+
+        bool dialogSemaphore;
+        bool clearCardsToDelete();
+        QList<CardItem *> cardsToDelete;
+
+        DeckLoader *deck;
+        QStringList predefinedTokens;
+
+        PlayerArea *playerArea;
+        QMap<QString, CardZone *> zones;
+        StackZone *stack;
+        TableZone *table;
+        HandZone *hand;
+        PlayerTarget *playerTarget;
+
+        void setCardAttrHelper(const GameEventContext &context, CardItem *card, CardAttribute attribute, const QString &avalue, bool allCards);
+        void addRelatedCardActions(const CardItem *card, QMenu *cardMenu);
+        void createCard(const CardItem *sourceCard, const QString &dbCardName, bool attach = false);
+        void createAttachedCard(const CardItem *sourceCard, const QString &dbCardName);
+        bool createRelatedFromRelation(const CardItem *sourceCard, const CardRelation *cardRelation);
+        QString dbNameFromTokenDisplayName(const QString &tokenName);
+
+        QRectF bRect;
+
+        QMap<int, AbstractCounter *> counters;
+        QMap<int, ArrowItem *> arrows;
+        void rearrangeCounters();
+
+        void initSayMenu();
+
+        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);
+        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 eventStopDumpZone(const Event_StopDumpZone &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);
+        void eventChangeZoneProperties(const Event_ChangeZoneProperties &event);
+
+    public:
+        static const int counterAreaWidth = 55;
+        enum CardMenuActionType { cmTap, cmUntap, cmDoesntUntap, cmFlip, cmPeek, cmClone, cmMoveToTopLibrary, cmMoveToBottomLibrary, cmMoveToHand, cmMoveToGraveyard, cmMoveToExile };
+        enum CardsToReveal {RANDOM_CARD_FROM_ZONE = -2};
+
+        enum { Type = typeOther };
+        int type() const override { return Type; }
+        QRectF boundingRect() const override;
+        void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
+
+        void playCard(CardItem *c, bool faceDown, bool tapped);
+        void addCard(CardItem *c);
+        void deleteCard(CardItem *c);
+        void addZone(CardZone *z);
+
+        AbstractCounter *addCounter(const ServerInfo_Counter &counter);
+        AbstractCounter *addCounter(int counterId, const QString &name, QColor color, int radius, int value);
+        void delCounter(int counterId);
+        void clearCounters();
+
+        ArrowItem *addArrow(const ServerInfo_Arrow &arrow);
+        ArrowItem *addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color);
+        void delArrow(int arrowId);
+        void removeArrow(ArrowItem *arrow);
+        void clearArrows();
+        PlayerTarget *getPlayerTarget() const { return playerTarget; }
+
+        Player(const ServerInfo_User &info, int _id, bool _local, TabGame *_parent);
+        ~Player() override;
+        void retranslateUi();
+        void clear();
+        TabGame *getGame() const { return game; }
+        void setDeck(const DeckLoader &_deck);
+        QMenu *getPlayerMenu() const { return playerMenu; }
+        int getId() const { return id; }
+        QString getName() const;
+        ServerInfo_User *getUserInfo() const { return userInfo; }
+        bool getLocal() const { return local; }
+        bool getMirrored() const { return mirrored; }
+        const QMap<QString, CardZone *> &getZones() const { return zones; }
+        const QMap<int, ArrowItem *> &getArrows() const { return arrows; }
+        void setCardMenu(QMenu *menu);
+        QMenu *getCardMenu() const;
+        void updateCardMenu(const CardItem *card);
+        bool getActive() const { return active; }
+        void setActive(bool _active);
+        void setShortcutsActive();
+        void setShortcutsInactive();
+        void updateZones();
+
+        void setConceded(bool _conceded);
+        bool getConceded() const { return conceded; }
+
+        void setGameStarted();
+
+        qreal getMinimumWidth() const;
+        void setMirrored(bool _mirrored);
+        void processSceneSizeChange(int newPlayerWidth);
+
+        void processPlayerInfo(const ServerInfo_Player &info);
+        void processCardAttachment(const ServerInfo_Player &info);
+
+        void processGameEvent(GameEvent::GameEventType type, const GameEvent &event, const GameEventContext &context);
+
+        PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
+        PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList);
+        void sendGameCommand(PendingCommand *pend);
+        void sendGameCommand(const google::protobuf::Message &command);
+
+        void setLastToken(CardInfo *cardInfo);
 };
 
 #endif
diff --git a/cockatrice/src/tab_game.cpp b/cockatrice/src/tab_game.cpp
index 077543fc2..a77c3ce7f 100644
--- a/cockatrice/src/tab_game.cpp
+++ b/cockatrice/src/tab_game.cpp
@@ -70,9 +70,9 @@
 #include "pb/context_ping_changed.pb.h"
 #include "get_pb_extension.h"
 
-ToggleButton::ToggleButton(QWidget *parent)
-        : QPushButton(parent), state(false)
+ToggleButton::ToggleButton(QWidget *parent) : QPushButton(parent), state(false)
 {
+
 }
 
 void ToggleButton::paintEvent(QPaintEvent *event)
@@ -95,13 +95,15 @@ void ToggleButton::setState(bool _state)
     update();
 }
 
-DeckViewContainer::DeckViewContainer(int _playerId, TabGame *parent)
-        : QWidget(0), parentGame(parent), playerId(_playerId)
+DeckViewContainer::DeckViewContainer(int _playerId, TabGame *parent) : QWidget(nullptr), parentGame(parent), playerId(_playerId)
 {
     loadLocalButton = new QPushButton;
     loadRemoteButton = new QPushButton;
     if (parentGame->getIsLocalGame())
+    {
         loadRemoteButton->setEnabled(false);
+    }
+
     readyStartButton = new ToggleButton;
     readyStartButton->setEnabled(false);
     sideboardLockButton = new ToggleButton;
@@ -113,18 +115,19 @@ DeckViewContainer::DeckViewContainer(int _playerId, TabGame *parent)
     connect(sideboardLockButton, SIGNAL(clicked()), this, SLOT(sideboardLockButtonClicked()));
     connect(sideboardLockButton, SIGNAL(stateChanged()), this, SLOT(updateSideboardLockButtonText()));
 
-    QHBoxLayout *buttonHBox = new QHBoxLayout;
+    auto *buttonHBox = new QHBoxLayout;
     buttonHBox->addWidget(loadLocalButton);
     buttonHBox->addWidget(loadRemoteButton);
     buttonHBox->addWidget(readyStartButton);
     buttonHBox->addWidget(sideboardLockButton);
     buttonHBox->setContentsMargins(0, 0, 0, 0);
     buttonHBox->addStretch();
+
     deckView = new DeckView;
     connect(deckView, SIGNAL(newCardAdded(AbstractCardItem *)), this, SIGNAL(newCardAdded(AbstractCardItem *)));
     connect(deckView, SIGNAL(sideboardPlanChanged()), this, SLOT(sideboardPlanChanged()));
 
-    QVBoxLayout *deckViewLayout = new QVBoxLayout;
+    auto *deckViewLayout = new QVBoxLayout;
     deckViewLayout->addLayout(buttonHBox);
     deckViewLayout->addWidget(deckView);
     deckViewLayout->setContentsMargins(0, 0, 0, 0);
@@ -143,20 +146,16 @@ void DeckViewContainer::retranslateUi()
     updateSideboardLockButtonText();
 }
 
-void DeckViewContainer::setButtonsVisible(bool _visible)
-{
-    loadLocalButton->setVisible(_visible);
-    loadRemoteButton->setVisible(_visible);
-    readyStartButton->setVisible(_visible);
-    sideboardLockButton->setVisible(_visible);
-}
-
 void DeckViewContainer::updateSideboardLockButtonText()
 {
     if (sideboardLockButton->getState())
+    {
         sideboardLockButton->setText(tr("S&ideboard unlocked"));
+    }
     else
+    {
         sideboardLockButton->setText(tr("S&ideboard locked"));
+    }
 }
 
 void DeckViewContainer::refreshShortcuts()
@@ -167,9 +166,11 @@ void DeckViewContainer::refreshShortcuts()
 
 void TabGame::refreshShortcuts()
 {
-    for (int i = 0; i < phaseActions.size(); ++i) {
+    for (int i = 0; i < phaseActions.size(); i++)
+    {
         QAction *temp = phaseActions.at(i);
-        switch (i) {
+        switch (i)
+        {
             case 0: temp->setShortcuts(settingsCache->shortcuts().getShortcut("Player/phase0")); break;
             case 1: temp->setShortcuts(settingsCache->shortcuts().getShortcut("Player/phase1")); break;
             case 2: temp->setShortcuts(settingsCache->shortcuts().getShortcut("Player/phase2")); break;
@@ -181,35 +182,52 @@ void TabGame::refreshShortcuts()
             case 8: temp->setShortcuts(settingsCache->shortcuts().getShortcut("Player/phase8")); break;
             case 9: temp->setShortcuts(settingsCache->shortcuts().getShortcut("Player/phase9")); break;
             case 10:temp->setShortcuts(settingsCache->shortcuts().getShortcut("Player/phase10")); break;
-            default: ;
+            default: break;
         }
     }
 
-    if (aNextPhase) {
+    if (aNextPhase)
+    {
         aNextPhase->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aNextPhase"));
     }
-    if (aNextTurn) {
+
+    if (aNextTurn)
+    {
         aNextTurn->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aNextTurn"));
     }
-    if (aRemoveLocalArrows) {
+
+    if (aRemoveLocalArrows)
+    {
         aRemoveLocalArrows->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aRemoveLocalArrows"));
     }
-    if (aRotateViewCW) {
+
+    if (aRotateViewCW)
+    {
         aRotateViewCW->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aRotateViewCW"));
     }
-    if (aRotateViewCCW) {
+
+    if (aRotateViewCCW)
+    {
         aRotateViewCCW->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aRotateViewCCW"));
     }
-    if (aConcede) {
+
+    if (aConcede)
+    {
         aConcede->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aConcede"));
     }
-    if (aLeaveGame) {
+
+    if (aLeaveGame)
+    {
         aLeaveGame->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aLeaveGame"));
     }
-    if (aCloseReplay) {
+
+    if (aCloseReplay)
+    {
         aCloseReplay->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aCloseReplay"));
     }
-    if (aResetLayout) {
+
+    if (aResetLayout)
+    {
         aResetLayout->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aResetLayout"));
     }
 }
@@ -220,12 +238,15 @@ void DeckViewContainer::loadLocalDeck()
     dialog.setDirectory(settingsCache->getDeckPath());
     dialog.setNameFilters(DeckLoader::fileNameFilters);
     if (!dialog.exec())
+    {
         return;
+    }
 
     QString fileName = dialog.selectedFiles().at(0);
     DeckLoader::FileFormat fmt = DeckLoader::getFormatFromName(fileName);
     DeckLoader deck;
-    if (!deck.loadFromFile(fileName, fmt)) {
+    if (!deck.loadFromFile(fileName, fmt))
+    {
         QMessageBox::critical(this, tr("Error"), tr("The selected file could not be loaded."));
         return;
     }
@@ -240,7 +261,8 @@ void DeckViewContainer::loadLocalDeck()
 void DeckViewContainer::loadRemoteDeck()
 {
     DlgLoadRemoteDeck dlg(parentGame->getClientForPlayer(playerId));
-    if (dlg.exec()) {
+    if (dlg.exec())
+    {
         Command_DeckSelect cmd;
         cmd.set_deck_id(dlg.getDeckId());
         PendingCommand *pend = parentGame->prepareGameCommand(cmd);
@@ -276,8 +298,10 @@ void DeckViewContainer::sideboardPlanChanged()
 {
     Command_SetSideboardPlan cmd;
     const QList<MoveCard_ToZone> &newPlan = deckView->getSideboardPlan();
-    for (int i = 0; i < newPlan.size(); ++i)
-        cmd.add_move_list()->CopyFrom(newPlan.at(i));
+    for (const auto &i : newPlan)
+    {
+        cmd.add_move_list()->CopyFrom(i);
+    }
     parentGame->sendGameCommand(cmd, playerId);
 }
 
@@ -285,7 +309,7 @@ void DeckViewContainer::setReadyStart(bool ready)
 {
     readyStartButton->setState(ready);
     deckView->setLocked(ready || !sideboardLockButton->getState());
-    sideboardLockButton->setEnabled(!readyStartButton->getState());
+    sideboardLockButton->setEnabled(!readyStartButton->getState() && readyStartButton->isEnabled());
 }
 
 void DeckViewContainer::setSideboardLocked(bool locked)
@@ -293,7 +317,9 @@ void DeckViewContainer::setSideboardLocked(bool locked)
     sideboardLockButton->setState(!locked);
     deckView->setLocked(readyStartButton->getState() || !sideboardLockButton->getState());
     if (locked)
+    {
         deckView->resetSideboardPlan();
+    }
 }
 
 void DeckViewContainer::setDeck(const DeckLoader &deck)
@@ -314,12 +340,12 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, GameReplay *_replay)
           gameStateKnown(false),
           resuming(false),
           currentPhase(-1),
-          activeCard(0),
+          activeCard(nullptr),
           gameClosed(false),
           replay(_replay),
           currentReplayStep(0),
-          sayLabel(0),
-          sayEdit(0)
+          sayLabel(nullptr),
+          sayEdit(nullptr)
 {
     // THIS CTOR IS USED ON REPLAY
     gameInfo.CopyFrom(replay->game_info());
@@ -329,17 +355,25 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, GameReplay *_replay)
     // Distribute simultaneous events evenly across 1 second.
     unsigned int lastEventTimestamp = 0;
     const int eventCount = replay->event_list_size();
-    for (int i = 0; i < eventCount; ++i) {
+    for (int i = 0; i < eventCount; ++i)
+    {
         int j = i + 1;
         while ((j < eventCount) && (replay->event_list(j).seconds_elapsed() == lastEventTimestamp))
+        {
             ++j;
+        }
 
         const int numberEventsThisSecond = j - i;
         for (int k = 0; k < numberEventsThisSecond; ++k)
-            replayTimeline.append(replay->event_list(i + k).seconds_elapsed() * 1000 + (int) ((qreal) k / (qreal) numberEventsThisSecond * 1000));
+        {
+            replayTimeline.append(replay->event_list(i + k).seconds_elapsed() * 1000 + static_cast<int>((static_cast<qreal>(k) / static_cast<qreal>(numberEventsThisSecond) * 1000)));
+        }
 
         if (j < eventCount)
+        {
             lastEventTimestamp = replay->event_list(j).seconds_elapsed();
+        }
+
         i += numberEventsThisSecond - 1;
     }
 
@@ -383,10 +417,10 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_client
           gameStateKnown(false),
           resuming(event.resuming()),
           currentPhase(-1),
-          activeCard(0),
+          activeCard(nullptr),
           gameClosed(false),
-          replay(0),
-          replayDock(0)
+          replay(nullptr),
+          replayDock(nullptr)
 {
     // THIS CTOR IS USED ON GAMES
     gameInfo.set_started(false);
@@ -415,18 +449,22 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_client
 
     // append game to rooms game list for others to see
     for (int i = gameInfo.game_types_size() - 1; i >= 0; i--)
+    {
         gameTypes.append(roomGameTypes.find(gameInfo.game_types(i)).value());
+    }
 
     this->installEventFilter(this);
     QTimer::singleShot(0, this, SLOT(loadLayout()));
 }
 
-void TabGame::addMentionTag(QString value) {
+void TabGame::addMentionTag(QString value)
+{
     sayEdit->insert(value + " ");
     sayEdit->setFocus();
 }
 
-void TabGame::emitUserEvent() {
+void TabGame::emitUserEvent()
+{
     bool globalEvent = !spectator || settingsCache->getSpectatorNotificationsEnabled();
     emit userEvent(globalEvent);
     updatePlayerListDockTitle();
@@ -434,12 +472,13 @@ void TabGame::emitUserEvent() {
 
 TabGame::~TabGame()
 {
-    if(replay)
-        delete replay;
+    delete replay;
 
     QMapIterator<int, Player *> i(players);
     while (i.hasNext())
+    {
         delete i.next().value();
+    }
     players.clear();
 
     emit gameClosing(this);
@@ -459,43 +498,68 @@ void TabGame::retranslateUi()
     updatePlayerListDockTitle();
     cardInfoDock->setWindowTitle(tr("Card Info") + (cardInfoDock->isWindow() ? tabText : QString()));
     messageLayoutDock->setWindowTitle(tr("Messages") + (messageLayoutDock->isWindow() ? tabText : QString()));
-    if(replayDock)
+    if (replayDock)
+    {
         replayDock->setWindowTitle(tr("Replay Timeline") + (replayDock->isWindow() ? tabText : QString()));
+    }
 
-    if (phasesMenu) {
+    if (phasesMenu)
+    {
         for (int i = 0; i < phaseActions.size(); ++i)
+        {
             phaseActions[i]->setText(phasesToolbar->getLongPhaseName(i));
+        }
         phasesMenu->setTitle(tr("&Phases"));
     }
 
     gameMenu->setTitle(tr("&Game"));
-    if (aNextPhase) {
+    if (aNextPhase)
+    {
         aNextPhase->setText(tr("Next &phase"));
     }
-    if (aNextTurn) {
+
+    if (aNextTurn)
+    {
         aNextTurn->setText(tr("Next &turn"));
     }
-    if (aRemoveLocalArrows) {
+
+    if (aRemoveLocalArrows)
+    {
         aRemoveLocalArrows->setText(tr("&Remove all local arrows"));
     }
-    if (aRotateViewCW) {
+
+    if (aRotateViewCW)
+    {
         aRotateViewCW->setText(tr("Rotate View Cl&ockwise"));
     }
-    if (aRotateViewCCW) {
+
+    if (aRotateViewCCW)
+    {
         aRotateViewCCW->setText(tr("Rotate View Co&unterclockwise"));
     }
+
     if (aGameInfo)
+    {
         aGameInfo->setText(tr("Game &information"));
-    if (aConcede) {
+    }
+
+    if (aConcede)
+    {
         aConcede->setText(tr("&Concede"));
     }
-    if (aLeaveGame) {
+
+    if (aLeaveGame)
+    {
         aLeaveGame->setText(tr("&Leave game"));
     }
-    if (aCloseReplay) {
+
+    if (aCloseReplay)
+    {
         aCloseReplay->setText(tr("C&lose replay"));
     }
-    if (sayLabel){
+
+    if (sayLabel)
+    {
         sayLabel->setText(tr("&Say:"));
     }
 
@@ -513,7 +577,7 @@ void TabGame::retranslateUi()
     aPlayerListDockVisible->setText(tr("Visible"));
     aPlayerListDockFloating->setText(tr("Floating"));
 
-    if(replayDock)
+    if (replayDock)
     {
         replayDockMenu->setTitle(tr("Replay Timeline"));
         aReplayDockVisible->setText(tr("Visible"));
@@ -526,10 +590,15 @@ void TabGame::retranslateUi()
 
     QMapIterator<int, Player *> i(players);
     while (i.hasNext())
+    {
         i.next().value()->retranslateUi();
+    }
+
     QMapIterator<int, DeckViewContainer *> j(deckViewContainers);
     while (j.hasNext())
+    {
         j.next().value()->retranslateUi();
+    }
 
     scene->retranslateUi();
 }
@@ -541,7 +610,7 @@ void TabGame::closeRequest()
 
 void TabGame::replayNextEvent()
 {
-    processGameEventContainer(replay->event_list(timelineWidget->getCurrentEvent()), 0);
+    processGameEventContainer(replay->event_list(timelineWidget->getCurrentEvent()), nullptr);
 }
 
 void TabGame::replayFinished()
@@ -607,20 +676,29 @@ void TabGame::actGameInfo()
 void TabGame::actConcede()
 {
     if (QMessageBox::question(this, tr("Concede"), tr("Are you sure you want to concede this game?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes)
+    {
         return;
+    }
 
     sendGameCommand(Command_Concede());
 }
 
 void TabGame::actLeaveGame()
 {
-    if (!gameClosed) {
+    if (!gameClosed)
+    {
         if (!spectator)
-        if (QMessageBox::question(this, tr("Leave game"), tr("Are you sure you want to leave this game?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes)
-            return;
+        {
+            if (QMessageBox::question(this, tr("Leave game"), tr("Are you sure you want to leave this game?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes)
+            {
+                return;
+            }
 
-        if (!replay)
-            sendGameCommand(Command_LeaveGame());
+            if (!replay)
+            {
+                sendGameCommand(Command_LeaveGame());
+            }
+        }
     }
     scene->clearViews();
     deleteLater();
@@ -629,9 +707,12 @@ void TabGame::actLeaveGame()
 void TabGame::actSay()
 {
     if (completer->popup()->isVisible())
+    {
         return;
+    }
 
-    if (!sayEdit->text().isEmpty()) {
+    if (!sayEdit->text().isEmpty())
+    {
         Command_GameSay cmd;
         cmd.set_message(sayEdit->text().toStdString());
         sendGameCommand(cmd);
@@ -641,9 +722,9 @@ void TabGame::actSay()
 
 void TabGame::actPhaseAction()
 {
-    int phase = phaseActions.indexOf(static_cast<QAction *>(sender()));
+    int phase = phaseActions.indexOf(dynamic_cast<QAction *>(sender()));
     Command_SetActivePhase cmd;
-    cmd.set_phase(phase);
+    cmd.set_phase(static_cast<google::protobuf::uint32>(phase));
     sendGameCommand(cmd);
 }
 
@@ -651,9 +732,12 @@ void TabGame::actNextPhase()
 {
     int phase = currentPhase;
     if (++phase >= phasesToolbar->phaseCount())
+    {
         phase = 0;
+    }
+
     Command_SetActivePhase cmd;
-    cmd.set_phase(phase);
+    cmd.set_phase(static_cast<google::protobuf::uint32>(phase));
     sendGameCommand(cmd);
 }
 
@@ -665,12 +749,17 @@ void TabGame::actNextTurn()
 void TabGame::actRemoveLocalArrows()
 {
     QMapIterator<int, Player *> playerIterator(players);
-    while (playerIterator.hasNext()) {
+    while (playerIterator.hasNext())
+    {
         Player *player = playerIterator.next().value();
         if (!player->getLocal())
+        {
             continue;
+        }
+
         QMapIterator<int, ArrowItem *> arrowIterator(player->getArrows());
-        while (arrowIterator.hasNext()) {
+        while (arrowIterator.hasNext())
+        {
             ArrowItem *a = arrowIterator.next().value();
             Command_DeleteArrow cmd;
             cmd.set_arrow_id(a->getId());
@@ -697,10 +786,12 @@ void TabGame::actCompleterChanged()
 Player *TabGame::addPlayer(int playerId, const ServerInfo_User &info)
 {
     bool local = ((clients.size() > 1) || (playerId == localPlayerId));
-    Player *newPlayer = new Player(info, playerId, local, this);
+    auto *newPlayer = new Player(info, playerId, local, this);
     connect(newPlayer, SIGNAL(openDeckEditor(const DeckLoader *)), this, SIGNAL(openDeckEditor(const DeckLoader *)));
     QString newPlayerName = "@" + newPlayer->getName();
-    if (sayEdit && !autocompleteUserList.contains(newPlayerName)){
+
+    if (sayEdit && !autocompleteUserList.contains(newPlayerName))
+    {
         autocompleteUserList << newPlayerName;
         sayEdit->setCompletionList(autocompleteUserList);
     }
@@ -709,11 +800,14 @@ Player *TabGame::addPlayer(int playerId, const ServerInfo_User &info)
     connect(newPlayer, SIGNAL(newCardAdded(AbstractCardItem *)), this, SLOT(newCardAdded(AbstractCardItem *)));
     messageLog->connectToPlayer(newPlayer);
 
-    if (local && !spectator) {
+    if (local && !spectator)
+    {
         if (clients.size() == 1)
+        {
             newPlayer->setShortcutsActive();
+        }
 
-        DeckViewContainer *deckView = new DeckViewContainer(playerId, this);
+        auto *deckView = new DeckViewContainer(playerId, this);
         connect(deckView, SIGNAL(newCardAdded(AbstractCardItem *)), this, SLOT(newCardAdded(AbstractCardItem *)));
         deckViewContainers.insert(playerId, deckView);
         deckViewContainerLayout->addWidget(deckView);
@@ -731,25 +825,37 @@ void TabGame::processGameEventContainer(const GameEventContainer &cont, Abstract
     const GameEventContext &context = cont.context();
     messageLog->containerProcessingStarted(context);
     const int eventListSize = cont.event_list_size();
-    for (int i = 0; i < eventListSize; ++i) {
+    for (int i = 0; i < eventListSize; ++i)
+    {
         const GameEvent &event = cont.event_list(i);
         const int playerId = event.player_id();
-        const GameEvent::GameEventType eventType = static_cast<GameEvent::GameEventType>(getPbExtension(event));
-        if (spectators.contains(playerId)) {
-            switch (eventType) {
+        const auto eventType = static_cast<GameEvent::GameEventType>(getPbExtension(event));
+
+        if (spectators.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: {
+                default:
+                {
                     qDebug() << "unhandled spectator game event" << eventType;
                     break;
                 }
             }
-        } else {
+        }
+        else
+        {
             if ((clients.size() > 1) && (playerId != -1))
-            if (clients.at(playerId) != client)
-                continue;
+            {
+                if (clients.at(playerId) != client)
+                {
+                    continue;
+                }
+            }
 
-            switch (eventType) {
+            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;
@@ -759,16 +865,38 @@ void TabGame::processGameEventContainer(const GameEventContainer &cont, Abstract
                 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;
-
-                default: {
+                default:
+                {
                     Player *player = players.value(playerId, 0);
-                    if (!player) {
+                    if (!player)
+                    {
                         qDebug() << "unhandled game event: invalid player id";
                         break;
                     }
                     player->processGameEvent(eventType, event, context);
                     emitUserEvent();
+                    break;
                 }
+                case GameEvent_GameEventType_GAME_SAY:break;
+                case GameEvent_GameEventType_CREATE_ARROW:break;
+                case GameEvent_GameEventType_DELETE_ARROW:break;
+                case GameEvent_GameEventType_CREATE_COUNTER:break;
+                case GameEvent_GameEventType_SET_COUNTER:break;
+                case GameEvent_GameEventType_DEL_COUNTER:break;
+                case GameEvent_GameEventType_DRAW_CARDS:break;
+                case GameEvent_GameEventType_REVEAL_CARDS:break;
+                case GameEvent_GameEventType_SHUFFLE:break;
+                case GameEvent_GameEventType_ROLL_DIE:break;
+                case GameEvent_GameEventType_MOVE_CARD:break;
+                case GameEvent_GameEventType_FLIP_CARD:break;
+                case GameEvent_GameEventType_DESTROY_CARD:break;
+                case GameEvent_GameEventType_ATTACH_CARD:break;
+                case GameEvent_GameEventType_CREATE_TOKEN:break;
+                case GameEvent_GameEventType_SET_CARD_ATTR:break;
+                case GameEvent_GameEventType_SET_CARD_COUNTER:break;
+                case GameEvent_GameEventType_DUMP_ZONE:break;
+                case GameEvent_GameEventType_STOP_DUMP_ZONE:break;
+                case GameEvent_GameEventType_CHANGE_ZONE_PROPERTIES:break;
             }
         }
     }
@@ -777,22 +905,32 @@ void TabGame::processGameEventContainer(const GameEventContainer &cont, Abstract
 
 AbstractClient *TabGame::getClientForPlayer(int playerId) const
 {
-    if (clients.size() > 1) {
+    if (clients.size() > 1)
+    {
         if (playerId == -1)
+        {
             playerId = getActiveLocalPlayer()->getId();
+        }
 
         return clients.at(playerId);
-    } else if (clients.isEmpty())
-        return 0;
+    }
+    else if (clients.isEmpty())
+    {
+        return nullptr;
+    }
     else
+    {
         return clients.first();
+    }
 }
 
 void TabGame::sendGameCommand(PendingCommand *pend, int playerId)
 {
     AbstractClient *client = getClientForPlayer(playerId);
-    if (!client)
+    if (client == nullptr)
+    {
         return;
+    }
 
     connect(pend, SIGNAL(finished(Response, CommandContainer, QVariant)), this, SLOT(commandFinished(const Response &)));
     client->sendCommand(pend);
@@ -801,8 +939,10 @@ void TabGame::sendGameCommand(PendingCommand *pend, int playerId)
 void TabGame::sendGameCommand(const google::protobuf::Message &command, int playerId)
 {
     AbstractClient *client = getClientForPlayer(playerId);
-    if (!client)
+    if (client == nullptr)
+    {
         return;
+    }
 
     PendingCommand *pend = prepareGameCommand(command);
     connect(pend, SIGNAL(finished(Response, CommandContainer, QVariant)), this, SLOT(commandFinished(const Response &)));
@@ -812,13 +952,15 @@ void TabGame::sendGameCommand(const google::protobuf::Message &command, int play
 void TabGame::commandFinished(const Response &response)
 {
     if (response.response_code() == Response::RespChatFlood)
+    {
         messageLog->appendMessage(tr("You are flooding the game. Please wait a couple of seconds."));
+    }
 }
 
 PendingCommand *TabGame::prepareGameCommand(const ::google::protobuf::Message &cmd)
 {
     CommandContainer cont;
-    cont.set_game_id(gameInfo.game_id());
+    cont.set_game_id(static_cast<google::protobuf::uint32>(gameInfo.game_id()));
     GameCommand *c = cont.add_game_command();
     c->GetReflection()->MutableMessage(c, cmd.GetDescriptor()->FindExtensionByName("ext"))->CopyFrom(cmd);
     return new PendingCommand(cont);
@@ -827,11 +969,13 @@ PendingCommand *TabGame::prepareGameCommand(const ::google::protobuf::Message &c
 PendingCommand *TabGame::prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList)
 {
     CommandContainer cont;
-    cont.set_game_id(gameInfo.game_id());
-    for (int i = 0; i < cmdList.size(); ++i) {
+    cont.set_game_id(static_cast<google::protobuf::uint32>(gameInfo.game_id()));
+
+    for (auto i : cmdList)
+    {
         GameCommand *c = cont.add_game_command();
-        c->GetReflection()->MutableMessage(c, cmdList[i]->GetDescriptor()->FindExtensionByName("ext"))->CopyFrom(*cmdList[i]);
-        delete cmdList[i];
+        c->GetReflection()->MutableMessage(c, i->GetDescriptor()->FindExtensionByName("ext"))->CopyFrom(*i);
+        delete i;
     }
     return new PendingCommand(cont);
 }
@@ -841,25 +985,35 @@ void TabGame::startGame(bool resuming)
     currentPhase = -1;
 
     QMapIterator<int, DeckViewContainer *> i(deckViewContainers);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
-        i.value()->setReadyStart(false);
-        i.value()->hide();
+        if (i.value())
+        {
+            i.value()->setReadyStart(false);
+            i.value()->hide();
+        }
     }
 
     mainWidget->setCurrentWidget(gamePlayAreaWidget);
 
-    if (!resuming) {
+    if (!resuming)
+    {
         QMapIterator<int, Player *> playerIterator(players);
         while (playerIterator.hasNext())
+        {
             playerIterator.next().value()->setGameStarted();
+        }
     }
 
     playerListWidget->setGameStarted(true, resuming);
     gameInfo.set_started(true);
-    static_cast<GameScene *>(gameView->scene())->rearrange();
-    if(sayEdit && players.size() > 1)
+    dynamic_cast<GameScene *>(gameView->scene())->rearrange();
+
+    if (sayEdit && players.size() > 1)
+    {
         sayEdit->setFocus();
+    }
 }
 
 void TabGame::stopGame()
@@ -868,9 +1022,13 @@ void TabGame::stopGame()
     activePlayer = -1;
 
     QMapIterator<int, DeckViewContainer *> i(deckViewContainers);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
-        i.value()->show();
+        if (i.value())
+        {
+            i.value()->show();
+        }
     }
 
     mainWidget->setCurrentWidget(deckViewContainerWidget);
@@ -899,7 +1057,10 @@ void TabGame::eventSpectatorLeave(const Event_Leave & event, int eventPlayerId,
 {
     QString playerName = "@" + QString::fromStdString(spectators.value(eventPlayerId).name());
     if (sayEdit && autocompleteUserList.removeOne(playerName))
+    {
         sayEdit->setCompletionList(autocompleteUserList);
+    }
+
     messageLog->logLeaveSpectator(QString::fromStdString(spectators.value(eventPlayerId).name()), getLeaveReason(event.reason()));
     playerListWidget->removePlayer(eventPlayerId);
     spectators.remove(eventPlayerId);
@@ -910,30 +1071,42 @@ void TabGame::eventSpectatorLeave(const Event_Leave & event, int eventPlayerId,
 void TabGame::eventGameStateChanged(const Event_GameStateChanged &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
     const int playerListSize = event.player_list_size();
-    for (int i = 0; i < playerListSize; ++i) {
+    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());
-        if (sayEdit && !autocompleteUserList.contains(playerName)){
+
+        if (sayEdit && !autocompleteUserList.contains(playerName))
+        {
             autocompleteUserList << playerName;
             sayEdit->setCompletionList(autocompleteUserList);
         }
-        if (prop.spectator()) {
-            if (!spectators.contains(playerId)) {
+
+        if (prop.spectator())
+        {
+            if (!spectators.contains(playerId))
+            {
                 spectators.insert(playerId, prop.user_info());
                 playerListWidget->addPlayer(prop);
             }
-        } else {
+        }
+        else
+        {
             Player *player = players.value(playerId, 0);
-            if (!player) {
+            if (!player)
+            {
                 player = addPlayer(playerId, prop.user_info());
                 playerListWidget->addPlayer(prop);
             }
             player->processPlayerInfo(playerInfo);
-            if (player->getLocal()) {
+
+            if (player->getLocal())
+            {
                 DeckViewContainer *deckViewContainer = deckViewContainers.value(playerId);
-                if (playerInfo.has_deck_list()) {
+                if (playerInfo.has_deck_list())
+                {
                     DeckLoader newDeck(QString::fromStdString(playerInfo.deck_list()));
                     PictureLoader::cacheCardPixmaps(db->getCards(newDeck.getCardList()));
                     deckViewContainer->setDeck(newDeck);
@@ -944,29 +1117,42 @@ void TabGame::eventGameStateChanged(const Event_GameStateChanged &event, int /*e
             }
         }
     }
-    for (int i = 0; i < playerListSize; ++i) {
+
+    for (int i = 0; i < playerListSize; ++i)
+    {
         const ServerInfo_Player &playerInfo = event.player_list(i);
         const ServerInfo_PlayerProperties &prop = playerInfo.properties();
-        if (!prop.spectator()) {
+        if (!prop.spectator())
+        {
             Player *player = players.value(prop.player_id(), 0);
-            if (!player)
+            if (player == nullptr)
+            {
                 continue;
+            }
+
             player->processCardAttachment(playerInfo);
         }
     }
 
     secondsElapsed = event.seconds_elapsed();
 
-    if (event.game_started() && !gameInfo.started()) {
+    if (event.game_started() && !gameInfo.started())
+    {
         startGame(!gameStateKnown);
         if (gameStateKnown)
+        {
             messageLog->logGameStart();
+        }
+
         setActivePlayer(event.active_player_id());
         setActivePhase(event.active_phase());
-    } else if (!event.game_started() && gameInfo.started()) {
+    }
+    else if (!event.game_started() && gameInfo.started())
+    {
         stopGame();
         scene->clearViews();
     }
+
     gameStateKnown = true;
     emitUserEvent();
 }
@@ -974,51 +1160,71 @@ void TabGame::eventGameStateChanged(const Event_GameStateChanged &event, int /*e
 void TabGame::eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event, int eventPlayerId, const GameEventContext &context)
 {
     Player *player = players.value(eventPlayerId, 0);
-    if (!player)
+    if (player == nullptr)
+    {
         return;
+    }
+
     const ServerInfo_PlayerProperties &prop = event.player_properties();
     playerListWidget->updatePlayerProperties(prop, eventPlayerId);
 
-    const GameEventContext::ContextType contextType = static_cast<const GameEventContext::ContextType>(getPbExtension(context));
-    switch (contextType) {
-        case GameEventContext::READY_START: {
+    const auto contextType = static_cast<const GameEventContext::ContextType>(getPbExtension(context));
+    switch (contextType)
+    {
+        case GameEventContext::READY_START:
+        {
             bool ready = prop.ready_start();
             if (player->getLocal())
+            {
                 deckViewContainers.value(player->getId())->setReadyStart(ready);
+            }
+
             if (ready)
+            {
                 messageLog->logReadyStart(player);
+            }
             else
+            {
                 messageLog->logNotReadyStart(player);
+            }
+
             break;
         }
-        case GameEventContext::CONCEDE: {
+        case GameEventContext::CONCEDE:
+        {
             messageLog->logConcede(player);
             player->setConceded(true);
 
             QMapIterator<int, Player *> playerIterator(players);
             while (playerIterator.hasNext())
+            {
                 playerIterator.next().value()->updateZones();
+            }
 
             break;
         }
-        case GameEventContext::DECK_SELECT: {
+        case GameEventContext::DECK_SELECT:
+        {
             Context_DeckSelect deckSelect = context.GetExtension(Context_DeckSelect::ext);
-            messageLog->logDeckSelect(player,
-                                      QString::fromStdString(deckSelect.deck_hash()),
-                                      deckSelect.sideboard_size());
+            messageLog->logDeckSelect(player, QString::fromStdString(deckSelect.deck_hash()), deckSelect.sideboard_size());
             break;
         }
-        case GameEventContext::SET_SIDEBOARD_LOCK: {
+        case GameEventContext::SET_SIDEBOARD_LOCK:
+        {
             if (player->getLocal())
+            {
                 deckViewContainers.value(player->getId())->setSideboardLocked(prop.sideboard_locked());
+            }
+
             messageLog->logSetSideboardLock(player, prop.sideboard_locked());
             break;
         }
-        case GameEventContext::CONNECTION_STATE_CHANGED: {
+        case GameEventContext::CONNECTION_STATE_CHANGED:
+        {
             messageLog->logConnectionStateChanged(player, prop.ping_seconds() != -1);
             break;
         }
-        default: ;
+        default: break;
     }
 }
 
@@ -1027,21 +1233,28 @@ void TabGame::eventJoin(const Event_Join &event, int /*eventPlayerId*/, const Ga
     const ServerInfo_PlayerProperties &playerInfo = event.player_properties();
     const int playerId = playerInfo.player_id();
     QString playerName = QString::fromStdString(playerInfo.user_info().name());
-    if (sayEdit && !autocompleteUserList.contains("@" + playerName)){
+    if (sayEdit && !autocompleteUserList.contains("@" + playerName))
+    {
         autocompleteUserList << "@" + playerName;
         sayEdit->setCompletionList(autocompleteUserList);
     }
 
     if (players.contains(playerId))
+    {
         return;
+    }
 
-    if (playerInfo.spectator()) {
+    if (playerInfo.spectator())
+    {
         spectators.insert(playerId, playerInfo.user_info());
         messageLog->logJoinSpectator(playerName);
-    } else {
+    }
+    else
+    {
         Player *newPlayer = addPlayer(playerId, playerInfo.user_info());
         messageLog->logJoin(newPlayer);
     }
+
     playerListWidget->addPlayer(playerInfo);
     emitUserEvent();
 }
@@ -1068,12 +1281,16 @@ QString TabGame::getLeaveReason(Event_Leave::LeaveReason reason)
 void TabGame::eventLeave(const Event_Leave & event, int eventPlayerId, const GameEventContext & /*context*/)
 {
     Player *player = players.value(eventPlayerId, 0);
-    if (!player)
+    if (player == nullptr)
+    {
         return;
+    }
 
     QString playerName = "@" + player->getName();
-    if(sayEdit && autocompleteUserList.removeOne(playerName))
+    if (sayEdit && autocompleteUserList.removeOne(playerName))
+    {
         sayEdit->setCompletionList(autocompleteUserList);
+    }
 
     messageLog->logLeave(player, getLeaveReason(event.reason()));
     playerListWidget->removePlayer(eventPlayerId);
@@ -1085,7 +1302,9 @@ void TabGame::eventLeave(const Event_Leave & event, int eventPlayerId, const Gam
     // Rearrange all remaining zones so that attachment relationship updates take place
     QMapIterator<int, Player *> playerIterator(players);
     while (playerIterator.hasNext())
+    {
         playerIterator.next().value()->updateZones();
+    }
 
     emitUserEvent();
 }
@@ -1120,23 +1339,34 @@ void TabGame::eventGameClosed(const Event_GameClosed & /*event*/, int /*eventPla
 Player *TabGame::setActivePlayer(int id)
 {
     Player *player = players.value(id, 0);
-    if (!player)
-        return 0;
+    if (player == nullptr)
+    {
+        return nullptr;
+    }
     activePlayer = id;
     playerListWidget->setActivePlayer(id);
     QMapIterator<int, Player *> i(players);
-    while (i.hasNext()) {
+    while (i.hasNext())
+    {
         i.next();
-        if (i.value() == player) {
+        if (i.value() == player)
+        {
             i.value()->setActive(true);
             if (clients.size() > 1)
+            {
                 i.value()->setShortcutsActive();
-        } else {
+            }
+        }
+        else
+        {
             i.value()->setActive(false);
             if (clients.size() > 1)
+            {
                 i.value()->setShortcutsInactive();
+            }
         }
     }
+
     currentPhase = -1;
     emitUserEvent();
     return player;
@@ -1145,15 +1375,19 @@ Player *TabGame::setActivePlayer(int id)
 void TabGame::eventSetActivePlayer(const Event_SetActivePlayer &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
     Player *player = setActivePlayer(event.active_player_id());
-    if (!player)
+    if (player == nullptr)
+    {
         return;
+    }
+
     messageLog->logSetActivePlayer(player);
     emitUserEvent();
 }
 
 void TabGame::setActivePhase(int phase)
 {
-    if (currentPhase != phase) {
+    if (currentPhase != phase)
+    {
         currentPhase = phase;
         phasesToolbar->setActivePhase(phase);
     }
@@ -1163,7 +1397,10 @@ void TabGame::eventSetActivePhase(const Event_SetActivePhase &event, int /*event
 {
     const int phase = event.phase();
     if (currentPhase != phase)
+    {
         messageLog->logSetActivePhase(phase);
+    }
+
     setActivePhase(phase);
     emitUserEvent();
 }
@@ -1179,12 +1416,16 @@ void TabGame::newCardAdded(AbstractCardItem *card)
 CardItem *TabGame::getCard(int playerId, const QString &zoneName, int cardId) const
 {
     Player *player = players.value(playerId, 0);
-    if (!player)
-        return 0;
+    if (player == nullptr)
+    {
+        return nullptr;
+    }
 
     CardZone *zone = player->getZones().value(zoneName, 0);
-    if (!zone)
-        return 0;
+    if (zone == nullptr)
+    {
+        return nullptr;
+    }
 
     return zone->getCard(cardId, QString());
 }
@@ -1192,10 +1433,13 @@ CardItem *TabGame::getCard(int playerId, const QString &zoneName, int cardId) co
 QString TabGame::getTabText() const
 {
     QString gameTypeInfo;
-    if (gameTypes.size() != 0) {
+    if (!gameTypes.empty())
+    {
         gameTypeInfo = gameTypes.at(0);
         if (gameTypes.size() > 1)
+        {
             gameTypeInfo.append("...");
+        }
     }
 
     QString gameDesc(gameInfo.description().c_str());
@@ -1203,17 +1447,32 @@ QString TabGame::getTabText() const
 
     QString tabText;
     if (replay)
+    {
         tabText.append(tr("Replay") + " ");
-    if (!gameTypeInfo.isEmpty())
-        tabText.append(gameTypeInfo + " ");
-    if (!gameDesc.isEmpty()) {
-        if (gameDesc.length() >= 15)
-            tabText.append("| " + gameDesc.left(15) + "... ");
-        else
-            tabText.append("| " + gameDesc + " ");
     }
+
+    if (!gameTypeInfo.isEmpty())
+    {
+        tabText.append(gameTypeInfo + " ");
+    }
+
+    if (!gameDesc.isEmpty())
+    {
+        if (gameDesc.length() >= 15)
+        {
+            tabText.append("| " + gameDesc.left(15) + "... ");
+        }
+        else
+        {
+            tabText.append("| " + gameDesc + " ");
+        }
+    }
+
     if (!tabText.isEmpty())
+    {
         tabText.append("| ");
+    }
+
     tabText.append("#" + gameId);
 
     return tabText;
@@ -1222,28 +1481,37 @@ QString TabGame::getTabText() const
 Player *TabGame::getActiveLocalPlayer() const
 {
     Player *active = players.value(activePlayer, 0);
-    if (active)
-    if (active->getLocal())
+    if (active && active->getLocal())
+    {
         return active;
-
-    QMapIterator<int, Player *> playerIterator(players);
-    while (playerIterator.hasNext()) {
-        Player *temp = playerIterator.next().value();
-        if (temp->getLocal())
-            return temp;
     }
 
-    return 0;
+    QMapIterator<int, Player *> playerIterator(players);
+    while (playerIterator.hasNext())
+    {
+        Player *temp = playerIterator.next().value();
+        if (temp->getLocal())
+        {
+            return temp;
+        }
+    }
+
+    return nullptr;
 }
 
 void TabGame::updateCardMenu(AbstractCardItem *card)
 {
     Player *p;
     if ((clients.size() > 1) || !players.contains(localPlayerId))
+    {
         p = card->getOwner();
+    }
     else
+    {
         p = players.value(localPlayerId);
-    p->updateCardMenu(static_cast<CardItem *>(card));
+    }
+
+    p->updateCardMenu(dynamic_cast<CardItem *>(card));
 }
 
 void TabGame::createMenuItems()
@@ -1264,10 +1532,11 @@ void TabGame::createMenuItems()
     connect(aConcede, SIGNAL(triggered()), this, SLOT(actConcede()));
     aLeaveGame = new QAction(this);
     connect(aLeaveGame, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
-    aCloseReplay = 0;
+    aCloseReplay = nullptr;
 
     phasesMenu = new QMenu(this);
-    for (int i = 0; i < phasesToolbar->phaseCount(); ++i) {
+    for (int i = 0; i < phasesToolbar->phaseCount(); ++i)
+    {
         QAction *temp = new QAction(QString(), this);
         connect(temp, SIGNAL(triggered()), this, SLOT(actPhaseAction()));
         phasesMenu->addAction(temp);
@@ -1294,19 +1563,19 @@ void TabGame::createMenuItems()
 
 void TabGame::createReplayMenuItems()
 {
-    aNextPhase = 0;
-    aNextTurn = 0;
-    aRemoveLocalArrows = 0;
-    aRotateViewCW = 0;
-    aRotateViewCCW = 0;
-    aResetLayout = 0;
-    aGameInfo = 0;
-    aConcede = 0;
-    aLeaveGame = 0;
+    aNextPhase = nullptr;
+    aNextTurn = nullptr;
+    aRemoveLocalArrows = nullptr;
+    aRotateViewCW = nullptr;
+    aRotateViewCCW = nullptr;
+    aResetLayout = nullptr;
+    aGameInfo = nullptr;
+    aConcede = nullptr;
+    aLeaveGame = nullptr;
     aCloseReplay = new QAction(this);
     connect(aCloseReplay, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
 
-    phasesMenu = 0;
+    phasesMenu = nullptr;
     gameMenu = new QMenu(this);
     gameMenu->addAction(aCloseReplay);
     addTabMenu(gameMenu);
@@ -1341,7 +1610,7 @@ void TabGame::createViewMenuItems()
     aPlayerListDockFloating->setCheckable(true);
     connect(aPlayerListDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
 
-    if(replayDock)
+    if (replayDock)
     {
         replayDockMenu = viewMenu->addMenu(QString());
 
@@ -1364,7 +1633,7 @@ void TabGame::createViewMenuItems()
 
 void TabGame::loadLayout()
 {
-    if(replayDock)
+    if (replayDock)
     {
         restoreGeometry(settingsCache->layouts().getReplayPlayAreaGeometry());
         restoreState(settingsCache->layouts().getReplayPlayAreaLayoutState());
@@ -1377,7 +1646,9 @@ void TabGame::loadLayout()
         playerListDock->setMaximumSize(settingsCache->layouts().getReplayPlayerListSize());
         replayDock->setMinimumSize(settingsCache->layouts().getReplayReplaySize());
         replayDock->setMaximumSize(settingsCache->layouts().getReplayReplaySize());
-    } else {
+    }
+    else
+    {
         restoreGeometry(settingsCache->layouts().getGamePlayAreaGeometry());
         restoreState(settingsCache->layouts().getGamePlayAreaLayoutState());
 
@@ -1401,7 +1672,7 @@ void TabGame::loadLayout()
     aMessageLayoutDockFloating->setChecked(messageLayoutDock->isFloating());
     aPlayerListDockFloating->setChecked(playerListDock->isFloating());
 
-    if(replayDock)
+    if (replayDock)
     {
         aReplayDockVisible->setChecked(replayDock->isVisible());
         aReplayDockFloating->setEnabled(aReplayDockVisible->isChecked());
@@ -1422,7 +1693,7 @@ void TabGame::freeDocksSize()
     playerListDock->setMinimumSize(100,100);
     playerListDock->setMaximumSize(5000,5000);
 
-    if(replayDock)
+    if (replayDock)
     {
         replayDock->setMinimumSize(100,100);
         replayDock->setMaximumSize(5000,5000);
@@ -1451,7 +1722,7 @@ void TabGame::actResetLayout()
     addDockWidget(Qt::RightDockWidgetArea, playerListDock);
     addDockWidget(Qt::RightDockWidgetArea, messageLayoutDock);
 
-    if(replayDock)
+    if (replayDock)
     {
         replayDock->setVisible(true);
         replayDock->setFloating(false);
@@ -1467,7 +1738,9 @@ void TabGame::actResetLayout()
         playerListDock->setMaximumSize(250,50);
         replayDock->setMinimumSize(900,100);
         replayDock->setMaximumSize(900,100);
-    } else {
+    }
+    else
+    {
         cardInfoDock->setMinimumSize(250,360);
         cardInfoDock->setMaximumSize(250,360);
         messageLayoutDock->setMinimumSize(250,250);
@@ -1482,8 +1755,11 @@ void TabGame::actResetLayout()
 void TabGame::createPlayAreaWidget(bool bReplay)
 {
     phasesToolbar = new PhasesToolbar;
-    if(!bReplay)
+    if (!bReplay)
+    {
         connect(phasesToolbar, SIGNAL(sendGameCommand(const ::google::protobuf::Message &, int)), this, SLOT(sendGameCommand(const ::google::protobuf::Message &, int)));
+    }
+
     scene = new GameScene(phasesToolbar, this);
     gameView = new GameView(scene);
 
@@ -1576,13 +1852,16 @@ void TabGame::createCardInfoDock(bool bReplay)
 
 void TabGame::createPlayerListDock(bool bReplay)
 {
-    if(bReplay)
+    if (bReplay)
+    {
+        playerListWidget = new PlayerListWidget(nullptr, nullptr, this);
+    }
+    else
     {
-        playerListWidget = new PlayerListWidget(0, 0, this);
-    } else {
         playerListWidget = new PlayerListWidget(tabSupervisor, clients.first(), this);
         connect(playerListWidget, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
     }
+
     playerListWidget->setFocusPolicy(Qt::NoFocus);
 
     playerListDock = new QDockWidget(this);
@@ -1602,7 +1881,7 @@ void TabGame::createMessageDock(bool bReplay)
     connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString)));
     connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString)));
 
-    if(!bReplay)
+    if (!bReplay)
     {
         connect(messageLog, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
         connect(messageLog, SIGNAL(addMentionTag(QString)), this, SLOT(addMentionTag(QString)));
@@ -1626,10 +1905,12 @@ void TabGame::createMessageDock(bool bReplay)
         sayEdit->setCompleter(completer);
         actCompleterChanged();
 
-        if (spectator && !gameInfo.spectators_can_chat() && tabSupervisor->getAdminLocked()) {
+        if (spectator && !gameInfo.spectators_can_chat() && tabSupervisor->getAdminLocked())
+        {
             sayLabel->hide();
             sayEdit->hide();
         }
+
         connect(tabSupervisor, SIGNAL(adminLockChanged(bool)), this, SLOT(adminLockChanged(bool)));
         connect(sayEdit, SIGNAL(returnPressed()), this, SLOT(actSay()));
 
@@ -1641,11 +1922,17 @@ void TabGame::createMessageDock(bool bReplay)
 
     messageLogLayout = new QVBoxLayout;
     messageLogLayout->setContentsMargins(0, 0, 0, 0);
-    if(!bReplay)
+    if (!bReplay)
+    {
         messageLogLayout->addWidget(timeElapsedLabel);
+    }
+
     messageLogLayout->addWidget(messageLog);
-    if(!bReplay)
+
+    if (!bReplay)
+    {
         messageLogLayout->addLayout(sayHLayout);
+    }
 
     messageLogLayoutWidget = new QWidget;
     messageLogLayoutWidget->setLayout(messageLogLayout);
@@ -1663,26 +1950,33 @@ void TabGame::createMessageDock(bool bReplay)
 // Method uses to sync docks state with menu items state
 bool TabGame::eventFilter(QObject * o, QEvent * e)
 {
-    if(e->type() == QEvent::Close)
+    if (e->type() == QEvent::Close)
     {
-        if(o == cardInfoDock)
+        if (o == cardInfoDock)
         {
             aCardInfoDockVisible->setChecked(false);
             aCardInfoDockFloating->setEnabled(false);
-        } else if(o == messageLayoutDock) {
+        }
+        else if (o == messageLayoutDock)
+        {
             aMessageLayoutDockVisible->setChecked(false);
             aMessageLayoutDockFloating->setEnabled(false);
-        } else if(o == playerListDock) {
+        }
+        else if(o == playerListDock)
+        {
             aPlayerListDockVisible->setChecked(false);
             aPlayerListDockFloating->setEnabled(false);
-        } else if(o == replayDock) {
+        }
+        else if(o == replayDock)
+        {
             aReplayDockVisible->setChecked(false);
             aReplayDockFloating->setEnabled(false);
         }
     }
 
-    if( o == this && e->type() == QEvent::Hide){
-        if(replay)
+    if (o == this && e->type() == QEvent::Hide)
+    {
+        if (replay)
         {
             settingsCache->layouts().setReplayPlayAreaState(saveState());
             settingsCache->layouts().setReplayPlayAreaGeometry(saveGeometry());
@@ -1690,7 +1984,9 @@ bool TabGame::eventFilter(QObject * o, QEvent * e)
             settingsCache->layouts().setReplayMessageLayoutSize(messageLayoutDock->size());
             settingsCache->layouts().setReplayPlayerListSize(playerListDock->size());
             settingsCache->layouts().setReplayReplaySize(replayDock->size());
-        } else {
+        }
+        else
+        {
             settingsCache->layouts().setGamePlayAreaState(saveState());
             settingsCache->layouts().setGamePlayAreaGeometry(saveGeometry());
             settingsCache->layouts().setGameCardInfoSize(cardInfoDock->size());
@@ -1704,28 +2000,28 @@ bool TabGame::eventFilter(QObject * o, QEvent * e)
 void TabGame::dockVisibleTriggered()
 {
     QObject *o = sender();
-    if(o == aCardInfoDockVisible)
+    if (o == aCardInfoDockVisible)
     {
         cardInfoDock->setVisible(aCardInfoDockVisible->isChecked());
         aCardInfoDockFloating->setEnabled(aCardInfoDockVisible->isChecked());
         return;
     }
 
-    if(o == aMessageLayoutDockVisible)
+    if (o == aMessageLayoutDockVisible)
     {
         messageLayoutDock->setVisible(aMessageLayoutDockVisible->isChecked());
         aMessageLayoutDockFloating->setEnabled(aMessageLayoutDockVisible->isChecked());
         return;
     }
 
-    if(o == aPlayerListDockVisible)
+    if (o == aPlayerListDockVisible)
     {
         playerListDock->setVisible(aPlayerListDockVisible->isChecked());
         aPlayerListDockFloating->setEnabled(aPlayerListDockVisible->isChecked());
         return;
     }
 
-    if(o == aReplayDockVisible)
+    if (o == aReplayDockVisible)
     {
         replayDock->setVisible(aReplayDockVisible->isChecked());
         aReplayDockFloating->setEnabled(aReplayDockVisible->isChecked());
@@ -1736,25 +2032,25 @@ void TabGame::dockVisibleTriggered()
 void TabGame::dockFloatingTriggered()
 {
     QObject *o = sender();
-    if(o == aCardInfoDockFloating)
+    if (o == aCardInfoDockFloating)
     {
         cardInfoDock->setFloating(aCardInfoDockFloating->isChecked());
         return;
     }
 
-    if(o == aMessageLayoutDockFloating)
+    if (o == aMessageLayoutDockFloating)
     {
         messageLayoutDock->setFloating(aMessageLayoutDockFloating->isChecked());
         return;
     }
 
-    if(o == aPlayerListDockFloating)
+    if (o == aPlayerListDockFloating)
     {
         playerListDock->setFloating(aPlayerListDockFloating->isChecked());
         return;
     }
 
-    if(o == aReplayDockFloating)
+    if (o == aReplayDockFloating)
     {
         replayDock->setFloating(aReplayDockFloating->isChecked());
         return;
@@ -1766,27 +2062,27 @@ void TabGame::dockTopLevelChanged(bool topLevel)
     retranslateUi();
 
     QObject *o = sender();
-    if(o == cardInfoDock)
+    if (o == cardInfoDock)
     {
         aCardInfoDockFloating->setChecked(topLevel);
         return;
     }
 
-    if(o == messageLayoutDock)
+    if (o == messageLayoutDock)
     {
         aMessageLayoutDockFloating->setChecked(topLevel);
         return;
     }
 
-    if(o == playerListDock)
+    if (o == playerListDock)
     {
         aPlayerListDockFloating->setChecked(topLevel);
         return;
     }
 
-    if(o == replayDock)
+    if (o == replayDock)
     {
         aReplayDockFloating->setChecked(topLevel);
         return;
     }
-}
+}
\ No newline at end of file
diff --git a/cockatrice/src/tab_game.h b/cockatrice/src/tab_game.h
index ac4bcbc4c..6811ed71c 100644
--- a/cockatrice/src/tab_game.h
+++ b/cockatrice/src/tab_game.h
@@ -60,208 +60,216 @@ class LineEditCompleter;
 class QDockWidget;
 class QStackedWidget;
 
-class ToggleButton : public QPushButton {
+class ToggleButton : public QPushButton
+{
     Q_OBJECT
-private:
-    bool state;
-signals:
-    void stateChanged();
-public:
-    ToggleButton(QWidget *parent = 0);
-    bool getState() const { return state; }
-    void setState(bool _state);
-protected:
-    void paintEvent(QPaintEvent *event);
+    private:
+        bool state;
+
+    signals:
+        void stateChanged();
+
+    public:
+        explicit ToggleButton(QWidget *parent = nullptr);
+        bool getState() const { return state; }
+        void setState(bool _state);
+
+    protected:
+        void paintEvent(QPaintEvent *event) override;
 };
 
-class DeckViewContainer : public QWidget {
+class DeckViewContainer : public QWidget
+{
     Q_OBJECT
-private:
-    QPushButton *loadLocalButton, *loadRemoteButton;
-    ToggleButton *readyStartButton, *sideboardLockButton;
-    DeckView *deckView;
-    TabGame *parentGame;
-    int playerId;
-private slots:
-    void loadLocalDeck();
-    void loadRemoteDeck();
-    void readyStart();
-    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 setButtonsVisible(bool _visible);
-    void setReadyStart(bool ready);
-    void setSideboardLocked(bool locked);
-    void setDeck(const DeckLoader &deck);
+    private:
+        QPushButton *loadLocalButton, *loadRemoteButton;
+        ToggleButton *readyStartButton, *sideboardLockButton;
+        DeckView *deckView;
+        TabGame *parentGame;
+        int playerId;
+
+    private slots:
+        void loadLocalDeck();
+        void loadRemoteDeck();
+        void readyStart();
+        void deckSelectFinished(const Response &r);
+        void sideboardPlanChanged();
+        void sideboardLockButtonClicked();
+        void updateSideboardLockButtonText();
+        void refreshShortcuts();
+
+    signals:
+        void newCardAdded(AbstractCardItem *card);
+
+    public:
+        DeckViewContainer(int _playerId, TabGame *parent);
+        void retranslateUi();
+        void setReadyStart(bool ready);
+        void setSideboardLocked(bool locked);
+        void setDeck(const DeckLoader &deck);
 };
 
-class TabGame : public Tab {
+class TabGame : public Tab
+{
     Q_OBJECT
-private:
-    QTimer *gameTimer;
-    int secondsElapsed;
-    QList<AbstractClient *> clients;
-    ServerInfo_Game gameInfo;
-    QMap<int, QString> roomGameTypes;
-    int hostId;
-    int localPlayerId;
-    const bool isLocalGame;
-    bool spectator;
-    QMap<int, Player *> players;
-    QMap<int, ServerInfo_User> spectators;
-    bool gameStateKnown;
-    bool resuming;
-    QStringList phasesList;
-    int currentPhase;
-    int activePlayer;
-    CardItem *activeCard;
-    bool gameClosed;
-    QStringList gameTypes;
-    QCompleter *completer;
-    QStringList autocompleteUserList;
-    QStackedWidget * mainWidget;
-    
-    // Replay related members
-    GameReplay *replay;
-    int currentReplayStep;
-    QList<int> replayTimeline;
-    ReplayTimelineWidget *timelineWidget;
-    QToolButton *replayStartButton, *replayPauseButton, *replayFastForwardButton;
+    private:
+        QTimer *gameTimer;
+        int secondsElapsed;
+        QList<AbstractClient *> clients;
+        ServerInfo_Game gameInfo;
+        QMap<int, QString> roomGameTypes;
+        int hostId;
+        int localPlayerId;
+        const bool isLocalGame;
+        bool spectator;
+        QMap<int, Player *> players;
+        QMap<int, ServerInfo_User> spectators;
+        bool gameStateKnown;
+        bool resuming;
+        int currentPhase;
+        int activePlayer;
+        CardItem *activeCard;
+        bool gameClosed;
+        QStringList gameTypes;
+        QCompleter *completer;
+        QStringList autocompleteUserList;
+        QStackedWidget * mainWidget;
 
-    CardFrame *cardInfo;
-    PlayerListWidget *playerListWidget;
-    QLabel *timeElapsedLabel;
-    MessageLogWidget *messageLog;
-    QLabel *sayLabel;
-    LineEditCompleter *sayEdit;
-    PhasesToolbar *phasesToolbar;
-    GameScene *scene;
-    GameView *gameView;
-    QMap<int, DeckViewContainer *> deckViewContainers;
-    QVBoxLayout *cardVInfoLayout, *messageLogLayout, *gamePlayAreaVBox, *deckViewContainerLayout;
-    QHBoxLayout *cardHInfoLayout, *sayHLayout, *mainHLayout, *replayControlLayout;
-    QWidget *cardBoxLayoutWidget, *messageLogLayoutWidget, *gamePlayAreaWidget, *deckViewContainerWidget, *replayControlWidget;
-    QDockWidget *cardInfoDock, *messageLayoutDock, *playerListDock, *replayDock;
-    QAction *playersSeparator;
-    QMenu *gameMenu, *phasesMenu, *viewMenu, *cardInfoDockMenu, *messageLayoutDockMenu, *playerListDockMenu, *replayDockMenu;
-    QAction *aGameInfo, *aConcede, *aLeaveGame, *aCloseReplay, *aNextPhase, *aNextTurn, *aRemoveLocalArrows, *aRotateViewCW, *aRotateViewCCW, *aResetLayout, *aResetReplayLayout;
-    QAction *aCardInfoDockVisible, *aCardInfoDockFloating, *aMessageLayoutDockVisible, *aMessageLayoutDockFloating, *aPlayerListDockVisible, *aPlayerListDockFloating, *aReplayDockVisible, *aReplayDockFloating;
-    QList<QAction *> phaseActions;
+        // Replay related members
+        GameReplay *replay;
+        int currentReplayStep;
+        QList<int> replayTimeline;
+        ReplayTimelineWidget *timelineWidget;
+        QToolButton *replayStartButton, *replayPauseButton, *replayFastForwardButton;
 
-    Player *addPlayer(int playerId, const ServerInfo_User &info);
+        CardFrame *cardInfo;
+        PlayerListWidget *playerListWidget;
+        QLabel *timeElapsedLabel;
+        MessageLogWidget *messageLog;
+        QLabel *sayLabel;
+        LineEditCompleter *sayEdit;
+        PhasesToolbar *phasesToolbar;
+        GameScene *scene;
+        GameView *gameView;
+        QMap<int, DeckViewContainer *> deckViewContainers;
+        QVBoxLayout *cardVInfoLayout, *messageLogLayout, *gamePlayAreaVBox, *deckViewContainerLayout;
+        QHBoxLayout *cardHInfoLayout, *sayHLayout, *replayControlLayout;
+        QWidget *cardBoxLayoutWidget, *messageLogLayoutWidget, *gamePlayAreaWidget, *deckViewContainerWidget, *replayControlWidget;
+        QDockWidget *cardInfoDock, *messageLayoutDock, *playerListDock, *replayDock;
+        QAction *playersSeparator;
+        QMenu *gameMenu, *phasesMenu, *viewMenu, *cardInfoDockMenu, *messageLayoutDockMenu, *playerListDockMenu, *replayDockMenu;
+        QAction *aGameInfo, *aConcede, *aLeaveGame, *aCloseReplay, *aNextPhase, *aNextTurn, *aRemoveLocalArrows, *aRotateViewCW, *aRotateViewCCW, *aResetLayout;
+        QAction *aCardInfoDockVisible, *aCardInfoDockFloating, *aMessageLayoutDockVisible, *aMessageLayoutDockFloating, *aPlayerListDockVisible, *aPlayerListDockFloating, *aReplayDockVisible, *aReplayDockFloating;
+        QList<QAction *> phaseActions;
 
-    void startGame(bool resuming);
-    void stopGame();
-    void closeGame();
+        Player *addPlayer(int playerId, const ServerInfo_User &info);
 
-    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 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);
-    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);
-    Player *setActivePlayer(int id);
-    void eventSetActivePlayer(const Event_SetActivePlayer &event, int eventPlayerId, const GameEventContext &context);
-    void setActivePhase(int phase);
-    void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);
-    void eventPing(const Event_Ping &event, int eventPlayerId, const GameEventContext &context);
-    void emitUserEvent();
-    void createMenuItems();
-    void createReplayMenuItems();
-    void createViewMenuItems();
-    void createCardInfoDock(bool bReplay=false);
-    void createPlayerListDock(bool bReplay=false);
-    void createMessageDock(bool bReplay=false);
-    void createPlayAreaWidget(bool bReplay=false);
-    void createDeckViewContainerWidget(bool bReplay=false);
-    void createReplayDock();
-    QString getLeaveReason(Event_Leave::LeaveReason reason);
-signals:
-    void gameClosing(TabGame *tab);
-    void playerAdded(Player *player);
-    void playerRemoved(Player *player);
-    void containerProcessingStarted(const GameEventContext &context);
-    void containerProcessingDone();
-    void openMessageDialog(const QString &userName, bool focus);
-    void openDeckEditor(const DeckLoader *deck);
-    void notIdle();
-private slots:
-    void replayNextEvent();
-    void replayFinished();
-    void replayStartButtonClicked();
-    void replayPauseButtonClicked();
-    void replayFastForwardButtonToggled(bool checked);
-    
-    void incrementGameTime();
-    void adminLockChanged(bool lock);
-    void newCardAdded(AbstractCardItem *card);
-    void updateCardMenu(AbstractCardItem *card);
-    
-    void actGameInfo();
-    void actConcede();
-    void actLeaveGame();
-    void actRemoveLocalArrows();
-    void actRotateViewCW();
-    void actRotateViewCCW();
-    void actSay();
-    void actPhaseAction();
-    void actNextPhase();
-    void actNextTurn();
+        void startGame(bool resuming);
+        void stopGame();
+        void closeGame();
 
-    void addMentionTag(QString value);
-    void commandFinished(const Response &response);
-	
-    void refreshShortcuts();
-	
-    void loadLayout();
-	void actCompleterChanged();
-    void actResetLayout();
-    void freeDocksSize();
+        void eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext &context);
+        void eventSpectatorLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
 
-    bool eventFilter(QObject *o, QEvent *e);
-    void dockVisibleTriggered();
-    void dockFloatingTriggered();
-    void dockTopLevelChanged(bool topLevel);
-public:
-    TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event, const QMap<int, QString> &_roomGameTypes);
-    TabGame(TabSupervisor *_tabSupervisor, GameReplay *replay);
-    ~TabGame();
-    void retranslateUi();
-    void updatePlayerListDockTitle();
-    void closeRequest();
-    const QMap<int, Player *> &getPlayers() const { return players; }
-    CardItem *getCard(int playerId, const QString &zoneName, int cardId) const;
-    bool isHost() const { return hostId == localPlayerId; }
-    bool getIsLocalGame() const { return isLocalGame; }
-    int getGameId() const { return gameInfo.game_id(); }
-    QString getTabText() const;
-    bool getSpectator() const { return spectator; }
-    bool getSpectatorsSeeEverything() const { return gameInfo.spectators_omniscient(); }
-    bool isSpectator();
-    Player *getActiveLocalPlayer() const;
-    AbstractClient *getClientForPlayer(int playerId) const;
+        void eventGameStateChanged(const Event_GameStateChanged &event, int eventPlayerId, const GameEventContext &context);
+        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);
+        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);
+        Player *setActivePlayer(int id);
+        void eventSetActivePlayer(const Event_SetActivePlayer &event, int eventPlayerId, const GameEventContext &context);
+        void setActivePhase(int phase);
+        void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);
+        void emitUserEvent();
+        void createMenuItems();
+        void createReplayMenuItems();
+        void createViewMenuItems();
+        void createCardInfoDock(bool bReplay=false);
+        void createPlayerListDock(bool bReplay=false);
+        void createMessageDock(bool bReplay=false);
+        void createPlayAreaWidget(bool bReplay=false);
+        void createDeckViewContainerWidget(bool bReplay=false);
+        void createReplayDock();
+        QString getLeaveReason(Event_Leave::LeaveReason reason);
 
-    void setActiveCard(CardItem *_card) { activeCard = _card; }
-    CardItem *getActiveCard() const { return activeCard; }
+    signals:
+        void gameClosing(TabGame *tab);
+        void playerAdded(Player *player);
+        void playerRemoved(Player *player);
+        void containerProcessingStarted(const GameEventContext &context);
+        void containerProcessingDone();
+        void openMessageDialog(const QString &userName, bool focus);
+        void openDeckEditor(const DeckLoader *deck);
 
-    void processGameEventContainer(const GameEventContainer &cont, AbstractClient *client);
-    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);
+    private slots:
+        void replayNextEvent();
+        void replayFinished();
+        void replayStartButtonClicked();
+        void replayPauseButtonClicked();
+        void replayFastForwardButtonToggled(bool checked);
+
+        void incrementGameTime();
+        void adminLockChanged(bool lock);
+        void newCardAdded(AbstractCardItem *card);
+        void updateCardMenu(AbstractCardItem *card);
+
+        void actGameInfo();
+        void actConcede();
+        void actLeaveGame();
+        void actRemoveLocalArrows();
+        void actRotateViewCW();
+        void actRotateViewCCW();
+        void actSay();
+        void actPhaseAction();
+        void actNextPhase();
+        void actNextTurn();
+
+        void addMentionTag(QString value);
+        void commandFinished(const Response &response);
+
+        void refreshShortcuts();
+
+        void loadLayout();
+        void actCompleterChanged();
+        void actResetLayout();
+        void freeDocksSize();
+
+        bool eventFilter(QObject *o, QEvent *e) override;
+        void dockVisibleTriggered();
+        void dockFloatingTriggered();
+        void dockTopLevelChanged(bool topLevel);
+
+    public:
+        TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event, const QMap<int, QString> &_roomGameTypes);
+        TabGame(TabSupervisor *_tabSupervisor, GameReplay *replay);
+        ~TabGame() override;
+        void retranslateUi() override;
+        void updatePlayerListDockTitle();
+        void closeRequest() override;
+        const QMap<int, Player *> &getPlayers() const { return players; }
+        CardItem *getCard(int playerId, const QString &zoneName, int cardId) const;
+        bool isHost() const { return hostId == localPlayerId; }
+        bool getIsLocalGame() const { return isLocalGame; }
+        int getGameId() const { return gameInfo.game_id(); }
+        QString getTabText() const override;
+        bool getSpectator() const { return spectator; }
+        bool getSpectatorsSeeEverything() const { return gameInfo.spectators_omniscient(); }
+        bool isSpectator();
+        Player *getActiveLocalPlayer() const;
+        AbstractClient *getClientForPlayer(int playerId) const;
+
+        void setActiveCard(CardItem *_card) { activeCard = _card; }
+        CardItem *getActiveCard() const { return activeCard; }
+
+        void processGameEventContainer(const GameEventContainer &cont, AbstractClient *client);
+        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);
 };
 
 #endif
diff --git a/cockatrice/src/tab_supervisor.cpp b/cockatrice/src/tab_supervisor.cpp
index 4a64bd89e..911c95e54 100644
--- a/cockatrice/src/tab_supervisor.cpp
+++ b/cockatrice/src/tab_supervisor.cpp
@@ -28,8 +28,7 @@
 #include "pb/serverinfo_room.pb.h"
 #include "pb/moderator_commands.pb.h"
 
-CloseButton::CloseButton(QWidget *parent)
-    : QAbstractButton(parent)
+CloseButton::CloseButton(QWidget *parent) : QAbstractButton(parent)
 {
     setFocusPolicy(Qt::NoFocus);
     setCursor(Qt::ArrowCursor);
@@ -39,9 +38,9 @@ CloseButton::CloseButton(QWidget *parent)
 QSize CloseButton::sizeHint() const
 {
     ensurePolished();
-    int width = style()->pixelMetric(QStyle::PM_TabCloseIndicatorWidth, 0, this);
-    int height = style()->pixelMetric(QStyle::PM_TabCloseIndicatorHeight, 0, this);
-    return QSize(width, height);
+    int width = style()->pixelMetric(QStyle::PM_TabCloseIndicatorWidth, nullptr, this);
+    int height = style()->pixelMetric(QStyle::PM_TabCloseIndicatorHeight, nullptr, this);
+    return {width, height};
 }
 
 void CloseButton::enterEvent(QEvent *event)
@@ -63,24 +62,34 @@ void CloseButton::paintEvent(QPaintEvent * /*event*/)
     opt.init(this);
     opt.state |= QStyle::State_AutoRaise;
     if (isEnabled() && underMouse() && !isChecked() && !isDown())
+    {
         opt.state |= QStyle::State_Raised;
+    }
+
     if (isChecked())
+    {
         opt.state |= QStyle::State_On;
+    }
+
     if (isDown())
+    {
         opt.state |= QStyle::State_Sunken;
-    
-    if (const QTabBar *tb = qobject_cast<const QTabBar *>(parent())) {
+    }
+
+    if (const auto *tb = qobject_cast<const QTabBar *>(parent()))
+    {
         int index = tb->currentIndex();
-        QTabBar::ButtonPosition position = (QTabBar::ButtonPosition) style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, tb);
+        auto position = static_cast<QTabBar::ButtonPosition>(style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, tb));
         if (tb->tabButton(index, position) == this)
+        {
             opt.state |= QStyle::State_Selected;
+        }
     }
     
     style()->drawPrimitive(QStyle::PE_IndicatorTabClose, &opt, &p, this);
 }
 
-TabSupervisor::TabSupervisor(AbstractClient *_client, QWidget *parent)
-    : QTabWidget(parent), userInfo(0), client(_client), tabServer(0), tabUserLists(0), tabDeckStorage(0), tabReplays(0), tabAdmin(0), tabLog(0)
+TabSupervisor::TabSupervisor(AbstractClient *_client, QWidget *parent) : QTabWidget(parent), userInfo(nullptr), client(_client), tabServer(nullptr), tabUserLists(nullptr), tabDeckStorage(nullptr), tabReplays(nullptr), tabAdmin(nullptr), tabLog(nullptr)
 {
     setElideMode(Qt::ElideRight);
     setMovable(true);
@@ -113,42 +122,63 @@ void TabSupervisor::retranslateUi()
     tabs.append(tabLog);
     QMapIterator<int, TabRoom *> roomIterator(roomTabs);
     while (roomIterator.hasNext())
+    {
         tabs.append(roomIterator.next().value());
+    }
+
     QMapIterator<int, TabGame *> gameIterator(gameTabs);
     while (gameIterator.hasNext())
+    {
         tabs.append(gameIterator.next().value());
+    }
+
     QListIterator<TabGame *> replayIterator(replayTabs);
     while (replayIterator.hasNext())
+    {
         tabs.append(replayIterator.next());
+    }
+
     QListIterator<TabDeckEditor *> deckEditorIterator(deckEditorTabs);
     while (deckEditorIterator.hasNext())
+    {
         tabs.append(deckEditorIterator.next());
+    }
+
     QMapIterator<QString, TabMessage *> messageIterator(messageTabs);
     while (messageIterator.hasNext())
+    {
         tabs.append(messageIterator.next().value());
+    }
     
-    for (int i = 0; i < tabs.size(); ++i)
-        if (tabs[i]) {
-            int idx = indexOf(tabs[i]);
-            QString tabText = tabs[i]->getTabText();
+    for (auto &tab : tabs)
+    {
+        if (tab)
+        {
+            int idx = indexOf(tab);
+            QString tabText = tab->getTabText();
             setTabText(idx, sanitizeTabName(tabText));
             setTabToolTip(idx, sanitizeHtml(tabText));
-            tabs[i]->retranslateUi();
+            tab->retranslateUi();
         }
+    }
 }
 
 bool TabSupervisor::closeRequest()
 {
-    if (getGameCount()) {
-        if (QMessageBox::question(this, tr("Are you sure?"), tr("There are still open games. Are you sure you want to quit?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No) {
+    if (getGameCount())
+    {
+        if (QMessageBox::question(this, tr("Are you sure?"), tr("There are still open games. Are you sure you want to quit?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No)
+        {
             return false;
         }
     }
 
-    foreach(TabDeckEditor *tab,  deckEditorTabs)
+    for (TabDeckEditor *tab : deckEditorTabs)
     {
-        if(!tab->confirmClose())
+        if (!tab->confirmClose())
+        {
             return false;
+        }
     }
 
     return true;
@@ -185,53 +215,52 @@ int TabSupervisor::myAddTab(Tab *tab)
     return idx;
 }
 
-void TabSupervisor::start(const ServerInfo_User &_userInfo) {
+void TabSupervisor::start(const ServerInfo_User &_userInfo)
+{
     isLocalGame = false;
     userInfo = new ServerInfo_User(_userInfo);
 
     tabServer = new TabServer(this, client);
-    connect(tabServer, SIGNAL(roomJoined(
-                                      const ServerInfo_Room &, bool)), this, SLOT(addRoomTab(
-                                                                                          const ServerInfo_Room &, bool)));
+    connect(tabServer, SIGNAL(roomJoined(const ServerInfo_Room &, bool)), this, SLOT(addRoomTab(const ServerInfo_Room &, bool)));
     myAddTab(tabServer);
 
     tabUserLists = new TabUserLists(this, client, *userInfo);
-    connect(tabUserLists, SIGNAL(openMessageDialog(
-                                         const QString &, bool)), this, SLOT(addMessageTab(
-                                                                                     const QString &, bool)));
+    connect(tabUserLists, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
     connect(tabUserLists, SIGNAL(userJoined(ServerInfo_User)), this, SLOT(processUserJoined(ServerInfo_User)));
-    connect(tabUserLists, SIGNAL(userLeft(
-                                         const QString &)), this, SLOT(processUserLeft(
-                                                                               const QString &)));
+    connect(tabUserLists, SIGNAL(userLeft(const QString &)), this, SLOT(processUserLeft(const QString &)));
     myAddTab(tabUserLists);
 
     updatePingTime(0, -1);
 
-    if (userInfo->user_level() & ServerInfo_User::IsRegistered) {
+    if (userInfo->user_level() & ServerInfo_User::IsRegistered)
+    {
         tabDeckStorage = new TabDeckStorage(this, client);
-        connect(tabDeckStorage, SIGNAL(openDeckEditor(
-                                               const DeckLoader *)), this, SLOT(addDeckEditorTab(
-                                                                                        const DeckLoader *)));
+        connect(tabDeckStorage, SIGNAL(openDeckEditor(const DeckLoader *)), this, SLOT(addDeckEditorTab(const DeckLoader *)));
         myAddTab(tabDeckStorage);
 
         tabReplays = new TabReplays(this, client);
-        connect(tabReplays, SIGNAL(openReplay(GameReplay * )), this, SLOT(openReplay(GameReplay * )));
+        connect(tabReplays, SIGNAL(openReplay(GameReplay* )), this, SLOT(openReplay(GameReplay* )));
         myAddTab(tabReplays);
-    } else {
-        tabDeckStorage = 0;
-        tabReplays = 0;
+    }
+    else
+    {
+        tabDeckStorage = nullptr;
+        tabReplays = nullptr;
     }
 
-    if (userInfo->user_level() & ServerInfo_User::IsModerator) {
-        tabAdmin = new TabAdmin(this, client, (userInfo->user_level() & ServerInfo_User::IsAdmin));
+    if (userInfo->user_level() & ServerInfo_User::IsModerator)
+    {
+        tabAdmin = new TabAdmin(this, client, static_cast<bool>(userInfo->user_level() & ServerInfo_User::IsAdmin));
         connect(tabAdmin, SIGNAL(adminLockChanged(bool)), this, SIGNAL(adminLockChanged(bool)));
         myAddTab(tabAdmin);
 
         tabLog = new TabLog(this, client);
         myAddTab(tabLog);
-    } else {
-        tabAdmin = 0;
-        tabLog = 0;
+    }
+    else
+    {
+        tabAdmin = nullptr;
+        tabLog = nullptr;
     }
 
     retranslateUi();
@@ -247,82 +276,117 @@ void TabSupervisor::startLocal(const QList<AbstractClient *> &_clients)
     isLocalGame = true;
     userInfo = new ServerInfo_User;
     localClients = _clients;
-    for (int i = 0; i < localClients.size(); ++i)
-        connect(localClients[i], SIGNAL(gameEventContainerReceived(const GameEventContainer &)), this, SLOT(processGameEventContainer(const GameEventContainer &)));
+    for (auto &localClient : localClients)
+    {
+        connect(localClient, SIGNAL(gameEventContainerReceived(const GameEventContainer &)), this, SLOT(processGameEventContainer(const GameEventContainer &)));
+    }
+
     connect(localClients.first(), SIGNAL(gameJoinedEventReceived(const Event_GameJoined &)), this, SLOT(localGameJoined(const Event_GameJoined &)));
 }
 
 void TabSupervisor::stop()
 {
     if ((!client) && localClients.isEmpty())
+    {
         return;
+    }
     
-    if (!localClients.isEmpty()) {
-        for (int i = 0; i < localClients.size(); ++i)
-            localClients[i]->deleteLater();
+    if (!localClients.isEmpty())
+    {
+        for (auto &localClient : localClients)
+        {
+            localClient->deleteLater();
+        }
+
         localClients.clear();
         
         emit localGameEnded();
-    } else {
-        if (tabUserLists)
-            tabUserLists->deleteLater();
-        if (tabServer)
-            tabServer->deleteLater();
-        if (tabDeckStorage)
-            tabDeckStorage->deleteLater();
-        if (tabReplays)
-            tabReplays->deleteLater();
-        if (tabAdmin)
-            tabAdmin->deleteLater();
-        if (tabLog)
-            tabLog->deleteLater();
     }
-    tabUserLists = 0;
-    tabServer = 0;
-    tabDeckStorage = 0;
-    tabReplays = 0;
-    tabAdmin = 0;
-    tabLog = 0;
+    else
+    {
+        if (tabUserLists)
+        {
+            tabUserLists->deleteLater();
+        }
+
+        if (tabServer)
+        {
+            tabServer->deleteLater();
+        }
+
+        if (tabDeckStorage)
+        {
+            tabDeckStorage->deleteLater();
+        }
+
+        if (tabReplays)
+        {
+            tabReplays->deleteLater();
+        }
+
+        if (tabAdmin)
+        {
+            tabAdmin->deleteLater();
+        }
+
+        if (tabLog)
+        {
+            tabLog->deleteLater();
+        }
+    }
+
+    tabUserLists = nullptr;
+    tabServer = nullptr;
+    tabDeckStorage = nullptr;
+    tabReplays = nullptr;
+    tabAdmin = nullptr;
+    tabLog = nullptr;
     
     QMapIterator<int, TabRoom *> roomIterator(roomTabs);
     while (roomIterator.hasNext())
+    {
         roomIterator.next().value()->deleteLater();
+    }
     roomTabs.clear();
 
     QMapIterator<int, TabGame *> gameIterator(gameTabs);
     while (gameIterator.hasNext())
+    {
         gameIterator.next().value()->deleteLater();
+    }
     gameTabs.clear();
 
     QListIterator<TabGame *> replayIterator(replayTabs);
     while (replayIterator.hasNext())
+    {
         replayIterator.next()->deleteLater();
+    }
     replayTabs.clear();
 
     delete userInfo;
-    userInfo = 0;
+    userInfo = nullptr;
 }
 
 void TabSupervisor::updatePingTime(int value, int max)
 {
-    if (!tabServer)
-        return;
-    if (tabServer->getContentsChanged())
+    if (!tabServer || tabServer->getContentsChanged())
+    {
         return;
+    }
     
     setTabIcon(indexOf(tabServer), QIcon(PingPixmapGenerator::generatePixmap(15, value, max)));
 }
 
 void TabSupervisor::closeButtonPressed()
 {
-    Tab *tab = static_cast<Tab *>(static_cast<CloseButton *>(sender())->property("tab").value<QObject *>());
+    Tab *tab = dynamic_cast<Tab *>(dynamic_cast<CloseButton *>(sender())->property("tab").value<QObject *>());
     tab->closeRequest();
 }
 
 void TabSupervisor::addCloseButtonToTab(Tab *tab, int tabIndex)
 {
-    QTabBar::ButtonPosition closeSide = (QTabBar::ButtonPosition) tabBar()->style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, tabBar());
-    CloseButton *closeButton = new CloseButton;
+    auto closeSide = static_cast<QTabBar::ButtonPosition>(tabBar()->style()->styleHint(QStyle::SH_TabBar_CloseButtonPosition, 0, tabBar()));
+    auto *closeButton = new CloseButton;
     connect(closeButton, SIGNAL(clicked()), this, SLOT(closeButtonPressed()));
     closeButton->setProperty("tab", qVariantFromValue((QObject *) tab));
     tabBar()->setTabButton(tabIndex, closeSide, closeButton);
@@ -333,10 +397,16 @@ void TabSupervisor::gameJoined(const Event_GameJoined &event)
     QMap<int, QString> roomGameTypes;
     TabRoom *room = roomTabs.value(event.game_info().room_id());
     if (room)
+    {
         roomGameTypes = room->getGameTypes();
+    }
     else
+    {
         for (int i = 0; i < event.game_types_size(); ++i)
+        {
             roomGameTypes.insert(event.game_types(i).game_type_id(), QString::fromStdString(event.game_types(i).description()));
+        }
+    }
     
     TabGame *tab = new TabGame(this, QList<AbstractClient *>() << client, event, roomGameTypes);
     connect(tab, SIGNAL(gameClosing(TabGame *)), this, SLOT(gameLeft(TabGame *)));
@@ -358,7 +428,8 @@ void TabSupervisor::localGameJoined(const Event_GameJoined &event)
     gameTabs.insert(event.game_info().game_id(), tab);
     setCurrentWidget(tab);
     
-    for (int i = 1; i < localClients.size(); ++i) {
+    for (int i = 1; i < localClients.size(); ++i)
+    {
         Command_JoinGame cmd;
         cmd.set_game_id(event.game_info().game_id());
         localClients[i]->sendCommand(localClients[i]->prepareRoomCommand(cmd, 0));
@@ -367,19 +438,28 @@ void TabSupervisor::localGameJoined(const Event_GameJoined &event)
 
 void TabSupervisor::gameLeft(TabGame *tab)
 {
+    if (tab == nullptr)
+    {
+        return;
+    }
+
     if (tab == currentWidget())
+    {
         emit setMenu();
+    }
 
     gameTabs.remove(tab->getGameId());
     removeTab(indexOf(tab));
     
     if (!localClients.isEmpty())
+    {
         stop();
+    }
 }
 
 void TabSupervisor::addRoomTab(const ServerInfo_Room &info, bool setCurrent)
 {
-    TabRoom *tab = new TabRoom(this, client, userInfo, info);
+    auto *tab = new TabRoom(this, client, userInfo, info);
     connect(tab, SIGNAL(maximizeClient()), this, SLOT(maximizeMainWindow()));   
     connect(tab, SIGNAL(roomClosing(TabRoom *)), this, SLOT(roomLeft(TabRoom *)));
     connect(tab, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
@@ -387,13 +467,22 @@ void TabSupervisor::addRoomTab(const ServerInfo_Room &info, bool setCurrent)
     addCloseButtonToTab(tab, tabIndex);
     roomTabs.insert(info.room_id(), tab);
     if (setCurrent)
+    {
         setCurrentWidget(tab);
+    }
 }
 
 void TabSupervisor::roomLeft(TabRoom *tab)
 {
+    if (tab == nullptr)
+    {
+        return;
+    }
+
     if (tab == currentWidget())
+    {
         emit setMenu();
+    }
     
     roomTabs.remove(tab->getRoomId());
     removeTab(indexOf(tab));
@@ -401,7 +490,7 @@ void TabSupervisor::roomLeft(TabRoom *tab)
 
 void TabSupervisor::openReplay(GameReplay *replay)
 {
-    TabGame *replayTab = new TabGame(this, replay);
+    auto *replayTab = new TabGame(this, replay);
     connect(replayTab, SIGNAL(gameClosing(TabGame *)), this, SLOT(replayLeft(TabGame *)));
     int tabIndex = myAddTab(replayTab);
     addCloseButtonToTab(replayTab, tabIndex);
@@ -412,7 +501,9 @@ void TabSupervisor::openReplay(GameReplay *replay)
 void TabSupervisor::replayLeft(TabGame *tab)
 {
     if (tab == currentWidget())
+    {
         emit setMenu();
+    }
     
     replayTabs.removeAt(replayTabs.indexOf(tab));
 }
@@ -420,20 +511,30 @@ void TabSupervisor::replayLeft(TabGame *tab)
 TabMessage *TabSupervisor::addMessageTab(const QString &receiverName, bool focus)
 {
     if (receiverName == QString::fromStdString(userInfo->name()))
-        return 0;
+    {
+        return nullptr;
+    }
     
     ServerInfo_User otherUser;
     UserListTWI *twi = tabUserLists->getAllUsersList()->getUsers().value(receiverName);
     if (twi)
+    {
         otherUser = twi->getUserInfo();
+    }
     else
+    {
         otherUser.set_name(receiverName.toStdString());
+    }
 
     TabMessage *tab;
     tab = messageTabs.value(QString::fromStdString(otherUser.name()));
-    if (tab) {
+    if (tab)
+    {
         if (focus)
-          setCurrentWidget(tab);
+        {
+            setCurrentWidget(tab);
+        }
+
         return tab;
     }
 
@@ -444,18 +545,28 @@ TabMessage *TabSupervisor::addMessageTab(const QString &receiverName, bool focus
     addCloseButtonToTab(tab, tabIndex);
     messageTabs.insert(receiverName, tab);
     if (focus)
+    {
         setCurrentWidget(tab);
+    }
     return tab;
 }
 
-void TabSupervisor::maximizeMainWindow() {
+void TabSupervisor::maximizeMainWindow()
+{
     emit showWindowIfHidden();
 }
 
 void TabSupervisor::talkLeft(TabMessage *tab)
 {
+    if (tab == nullptr)
+    {
+        return;
+    }
+
     if (tab == currentWidget())
+    {
         emit setMenu();
+    }
 
     messageTabs.remove(tab->getUserName());
     removeTab(indexOf(tab));
@@ -463,9 +574,13 @@ void TabSupervisor::talkLeft(TabMessage *tab)
 
 TabDeckEditor *TabSupervisor::addDeckEditorTab(const DeckLoader *deckToOpen)
 {
-    TabDeckEditor *tab = new TabDeckEditor(this);
+    auto *tab = new TabDeckEditor(this);
+
     if (deckToOpen)
+    {
         tab->setDeck(new DeckLoader(*deckToOpen));
+    }
+
     connect(tab, SIGNAL(deckEditorClosing(TabDeckEditor *)), this, SLOT(deckEditorClosed(TabDeckEditor *)));
     int tabIndex = myAddTab(tab);
     addCloseButtonToTab(tab, tabIndex);
@@ -476,8 +591,15 @@ TabDeckEditor *TabSupervisor::addDeckEditorTab(const DeckLoader *deckToOpen)
 
 void TabSupervisor::deckEditorClosed(TabDeckEditor *tab)
 {
+    if (tab == nullptr)
+    {
+        return;
+    }
+
     if (tab == currentWidget())
+    {
         emit setMenu();
+    }
     
     deckEditorTabs.removeAt(deckEditorTabs.indexOf(tab));
     removeTab(indexOf(tab));
@@ -485,13 +607,18 @@ void TabSupervisor::deckEditorClosed(TabDeckEditor *tab)
 
 void TabSupervisor::tabUserEvent(bool globalEvent)
 {
-    Tab *tab = static_cast<Tab *>(sender());
-    if (tab != currentWidget()) {
+    auto *tab = dynamic_cast<Tab *>(sender());
+
+    if (tab != currentWidget())
+    {
         tab->setContentsChanged(true);
         setTabIcon(indexOf(tab), QPixmap("theme:icons/tab_changed"));
     }
+
     if (globalEvent && settingsCache->getNotificationsEnabled())
+    {
         QApplication::alert(this);
+    }
 }
 
 void TabSupervisor::updateTabText(Tab *tab, const QString &newTabText)
@@ -504,90 +631,129 @@ void TabSupervisor::updateTabText(Tab *tab, const QString &newTabText)
 void TabSupervisor::processRoomEvent(const RoomEvent &event)
 {
     TabRoom *tab = roomTabs.value(event.room_id(), 0);
+
     if (tab)
+    {
         tab->processRoomEvent(event);
+    }
 }
 
 void TabSupervisor::processGameEventContainer(const GameEventContainer &cont)
 {
     TabGame *tab = gameTabs.value(cont.game_id());
+
     if (tab)
+    {
         tab->processGameEventContainer(cont, qobject_cast<AbstractClient *>(sender()));
+    }
     else
+    {
         qDebug() << "gameEvent: invalid gameId";
+    }
 }
 
 void TabSupervisor::processUserMessageEvent(const Event_UserMessage &event)
 {
     QString senderName = QString::fromStdString(event.sender_name());
     TabMessage *tab = messageTabs.value(senderName);
-    if (!tab)
+
+    if (tab == nullptr)
+    {
         tab = messageTabs.value(QString::fromStdString(event.receiver_name()));
-    if (!tab) {
+    }
+
+    if (tab == nullptr)
+    {
         UserListTWI *twi = tabUserLists->getAllUsersList()->getUsers().value(senderName);
-        if (twi) {
+
+        if (twi)
+        {
             UserLevelFlags userLevel = UserLevelFlags(twi->getUserInfo().user_level());
-            if (settingsCache->getIgnoreUnregisteredUserMessages() &&
-                !userLevel.testFlag(ServerInfo_User::IsRegistered))
+            if (settingsCache->getIgnoreUnregisteredUserMessages() && !userLevel.testFlag(ServerInfo_User::IsRegistered))
+            {
                 // Flags are additive, so reg/mod/admin are all IsRegistered
                 return;
+            }
         }
+
         tab = addMessageTab(QString::fromStdString(event.sender_name()), false);
     }
-    if (!tab)
+
+    if (tab == nullptr)
+    {
         return;
+    }
+
     tab->processUserMessageEvent(event);
 }
 
 void TabSupervisor::processUserLeft(const QString &userName)
 {
     TabMessage *tab = messageTabs.value(userName);
+
     if (tab)
+    {
         tab->processUserLeft();
+    }
 }
 
 void TabSupervisor::processUserJoined(const ServerInfo_User &userInfo)
 {
     TabMessage *tab = messageTabs.value(QString::fromStdString(userInfo.name()));
     if (tab)
+    {
         tab->processUserJoined(userInfo);
+    }
 }
 
 void TabSupervisor::updateCurrent(int index)
 {
-    if (index != -1) {
-        Tab *tab = static_cast<Tab *>(widget(index));
-        if (tab->getContentsChanged()) {
+    if (index != -1)
+    {
+        auto *tab = dynamic_cast<Tab *>(widget(index));
+        if (tab->getContentsChanged())
+        {
             setTabIcon(index, QIcon());
             tab->setContentsChanged(false);
         }
-        emit setMenu(static_cast<Tab *>(widget(index))->getTabMenus());
+        emit setMenu(dynamic_cast<Tab *>(widget(index))->getTabMenus());
         tab->tabActivated();
-    } else
+    }
+    else
+    {
         emit setMenu();
+    }
 }
 
 bool TabSupervisor::getAdminLocked() const
 {
     if (!tabAdmin)
+    {
         return true;
+    }
     return tabAdmin->getLocked();
 }
 
 void TabSupervisor::processNotifyUserEvent(const Event_NotifyUser &event)
 {
 
-    switch ((Event_NotifyUser::NotificationType) event.type()) {
+    switch ((Event_NotifyUser::NotificationType) event.type())
+    {
         case Event_NotifyUser::UNKNOWN: QMessageBox::information(this, tr("Unknown Event"), tr("The server has sent you a message that your client does not understand.\nThis message might mean there is a new version of Cockatrice available or this server is running a custom or pre-release version.\n\nTo update your client, go to Help -> Check for Updates.")); break;
         case Event_NotifyUser::IDLEWARNING: QMessageBox::information(this, tr("Idle Timeout"), tr("You are about to be logged out due to inactivity.")); break;
         case Event_NotifyUser::PROMOTED: QMessageBox::information(this, tr("Promotion"), tr("You have been promoted to moderator. Please log out and back in for changes to take effect.")); break;
-        case Event_NotifyUser::WARNING: {
+        case Event_NotifyUser::WARNING:
+        {
             if (!QString::fromStdString(event.warning_reason()).simplified().isEmpty())
+            {
                 QMessageBox::warning(this, tr("Warned"), tr("You have received a warning due to %1.\nPlease refrain from engaging in this activity or further actions may be taken against you. If you have any questions, please private message a moderator.").arg(QString::fromStdString(event.warning_reason()).simplified()));
+            }
             break;
         }
-        case Event_NotifyUser::CUSTOM: {
-            if (!QString::fromStdString(event.custom_title()).simplified().isEmpty() && !QString::fromStdString(event.custom_content()).simplified().isEmpty()) {
+        case Event_NotifyUser::CUSTOM:
+        {
+            if (!QString::fromStdString(event.custom_title()).simplified().isEmpty() && !QString::fromStdString(event.custom_content()).simplified().isEmpty())
+            {
                 QMessageBox msgBox;
                 msgBox.setParent(this);
                 msgBox.setWindowFlags(Qt::Dialog);
@@ -600,7 +766,7 @@ void TabSupervisor::processNotifyUserEvent(const Event_NotifyUser &event)
             }
             break;
         }
-        default: ;
+        default: break;
     }
 
 }
@@ -617,8 +783,11 @@ QString TabSupervisor::getOwnUsername() const
 
 bool TabSupervisor::isUserBuddy(const QString &userName) const
 {
-    if (!getUserListsTab()) return false;
-    if (!getUserListsTab()->getBuddyList()) return false;
+    if (!getUserListsTab() || !getUserListsTab()->getBuddyList())
+    {
+        return false;
+    }
+
     QMap<QString, UserListTWI *> buddyList = getUserListsTab()->getBuddyList()->getUsers();
     bool senderIsBuddy = buddyList.contains(userName);
     return senderIsBuddy;
@@ -626,26 +795,33 @@ bool TabSupervisor::isUserBuddy(const QString &userName) const
 
 bool TabSupervisor::isUserIgnored(const QString &userName) const
 {
-    if (!getUserListsTab()) return false;
-    if (!getUserListsTab()->getIgnoreList()) return false;
+    if (!getUserListsTab() || !getUserListsTab()->getIgnoreList())
+    {
+        return false;
+    }
+
     QMap<QString, UserListTWI *> buddyList = getUserListsTab()->getIgnoreList()->getUsers();
     bool senderIsBuddy = buddyList.contains(userName);
     return senderIsBuddy;
 }
 
-const ServerInfo_User * TabSupervisor::getOnlineUser(const QString &userName) const
+const ServerInfo_User* TabSupervisor::getOnlineUser(const QString &userName) const
 {
-    if (!getUserListsTab()) return nullptr;
-    if (!getUserListsTab()->getAllUsersList()) return nullptr;
+    if (!getUserListsTab() || !getUserListsTab()->getAllUsersList())
+    {
+        return nullptr;
+    }
+
     QMap<QString, UserListTWI *> userList = getUserListsTab()->getAllUsersList()->getUsers();
     const QString &userNameToMatchLower = userName.toLower();
     QMap<QString, UserListTWI *>::iterator i;
 
     for (i = userList.begin(); i != userList.end(); ++i)
-        if (i.key().toLower() == userNameToMatchLower) {
+        if (i.key().toLower() == userNameToMatchLower)
+        {
             const ServerInfo_User &userInfo = i.value()->getUserInfo();
             return &userInfo;
         }
 
     return nullptr;
-};
+};
\ No newline at end of file
diff --git a/cockatrice/src/tab_supervisor.h b/cockatrice/src/tab_supervisor.h
index 6a7a4a152..b256a68c5 100644
--- a/cockatrice/src/tab_supervisor.h
+++ b/cockatrice/src/tab_supervisor.h
@@ -30,90 +30,97 @@ class ServerInfo_User;
 class GameReplay;
 class DeckList;
 
-class CloseButton : public QAbstractButton {
+class CloseButton : public QAbstractButton
+{
     Q_OBJECT
-public:
-    CloseButton(QWidget *parent = 0);
-    QSize sizeHint() const;
-    inline QSize minimumSizeHint() const { return sizeHint(); }
-protected:
-    void enterEvent(QEvent *event);
-    void leaveEvent(QEvent *event);
-    void paintEvent(QPaintEvent *event);
+    public:
+        explicit CloseButton(QWidget *parent = nullptr);
+        QSize sizeHint() const override;
+        inline QSize minimumSizeHint() const override { return sizeHint(); }
+
+    protected:
+        void enterEvent(QEvent *event) override;
+        void leaveEvent(QEvent *event) override;
+        void paintEvent(QPaintEvent *event) override;
 };
 
-class TabSupervisor : public QTabWidget, public UserlistProxy {
+class TabSupervisor : public QTabWidget, public UserlistProxy
+{
     Q_OBJECT
-private:
-    ServerInfo_User *userInfo;
-    AbstractClient *client;
-    QList<AbstractClient *> localClients;
-    TabServer *tabServer;
-    TabUserLists *tabUserLists;
-    TabDeckStorage *tabDeckStorage;
-    TabReplays *tabReplays;
-    TabAdmin *tabAdmin;
-    TabLog *tabLog;
-    QMap<int, TabRoom *> roomTabs;
-    QMap<int, TabGame *> gameTabs;
-    QList<TabGame *> replayTabs;
-    QMap<QString, TabMessage *> messageTabs;
-    QList<TabDeckEditor *> deckEditorTabs;
-    int myAddTab(Tab *tab);
-    void addCloseButtonToTab(Tab *tab, int tabIndex);
-    QString sanitizeTabName(QString dirty) const;
-    QString sanitizeHtml(QString dirty) const;
-    bool isLocalGame;
-public:
-    TabSupervisor(AbstractClient *_client, QWidget *parent = 0);
-    ~TabSupervisor();
-    void retranslateUi();
-    void start(const ServerInfo_User &userInfo);
-    void startLocal(const QList<AbstractClient *> &_clients);
-    void stop();
-    bool getIsLocalGame() const { return isLocalGame; }
-    int getGameCount() const { return gameTabs.size(); }
-    TabUserLists *getUserListsTab() const { return tabUserLists; }
-    ServerInfo_User *getUserInfo() const { return userInfo; }
-    AbstractClient *getClient() const;
-    const QMap<int, TabRoom *> &getRoomTabs() const { return roomTabs; }
-    bool getAdminLocked() const;
-    bool closeRequest();
-    bool isOwnUserRegistered() const;
-    QString getOwnUsername() const;
-    bool isUserBuddy(const QString &userName) const;
-    bool isUserIgnored(const QString &userName) const;
-    const ServerInfo_User* getOnlineUser(const QString &userName) const;
-signals:
-    void setMenu(const QList<QMenu *> &newMenuList = QList<QMenu *>());
-    void localGameEnded();
-    void adminLockChanged(bool lock);
-    void showWindowIfHidden();
-public slots:
-    TabDeckEditor *addDeckEditorTab(const DeckLoader *deckToOpen);
-    void openReplay(GameReplay *replay);
-    void maximizeMainWindow();
-private slots:
-    void closeButtonPressed();
-    void updateCurrent(int index);
-    void updatePingTime(int value, int max);
-    void gameJoined(const Event_GameJoined &event);
-    void localGameJoined(const Event_GameJoined &event);
-    void gameLeft(TabGame *tab);
-    void addRoomTab(const ServerInfo_Room &info, bool setCurrent);
-    void roomLeft(TabRoom *tab);
-    TabMessage *addMessageTab(const QString &userName, bool focus);
-    void replayLeft(TabGame *tab);
-    void processUserLeft(const QString &userName);
-    void processUserJoined(const ServerInfo_User &userInfo);
-    void talkLeft(TabMessage *tab);
-    void deckEditorClosed(TabDeckEditor *tab);
-    void tabUserEvent(bool globalEvent);
-    void updateTabText(Tab *tab, const QString &newTabText);
-    void processRoomEvent(const RoomEvent &event);
-    void processGameEventContainer(const GameEventContainer &cont);
-    void processUserMessageEvent(const Event_UserMessage &event);
-    void processNotifyUserEvent(const Event_NotifyUser &event);
+    private:
+        ServerInfo_User *userInfo;
+        AbstractClient *client;
+        QList<AbstractClient *> localClients;
+        TabServer *tabServer;
+        TabUserLists *tabUserLists;
+        TabDeckStorage *tabDeckStorage;
+        TabReplays *tabReplays;
+        TabAdmin *tabAdmin;
+        TabLog *tabLog;
+        QMap<int, TabRoom *> roomTabs;
+        QMap<int, TabGame *> gameTabs;
+        QList<TabGame *> replayTabs;
+        QMap<QString, TabMessage *> messageTabs;
+        QList<TabDeckEditor *> deckEditorTabs;
+        int myAddTab(Tab *tab);
+        void addCloseButtonToTab(Tab *tab, int tabIndex);
+        QString sanitizeTabName(QString dirty) const;
+        QString sanitizeHtml(QString dirty) const;
+        bool isLocalGame;
+
+    public:
+        explicit TabSupervisor(AbstractClient *_client, QWidget *parent = nullptr);
+        ~TabSupervisor() override;
+        void retranslateUi();
+        void start(const ServerInfo_User &userInfo);
+        void startLocal(const QList<AbstractClient *> &_clients);
+        void stop();
+        bool getIsLocalGame() const { return isLocalGame; }
+        int getGameCount() const { return gameTabs.size(); }
+        TabUserLists *getUserListsTab() const { return tabUserLists; }
+        ServerInfo_User *getUserInfo() const { return userInfo; }
+        AbstractClient *getClient() const;
+        const QMap<int, TabRoom *> &getRoomTabs() const { return roomTabs; }
+        bool getAdminLocked() const;
+        bool closeRequest();
+        bool isOwnUserRegistered() const override;
+        QString getOwnUsername() const override;
+        bool isUserBuddy(const QString &userName) const override;
+        bool isUserIgnored(const QString &userName) const override;
+        const ServerInfo_User* getOnlineUser(const QString &userName) const override;
+
+    signals:
+        void setMenu(const QList<QMenu *> &newMenuList = QList<QMenu *>());
+        void localGameEnded();
+        void adminLockChanged(bool lock);
+        void showWindowIfHidden();
+
+    public slots:
+        TabDeckEditor *addDeckEditorTab(const DeckLoader *deckToOpen);
+        void openReplay(GameReplay *replay);
+        void maximizeMainWindow();
+
+    private slots:
+        void closeButtonPressed();
+        void updateCurrent(int index);
+        void updatePingTime(int value, int max);
+        void gameJoined(const Event_GameJoined &event);
+        void localGameJoined(const Event_GameJoined &event);
+        void gameLeft(TabGame *tab);
+        void addRoomTab(const ServerInfo_Room &info, bool setCurrent);
+        void roomLeft(TabRoom *tab);
+        TabMessage *addMessageTab(const QString &userName, bool focus);
+        void replayLeft(TabGame *tab);
+        void processUserLeft(const QString &userName);
+        void processUserJoined(const ServerInfo_User &userInfo);
+        void talkLeft(TabMessage *tab);
+        void deckEditorClosed(TabDeckEditor *tab);
+        void tabUserEvent(bool globalEvent);
+        void updateTabText(Tab *tab, const QString &newTabText);
+        void processRoomEvent(const RoomEvent &event);
+        void processGameEventContainer(const GameEventContainer &cont);
+        void processUserMessageEvent(const Event_UserMessage &event);
+        void processNotifyUserEvent(const Event_NotifyUser &event);
 };
 
 #endif
\ No newline at end of file