table_zone.h

Go to the documentation of this file.

 
#ifndef TABLEZONE_H
#define TABLEZONE_H
 
#include "../../game/zones/table_zone_logic.h"
#include "../animated_item.h"
#include "../board/abstract_card_item.h"
#include "select_zone.h"
 
#include <QElapsedTimer>

class TableZone : public SelectZone, public IAnimatedItem
{
    Q_OBJECT
 
signals:
    void sizeChanged();
 
private:
    static const int TABLEROWS = 3;
 
    /*
    Margins between table edges and cards, paddings between cards
    */
    static const int MARGIN_LEFT = 20;
    static const int MARGIN_RIGHT = 15;
    static const int MARGIN_TOP = 10;
    static const int MARGIN_BOTTOM = 30;
    static const int PADDING_X = 35;
    static const int PADDING_Y = 30;
 
    /*
    Minimum width of the table zone including margins.
    */
    static const int MIN_WIDTH = MARGIN_LEFT + (5 * CardDimensions::WIDTH) + MARGIN_RIGHT;
 
    /*
    Offset sizes when cards are stacked on each other in the grid
    */
    static const int STACKED_CARD_OFFSET_X = CardDimensions::WIDTH / 3;
    static const int STACKED_CARD_OFFSET_Y = PADDING_Y / 3;
 
    /*
    Width of the box line drawn in the margin around the active player's area
    */
    static const int BOX_LINE_WIDTH = 10;
 
    /*
    Default inactive mask and border gradient
    */
    static const QColor BACKGROUND_COLOR;
    static const QColor FADE_MASK;
    static const QColor GRADIENT_COLOR;
    static const QColor GRADIENT_COLORLESS;
 
    /*
       Size and shape variables
     */
    int width;
    int height;
    int currentMinimumWidth;
 
    /*
    Internal cache for widths of stacks of cards by row and column.
    */
    QMap<int, int> cardStackWidth;
 
    /*
       Holds any custom background image for the TableZone
     */
    QPixmap backgroundPixelMap;
 
    /*
       If this TableZone is currently active
     */
    bool active = false;
    bool mirrored = false;
    bool playmatActive = false;
 
    [[nodiscard]] bool isInverted() const;
 
private slots:
    void updateBg();
 
public slots:
    void onPlaymatChanged(bool active);
 
public slots:
    void reorganizeCards() override;
    void setMirrored(bool isMirrored);
 
public:
    explicit TableZone(TableZoneLogic *_logic, bool mirrored, QGraphicsItem *parent = nullptr);

    [[nodiscard]] QRectF boundingRect() const override;

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;

    void triggerDamageShimmer();

    bool animationEvent() override;

    void toggleTapped();

    void
    handleDropEvent(const QList<CardDragItem *> &dragItems, CardZoneLogic *startZone, const QPoint &dropPoint) override;

    void
    handleDropEventByGrid(const QList<CardDragItem *> &dragItems, CardZoneLogic *startZone, const QPoint &gridPoint);

    [[nodiscard]] CardItem *getCardFromGrid(const QPoint &gridPoint) const;

    [[nodiscard]] CardItem *getCardFromCoords(const QPointF &point) const;
 
    QPointF closestGridPoint(const QPointF &point) override;
 
    static int clampValidTableRow(const int row);

    static int tableRowToGridY(int tableRow);

    void resizeToContents();
 
    [[nodiscard]] int getMinimumWidth() const
    {
        return currentMinimumWidth;
    }
    void setWidth(qreal _width)
    {
        // The width is stored as an int; truncate to match the previous implicit conversion.
        const int newWidth = static_cast<int>(_width);
        if (width == newWidth) {
            return;
        }
        prepareGeometryChange();
        width = newWidth;
        // The parent player item's boundingRect (which clips the playmat painting) is
        // derived from this zone's size. Without this signal the playmat is cut off at
        // the stale boundingRect edge whenever the scene is resized wider.
        emit sizeChanged();
    }
    [[nodiscard]] qreal getWidth() const
    {
        return width;
    }
    void setActive(bool _active)
    {
        active = _active;
        update();
    }
 
private:
    static constexpr qreal shimmerDurationMs = 450.0;
 
    QElapsedTimer shimmerClock;
    qreal damageShimmerAlpha = 0.0;
 
    void paintZoneOutline(QPainter *painter);
    void paintLandDivider(QPainter *painter);
 
    /*
    Calculates card stack widths so mapping functions work properly
    */
    void computeCardStackWidths();
 
    /*
    Mapping functions for points to/from gridpoints.
    */
    [[nodiscard]] QPointF mapFromGrid(QPoint gridPoint) const;
    [[nodiscard]] QPoint mapToGrid(const QPointF &mapPoint) const;
 
    /*
    Helper function to create a single key from a card stack location.
    */
    [[nodiscard]] int getCardStackMapKey(int x, int y) const
    {
        return x + (y * 1000);
    }
};
 
#endif