jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-11-09 11:33:25 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

[Game] Refactor: rename hovered to restore previous semantics (#7816)

Browse source
This commit is contained in:
RickyRister 2026-11-09 04:54:10 -07:00 • committed by GitHub
parent 9793a0df4a
commit 3f3aff9408
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 92 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

42
cockatrice/src/game_graphics/board/abstract_card_item.cpp
View file

@ -57,7 +57,7 @@ static constexpr int FADE_DURATION_MS = 140;
AbstractCardItem::AbstractCardItem(QGraphicsItem *parent, const CardRef &cardRef, PlayerLogic *_owner, int _id)
: ArrowTarget(_owner, parent), state(new CardState(this, nullptr, cardRef, _id)), tapAngle(0),
bgColor(Qt::transparent), isHovered(false), isHoverHighlighted(false), realZValue(0)
bgColor(Qt::transparent), isHovered(false), isHoverZoomed(false), realZValue(0)
{
setCursor(Qt::OpenHandCursor);
setFlag(ItemIsSelectable);
@ -82,10 +82,10 @@ AbstractCardItem::AbstractCardItem(QGraphicsItem *parent, const CardRef &cardRef
// the clip escape and the ancestor lift all stay put while the card is still large,
// so siblings and the clip container cannot cut through the shrinking card.
connect(hoverZoom, &QPropertyAnimation::finished, this, [this] {
if (!isHovered) {
if (!isHoverZoomed) {
// The cursor may still rest on the card (e.g. wheel-up reverts the zoom),
// in which case the highlight keeps it raised.
setZValue(isHoverHighlighted ? ZValues::HOVERED_CARD : realZValue);
setZValue(isHovered ? ZValues::HOVERED_CARD : realZValue);
// Final repaint at the settled footprint: with no scale delta the animation
// emits no per-frame updates, and zones would keep a stale clip hole behind.
if (scene()) {
@ -170,7 +170,7 @@ void AbstractCardItem::setRealZValue(qreal _zValue)
// During hover, zValue is overridden to HOVERED_CARD. Layout operations
// like reorganizeCards() call setRealZValue() on all cards including the
// hovered one — skip setZValue() here to avoid clobbering the override.
if (!isHovered && !isHoverHighlighted) {
if (!isHovered && !isHoverZoomed) {
setZValue(_zValue);
}
}
@ -268,9 +268,9 @@ void AbstractCardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *
painter->setRenderHint(QPainter::Antialiasing, false);
if (isSelected() || isHovered || isHoverHighlighted) {
if (isSelected() || isHovered || isHoverZoomed) {
QPen pen;
if (isHovered || isHoverHighlighted) {
if (isHovered || isHoverZoomed) {
pen.setColor(Qt::yellow);
}
if (isSelected()) {
@ -284,13 +284,13 @@ void AbstractCardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *
painter->restore();
}
void AbstractCardItem::setHovered(bool _hovered)
void AbstractCardItem::setHoverZoomed(bool _hoverZoomed)
{
if (isHovered == _hovered) {
if (isHoverZoomed == _hoverZoomed) {
return;
}
if (_hovered) {
if (_hoverZoomed) {
processHoverEvent();
} else {
// Mark the hovered card's current scene footprint dirty so overlapped
@ -304,11 +304,11 @@ void AbstractCardItem::setHovered(bool _hovered)
}
}
isHovered = _hovered;
isHoverZoomed = _hoverZoomed;
// The stacking override is one-directional: it applies the moment the hover starts
// and only drops once the shrink-out finishes (see the hoverZoom finished handler).
// Restoring it here would let siblings paint over the still-enlarged card.
if (_hovered) {
if (_hoverZoomed) {
setZValue(ZValues::HOVERED_CARD);
}
// Scale about the center in both directions: at scale 1 the origin is moot,
@ -320,7 +320,7 @@ void AbstractCardItem::setHovered(bool _hovered)
// The target is constant ON-SCREEN pixels: divide out the board view zoom so
// fullscreen (or zoomed) boards don't overshoot while the fixed-size panel matches.
qreal target = 1.0;
if (_hovered && SettingsCache::instance().cardsDisplay().getScaleCards()) {
if (_hoverZoomed && SettingsCache::instance().cardsDisplay().getScaleCards()) {
const qreal w = boundingRect().width();
qreal viewScale = 1.0;
if (scene() && !scene()->views().isEmpty()) {
@ -335,24 +335,24 @@ void AbstractCardItem::setHovered(bool _hovered)
hoverZoom->stop();
hoverZoom->setStartValue(scale());
hoverZoom->setEndValue(target);
hoverZoom->setDuration(_hovered ? HOVER_ZOOM_IN_MS : HOVER_ZOOM_OUT_MS);
hoverZoom->setDuration(_hoverZoomed ? HOVER_ZOOM_IN_MS : HOVER_ZOOM_OUT_MS);
hoverZoom->start();
update();
}
void AbstractCardItem::setHoverHighlighted(bool highlighted)
void AbstractCardItem::setHovered(bool _hovered)
{
if (isHoverHighlighted == highlighted) {
if (isHovered == _hovered) {
return;
}
if (highlighted) {
if (_hovered) {
// The card-info widget listens for this: hovering still updates it right away.
processHoverEvent();
}
isHoverHighlighted = highlighted;
if (highlighted) {
isHovered = _hovered;
if (_hovered) {
setZValue(ZValues::HOVERED_CARD);
}
@ -368,10 +368,10 @@ void AbstractCardItem::setHoverHighlighted(bool highlighted)
setTransformOriginPoint(CardDimensions::WIDTH_HALF_F, CardDimensions::HEIGHT_HALF_F);
hoverZoom->stop();
hoverZoom->setStartValue(scale());
hoverZoom->setEndValue(highlighted ? LEGACY_HOVER_SCALE : 1.0);
hoverZoom->setDuration(highlighted ? HOVER_ZOOM_IN_MS : HOVER_ZOOM_OUT_MS);
hoverZoom->setEndValue(_hovered ? LEGACY_HOVER_SCALE : 1.0);
hoverZoom->setDuration(_hovered ? HOVER_ZOOM_IN_MS : HOVER_ZOOM_OUT_MS);
hoverZoom->start();
} else if (!highlighted && !isHovered && hoverZoom->state() != QAbstractAnimation::Running) {
} else if (!_hovered && !isHoverZoomed && hoverZoom->state() != QAbstractAnimation::Running) {
// A zoomed card keeps its raised z until the shrink-out finishes (its finished
// handler restores it); a highlight-only card has nothing to unwind.
setZValue(realZValue);

10
cockatrice/src/game_graphics/board/abstract_card_item.h
View file

@ -37,7 +37,7 @@ protected:
private:
bool isHovered;
bool isHoverHighlighted;
bool isHoverZoomed;
qreal realZValue;
bool pendingSelectionCollapse;
int selectionCollapseGeneration = 0; ///< Guards the deferred collapse timer against stale firings
@ -134,7 +134,6 @@ public:
return realZValue;
}
void setRealZValue(qreal _zValue);
void setHovered(bool _hovered);
/**
* @brief Shows the hover outline and stacking lift, plus the historical 1.1x hover
* scale whenever no zoom trigger is configured.
@ -144,7 +143,8 @@ public:
* off and the panel not on hover, the old 1.1x enlargement (gated by scaleCards)
* stays in effect so upgrading does not silently drop it.
*/
void setHoverHighlighted(bool highlighted);
void setHovered(bool _hovered);
void setHoverZoomed(bool _hoverZoomed);
qreal getCardScale() const;
void setCardScale(qreal scale);
qreal getCardOpacity() const;
@ -152,9 +152,9 @@ public:
/** @brief Fades the card out under the hover panel, or back in when it closes. */
void fadeCardOut();
void fadeCardIn();
bool getIsHovered() const
bool getIsHoverZoomed() const
{
return isHovered;
return isHoverZoomed;
}
[[nodiscard]] QString getColor() const
{

2
cockatrice/src/game_graphics/board/card_item.cpp
View file

@ -533,7 +533,7 @@ bool CardItem::animationEvent()
.translate(CardDimensions::WIDTH_HALF_F, CardDimensions::HEIGHT_HALF_F)
.rotate(tapAngle)
.translate(-CardDimensions::WIDTH_HALF_F, -CardDimensions::HEIGHT_HALF_F));
setHovered(false);
setHoverZoomed(false);
update();
return animationIncomplete;

100
cockatrice/src/game_graphics/game_scene.cpp
View file

@ -773,7 +773,7 @@ void GameScene::onCardViewRefreshRequested(CardState *card, bool zoneChanged, Pl
item->deleteDragItem();
if (zoneChanged) {
item->setBeingPointedAt(false);
item->setHovered(false);
item->setHoverZoomed(false);
}
if (newOwner) {
item->setOwner(newOwner);
@ -797,9 +797,9 @@ void GameScene::clearArrowsForPlayerLocally(int playerId)
}
// ---------- Hover Handling ----------
CardItem *GameScene::getHoveredCard() const
CardItem *GameScene::getHoverZoomedCard() const
{
return hoveredCard;
return hoverZoomedCard;
}
void GameScene::updateHover(const QPointF &scenePos)
@ -812,14 +812,14 @@ CardItem *GameScene::pickCardAt(const QPointF &scenePos)
auto itemList = items(scenePos, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder, getViewTransform());
CardZone *zone = findTopmostZone(itemList);
CardItem *topCard = zone ? findTopmostCardInZone(itemList, zone) : nullptr;
if (!topCard && hoveredCard) {
const QRectF guard = hoveredCard->sceneBoundingRect().adjusted(-8, -8, 8, 8);
if (!topCard && hoverZoomedCard) {
const QRectF guard = hoverZoomedCard->sceneBoundingRect().adjusted(-8, -8, 8, 8);
if (guard.contains(scenePos)) {
// The zoomed card overflows onto neighboring zones, where naive topmost-zone
// picking attributes the cursor to the zone underneath. While the cursor is
// still over the zoomed footprint (with hysteresis for edge jiggle), keep it.
// A genuinely different topmost card still takes over.
return hoveredCard;
return hoverZoomedCard;
}
}
return topCard;
@ -833,27 +833,27 @@ void GameScene::updateHoveredCard(CardItem *newCard)
}
// The hovered card may have been destroyed without ending the hover: its QPointer
// nulled itself, but the ancestor lift is still outstanding. Restore it now.
if (!hoveredCard && !hoverLiftedAncestors.isEmpty()) {
if (!hoverZoomedCard && !hoverLiftedAncestors.isEmpty()) {
restoreHoverLift();
}
// Hovering alone never starts anything anymore: the trigger (dwell, click, wheel,
// shortcut) resolves first, then the zoom follows. This keeps the feature calm.
bool wasHoveringCard = (hoveredCard != nullptr);
if (hoveredCard && (newCard != hoveredCard)) {
endCardHover(hoveredCard);
hoveredCard = nullptr;
bool wasHoveringCard = (hoverZoomedCard != nullptr);
if (hoverZoomedCard && (newCard != hoverZoomedCard)) {
endHoverZoom(hoverZoomedCard);
hoverZoomedCard = nullptr;
}
// The hover outline and the card info follow the cursor on contact: only the board
// zoom and the panel wait for their trigger. A highlight-only card has no zoom to
// unwind, so it is dropped directly instead of through endCardHover().
if (hoverHighlightCard && hoverHighlightCard != newCard) {
hoverHighlightCard->setHoverHighlighted(false);
if (hoveredCard && hoveredCard != newCard) {
hoveredCard->setHovered(false);
}
hoverHighlightCard = newCard;
hoveredCard = newCard;
if (newCard) {
newCard->setHoverHighlighted(true);
newCard->setHovered(true);
}
auto &display = SettingsCache::instance().cardsDisplay();
@ -866,7 +866,7 @@ void GameScene::updateHoveredCard(CardItem *newCard)
hoverGracePending = false;
hoverGraceTimer->stop();
if (newCard == hoveredCard) {
if (newCard == hoverZoomedCard) {
// Steady state: zoom already up. Refresh an open panel, otherwise nothing —
// in particular this must not re-fire an armed double-confirm.
if (cardHoverWidget && cardHoverWidget->isVisible() && cardHoverWidget->getCardItem() == newCard) {
@ -877,8 +877,8 @@ void GameScene::updateHoveredCard(CardItem *newCard)
if (cardHoverWidget && cardHoverWidget->isVisible() && !cardHoverWidget->isClosing() &&
cardHoverWidget->getCardItem() == newCard) {
// Panel open but zoom dropped (e.g. survived a Leave) — zoom back and refresh.
beginCardHover(newCard);
hoveredCard = newCard;
beginHoverZoom(newCard);
hoverZoomedCard = newCard;
cardHoverWidget->refreshDisplay();
return;
}
@ -896,8 +896,8 @@ void GameScene::updateHoveredCard(CardItem *newCard)
}
if (doubleConfirm && confirmArmedCard == newCard) {
// Repeat hover on an armed card: zoom and show at once, no second dwell.
beginCardHover(newCard);
hoveredCard = newCard;
beginHoverZoom(newCard);
hoverZoomedCard = newCard;
confirmArmedCard.clear();
showCardHoverPopup(newCard);
return;
@ -928,9 +928,9 @@ void GameScene::updateHoveredCard(CardItem *newCard)
}
}
void GameScene::beginCardHover(CardItem *card)
void GameScene::beginHoverZoom(CardItem *card)
{
card->setHovered(true);
card->setHoverZoomed(true);
if (auto *zone = SelectZone::findOwningSelectZone(card)) {
zone->escapeClipForHover(card);
}
@ -953,21 +953,21 @@ void GameScene::beginCardHover(CardItem *card)
ancestor = ancestor->parentItem();
}
liftOwner = card;
connect(card, &AbstractCardItem::hoverShrinkFinished, this, &GameScene::onHoverShrinkFinished,
connect(card, &AbstractCardItem::hoverShrinkFinished, this, &GameScene::onHoverZoomShrinkFinished,
Qt::UniqueConnection);
connect(card, &AbstractCardItem::hoverFootprintChanged, this, &GameScene::onHoverFootprintChanged,
connect(card, &AbstractCardItem::hoverFootprintChanged, this, &GameScene::onHoverZoomFootprintChanged,
Qt::UniqueConnection);
}
void GameScene::endCardHover(CardItem *card)
void GameScene::endHoverZoom(CardItem *card)
{
// Only the zoom-out starts here: the z-value, the clip escape and the ancestor
// lift stay put until the shrink finishes (onHoverShrinkFinished), so siblings and
// the clip container cannot cut through the still-enlarged card.
card->setHovered(false);
card->setHoverZoomed(false);
}
void GameScene::onHoverShrinkFinished(AbstractCardItem *card)
void GameScene::onHoverZoomShrinkFinished(AbstractCardItem *card)
{
auto *cardItem = qobject_cast<CardItem *>(card);
if (!cardItem) {
@ -984,7 +984,7 @@ void GameScene::onHoverShrinkFinished(AbstractCardItem *card)
restoreHoverLift();
}
void GameScene::onHoverFootprintChanged(const QRectF &oldFootprint, const QRectF &newFootprint)
void GameScene::onHoverZoomFootprintChanged(const QRectF &oldFootprint, const QRectF &newFootprint)
{
const QRectF dirty = oldFootprint.united(newFootprint);
if (dirty.isEmpty()) {
@ -1126,13 +1126,13 @@ void GameScene::onHoverActivateTimeout()
const bool panelPhase = display.getHoverPanelTrigger() == CardsDisplaySettings::HoverPanelTriggerHover;
const bool effectiveDouble =
display.getHoverPanelDoubleConfirm() && display.getHoverZoomTrigger() == display.getHoverPanelTrigger();
if (hoveredCard && hoveredCard != target) {
endCardHover(hoveredCard);
if (hoverZoomedCard && hoverZoomedCard != target) {
endHoverZoom(hoverZoomedCard);
}
if (zoomPhase) {
if (hoveredCard != target) {
beginCardHover(target);
hoveredCard = target;
if (hoverZoomedCard != target) {
beginHoverZoom(target);
hoverZoomedCard = target;
}
if (effectiveDouble) {
confirmArmedCard = target;
@ -1158,7 +1158,7 @@ void GameScene::onHoverPanelTimeout()
if (!target->sceneBoundingRect().contains(cursorScene)) {
return;
}
ensureZoomed(target);
ensureHoverZoomed(target);
showCardHoverPopup(target);
}
@ -1186,14 +1186,14 @@ void GameScene::summonHoverPanel()
}
}
void GameScene::ensureZoomed(CardItem *card)
void GameScene::ensureHoverZoomed(CardItem *card)
{
if (hoveredCard != card) {
if (hoveredCard) {
endCardHover(hoveredCard);
if (hoverZoomedCard != card) {
if (hoverZoomedCard) {
endHoverZoom(hoverZoomedCard);
}
beginCardHover(card);
hoveredCard = card;
beginHoverZoom(card);
hoverZoomedCard = card;
}
}
@ -1225,23 +1225,23 @@ void GameScene::fireTriggers(CardItem *card, bool zoomFired, bool panelFired)
if (effectiveDouble) {
if (confirmArmedCard == card) {
confirmArmedCard.clear();
ensureZoomed(card);
ensureHoverZoomed(card);
showCardHoverPopup(card);
} else {
confirmArmedCard = card;
ensureZoomed(card);
ensureHoverZoomed(card);
}
} else {
ensureZoomed(card);
ensureHoverZoomed(card);
showCardHoverPopup(card);
}
return;
}
if (zoomFired) {
ensureZoomed(card);
ensureHoverZoomed(card);
}
if (panelFired) {
ensureZoomed(card);
ensureHoverZoomed(card);
showCardHoverPopup(card);
}
}
@ -1254,7 +1254,7 @@ void GameScene::onHoverWidgetEntered()
void GameScene::onHoverWidgetLeft()
{
if (!hoveredCard && cardHoverWidget && cardHoverWidget->isVisible() && !hoverGracePending) {
if (!hoverZoomedCard && cardHoverWidget && cardHoverWidget->isVisible() && !hoverGracePending) {
hoverGracePending = true;
hoverGraceTimer->start();
}
@ -1440,14 +1440,14 @@ bool GameScene::event(QEvent *event)
? wheelEvent->pixelDelta().y()
: (wheelEvent->orientation() == Qt::Vertical ? wheelEvent->delta() : 0);
if (wheelUp > 0) {
if ((cardHoverWidget && cardHoverWidget->isVisible()) || hoveredCard) {
if ((cardHoverWidget && cardHoverWidget->isVisible()) || hoverZoomedCard) {
hoverPopupTarget = nullptr;
hoverPanelTarget = nullptr;
confirmArmedCard.clear();
hideCardHoverPopup();
if (hoveredCard) {
endCardHover(hoveredCard);
hoveredCard = nullptr;
if (hoverZoomedCard) {
endHoverZoom(hoverZoomedCard);
hoverZoomedCard = nullptr;
}
event->accept();
return true;

26
cockatrice/src/game_graphics/game_scene.h
View file

@ -78,11 +78,9 @@ private:
ArrowRegistry arrowRegistry; ///< ID registry for arrow graphics items
QList<ZoneViewWidget *> zoneViews; ///< Active zone view widgets
QSize viewSize; ///< Current view size
QPointer<CardItem> hoveredCard; ///< Currently hovered card (zoomed)
/// Card the cursor is resting on. It carries the hover outline and the card-info
/// update immediately, independently of the zoom/panel triggers.
QPointer<CardItem> hoverHighlightCard;
QPointer<CardItem> activeCard; ///< Card the currently open context menu targets
QPointer<CardItem> hoveredCard; ///< Card the cursor is resting on
QPointer<CardItem> hoverZoomedCard; ///< Card that is currently being hover zoomed
QPointer<CardItem> activeCard; ///< Card the currently open context menu targets
/// Card armed for double-confirm panel summon (first trigger zooms, repeat shows).
QPointer<CardItem> confirmArmedCard;
/// Ancestor chain of the hovered card with pre-hover Z-values. Lifted while hovering
@ -120,16 +118,16 @@ private:
void updateHover(const QPointF &scenePos);
/**
* @brief Activates hover state and escapes the card from its clip container
* @brief Activates hover zoom state and escapes the card from its clip container
* so hover scaling is visible beyond zone bounds.
*/
void beginCardHover(CardItem *card);
/** @brief Deactivates hover state and restores the card to its clip container. */
void endCardHover(CardItem *card);
void beginHoverZoom(CardItem *card);
/** @brief Deactivates hover zoom state and restores the card to its clip container. */
void endHoverZoom(CardItem *card);
/** @brief Restores every lifted ancestor to its pre-hover Z-value and drops the chain. */
void restoreHoverLift();
/** @brief Settles a finished shrink-out: clip container and ancestor lift restore. */
void onHoverShrinkFinished(AbstractCardItem *card);
void onHoverZoomShrinkFinished(AbstractCardItem *card);
/**
* @brief Repaints the zones that dodge the zoomed card when its footprint moves.
*
@ -137,7 +135,7 @@ private:
* item's geometry change does not dirty them, so without this the previous hole stays
* transparent in the cache and a black rectangle shows under the zoom.
*/
void onHoverFootprintChanged(const QRectF &oldFootprint, const QRectF &newFootprint);
void onHoverZoomFootprintChanged(const QRectF &oldFootprint, const QRectF &newFootprint);
// Card hover popup methods
void showCardHoverPopup(CardItem *card);
@ -284,10 +282,10 @@ public:
void fireTriggers(CardItem *card, bool zoomFired, bool panelFired);
/** @brief Starts the hover zoom for a card without touching panel state. */
void ensureZoomed(CardItem *card);
void ensureHoverZoomed(CardItem *card);
/** @brief The currently hovered card, if any (used by zones to dodge it while painting). */
CardItem *getHoveredCard() const;
/** @brief The currently hover zoomed card, if any (used by zones to dodge it while painting). */
CardItem *getHoverZoomedCard() const;
/**
* @brief Registers an item for animation updates with the shared scene timer.

2
cockatrice/src/game_graphics/zones/select_zone.cpp
View file

@ -119,7 +119,7 @@ void SelectZone::restoreStaleEscapedCards()
// A card parented to the zone (instead of the clip container) should
// only occur while it is actively hovered. If hover cleanup was
// missed, reparent it back so clipping resumes.
if (card && card->parentItem() == this && !card->getIsHovered()) {
if (card && card->parentItem() == this && !card->getIsHoverZoomed()) {
card->setParentItem(cardClipContainer);
}
}

2
cockatrice/src/game_graphics/zones/table_zone.cpp
View file

@ -176,7 +176,7 @@ std::optional<QPainterPath> TableZone::hoveredCardHole() const
if (!scene) {
return std::nullopt;
}
CardItem *hovered = scene->getHoveredCard();
CardItem *hovered = scene->getHoverZoomedCard();
if (!hovered) {
return std::nullopt;
}

2
cockatrice/src/interface/widgets/cards/card_hover_widget.cpp
View file

@ -460,7 +460,7 @@ void CardHoverWidget::createPTOverlay()
ptPillLabel->clear();
ptOverlay->resize(ptCompactSize);
// The whole subtree feeds the hover state: moving onto a button must not read as a leave.
// The whole subtree feeds the hover zoom state: moving onto a button must not read as a leave.
ptOverlay->installEventFilter(this);
const QList<QWidget *> ptChildren = ptOverlay->findChildren<QWidget *>();
for (QWidget *child : ptChildren) {