game_scene.h

Go to the documentation of this file.

#ifndef GAMESCENE_H
#define GAMESCENE_H
 
#include "../game/arrow_registry.h"
 
#include <QGraphicsScene>
#include <QHash>
#include <QList>
#include <QLoggingCategory>
#include <QMap>
#include <QMetaObject>
#include <QPointF>
#include <QPointer>
#include <QSize>
#include <QSizeF>
#include <QString>
#include <QTransform>
#include <QtGlobal>
#include <qtmetamacros.h>
 
// IWYU pragma: keep
// ServerInfo_Card appears inside QList<...> in signal and slot
// signatures, which the moc-generated code needs to be complete.
#include <libcockatrice/protocol/pb/serverinfo_card.pb.h>
 
class CardZoneLogic;
class IAnimatedItem;
class QGraphicsItem;
class QPoint;
struct ArrowData;
template <class T> class QSharedPointer;
 
inline Q_LOGGING_CATEGORY(GameSceneLog, "game_scene");
inline Q_LOGGING_CATEGORY(GameScenePlayerAdditionRemovalLog, "game_scene.player_addition_removal");
 
class PlayerLogic;
class PlayerGraphicsItem;
class ZoneViewWidget;
class CardZone;
class AbstractCardItem;
class CardItem;
class ServerInfo_Card;
class PhasesToolbar;
class QBasicTimer;
class QObject;

class GameScene : public QGraphicsScene
{
    Q_OBJECT
private:
    static const int playerAreaSpacing = 5; 
 
    PhasesToolbar *phasesToolbar;                       
    QMap<int, PlayerGraphicsItem *> playerViews;        
    QList<QList<PlayerGraphicsItem *>> playersByColumn; 
    ArrowRegistry arrowRegistry;                        
    QList<ZoneViewWidget *> zoneViews;                  
    QSize viewSize;                                     
    QPointer<CardItem> hoveredCard;                     
    QBasicTimer *animationTimer;                        
    QHash<QObject *, IAnimatedItem *> animatedItems;    
    QHash<QObject *, QMetaObject::Connection>
        animationItemConnections; 
    int playerRotation;           
    bool rearranging = false;     
    bool needsReArrange = false;  

    void updateHover(const QPointF &scenePos);

    void beginCardHover(CardItem *card);
    void endCardHover(CardItem *card);
 
public:
    explicit GameScene(PhasesToolbar *_phasesToolbar, QObject *parent = nullptr);

    ~GameScene() override;

    void retranslateUi();

    QList<CardItem *> selectedCards() const;

    void addPlayer(PlayerLogic *player);

    void removePlayer(PlayerLogic *player);
 
    QMap<int, PlayerGraphicsItem *> getPlayers() const
    {
        return playerViews;
    }
 
    PlayerGraphicsItem *viewForPlayer(int playerId)
    {
        return playerViews.value(playerId);
    }

    void adjustPlayerRotation(int rotationAdjustment);

    void rearrange();

    void processViewSizeChange(const QSize &newSize);

    QList<PlayerLogic *> collectActivePlayers(int &firstPlayerIndex) const;

    QList<PlayerLogic *> rotatePlayers(const QList<PlayerLogic *> &players, int firstPlayerIndex) const;

    static int determineColumnCount(int playerCount);

    QSizeF computeSceneSizeAndPlayerLayout(const QList<PlayerLogic *> &playersPlaying, int columns);

    QList<qreal> calculateMinWidthByColumn() const;

    qreal calculateNewSceneWidth(const QSize &newSize, qreal minWidth) const;

    void resizeColumnsAndPlayers(const QList<qreal> &minWidthByColumn, qreal newWidth);

    static CardZone *findTopmostZone(const QList<QGraphicsItem *> &items);

    static CardItem *findTopmostCardInZone(const QList<QGraphicsItem *> &items, CardZone *zone);

    void updateHoveredCard(CardItem *newCard);

    void registerAnimationItem(IAnimatedItem *item);

    void unregisterAnimationItem(IAnimatedItem *item);
    void startRubberBand(const QPointF &selectionOrigin);
    void resizeRubberBand(const QPointF &cursorPoint, int selectedCount);
    void stopRubberBand();
 
private slots:
    void removeAnimatedItem(QObject *item);
 
public slots:
    void onCardSelectionChanged(AbstractCardItem *card, bool selected);
    void onCardRightClicked(AbstractCardItem *card, QPoint screenPos);
    void playSelected(AbstractCardItem *card);
    void playSelectedFaceDown(AbstractCardItem *card);
    void hideSelected(AbstractCardItem *card);
    void toggleZoneView(PlayerLogic *player, const QString &zoneName, int numberCards, bool isReversed = false);

    void addRevealedZoneView(PlayerLogic *player,
                             CardZoneLogic *zone,
                             const QList<const ServerInfo_Card *> &cardList,
                             bool withWritePermission);

    void removeZoneView(ZoneViewWidget *item);

    void clearViews();

    void emptyActiveViews();

    void closeMostRecentZoneView();
    QTransform getViewTransform() const;
    QTransform getViewportTransform() const;

    void addArrow(QSharedPointer<ArrowData> data);
    void deleteArrow(int playerId, int arrowId);
    void clearArrowsForPlayer(int playerId);
    void clearArrowsForPlayerLocally(int playerId);

    void requestArrowDeletion(int playerId, int arrowId);
 
    void onCardZoneChanged(CardItem *card, bool sameZone);
 
protected:
    bool event(QEvent *event) override;

    void timerEvent(QTimerEvent *event) override;
 
signals:
    void sigStartRubberBand(const QPointF &selectionOrigin);
    void sigResizeRubberBand(const QPointF &cursorPoint, int selectedCount);
    void sigStopRubberBand();
    void arrowDeletionRequested(int creatorId, int arrowId);
};
 
#endif