arrows can target players; card attachment works

cockatrice/src/abstractcarditem.cpp

@@ -8,8 +8,8 @@
 #include "main.h"
 #include <QDebug>
 
-AbstractCardItem::AbstractCardItem(const QString &_name, QGraphicsItem *parent)
-	: ArrowTarget(parent), info(db->getCard(_name)), name(_name), tapped(false)
+AbstractCardItem::AbstractCardItem(const QString &_name, Player *_owner, QGraphicsItem *parent)
+	: ArrowTarget(_owner, parent), info(db->getCard(_name)), name(_name), tapped(false)
 {
 	setCursor(Qt::OpenHandCursor);
 	setFlag(ItemIsSelectable);

cockatrice/src/abstractcarditem.h

@@ -4,6 +4,7 @@
 #include "arrowtarget.h"
 
 class CardInfo;
+class Player;
 
 const int CARD_WIDTH = 72;
 const int CARD_HEIGHT = 102;
@@ -22,7 +23,7 @@ signals:
 public:
 	enum { Type = typeCard };
 	int type() const { return Type; }
-	AbstractCardItem(const QString &_name = QString(), QGraphicsItem *parent = 0);
+	AbstractCardItem(const QString &_name = QString(), Player *_owner = 0, QGraphicsItem *parent = 0);
 	~AbstractCardItem();
 	QRectF boundingRect() const;
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);

cockatrice/src/arrowitem.cpp

@@ -8,15 +8,34 @@
 #include <QPainter>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsScene>
+#include <QDebug>
 
 ArrowItem::ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &_color)
         : QGraphicsItem(), player(_player), id(_id), startItem(_startItem), targetItem(_targetItem), color(_color), fullColor(true)
 {
 	setZValue(2000000005);
+	
+	if (startItem)
+		startItem->addArrowFrom(this);
+	if (targetItem)
+		targetItem->addArrowTo(this);
+	
 	if (startItem && targetItem)
 		updatePath();
 }
 
+ArrowItem::~ArrowItem()
+{
+	qDebug() << "ArrowItem destructor";
+	if (startItem)
+		startItem->removeArrowFrom(this);
+	
+	if (targetItem) {
+		targetItem->setBeingPointedAt(false);
+		targetItem->removeArrowTo(this);
+	}
+}
+
 void ArrowItem::updatePath()
 {
 	QPointF endPoint = targetItem->mapToScene(QPointF(targetItem->boundingRect().width() / 2, targetItem->boundingRect().height() / 2));
@@ -97,8 +116,8 @@ void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 		player->sendGameCommand(new Command_DeleteArrow(-1, id));
 }
 
-ArrowDragItem::ArrowDragItem(ArrowTarget *_startItem, const QColor &_color)
-        : ArrowItem(static_cast<CardZone *>(_startItem->parentItem())->getPlayer(), -1, _startItem, 0, _color)
+ArrowDragItem::ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QColor &_color)
+        : ArrowItem(_owner, -1, _startItem, 0, _color)
 {
 }
 
@@ -118,17 +137,23 @@ void ArrowDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 			cursorItem = static_cast<ArrowTarget *>(colliding.at(i));
                         break;
 		}
-	if ((cursorItem != targetItem) && targetItem)
+	if ((cursorItem != targetItem) && targetItem) {
 		targetItem->setBeingPointedAt(false);
+		targetItem->removeArrowTo(this);
+	}
         if (!cursorItem) {
 		fullColor = false;
 		targetItem = 0;
 		updatePath(endPos);
 	} else {
+		if (cursorItem != targetItem) {
 			fullColor = true;
-		if (cursorItem != startItem)
+			if (cursorItem != startItem) {
 				cursorItem->setBeingPointedAt(true);
+				cursorItem->addArrowTo(this);
+			}
 			targetItem = cursorItem;
+		}
 		updatePath();
 	}
 	update();
@@ -140,14 +165,13 @@ void ArrowDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
 	if (targetItem && (targetItem != startItem)) {
-		targetItem->setBeingPointedAt(false);
-		CardZone *startZone = static_cast<CardZone *>(startItem->parentItem());
+		CardZone *startZone = static_cast<CardItem *>(startItem)->getZone();
 		// For now, we can safely assume that the start item is always a card.
 		// The target item can be a player as well.
 		CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem);
 		CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
 		if (targetCard) {
-			CardZone *targetZone = static_cast<CardZone *>(targetItem->parentItem());
+			CardZone *targetZone = targetCard->getZone();
 			player->sendGameCommand(new Command_CreateArrow(
 				-1,
 				startZone->getPlayer()->getId(),
@@ -165,7 +189,7 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 				startZone->getPlayer()->getId(),
 				startZone->getName(),
 				startCard->getId(),
-				static_cast<Player *>(targetPlayer->parentItem())->getId(),
+				targetPlayer->getOwner()->getId(),
 				QString(),
 				-1,
 				color
@@ -177,3 +201,55 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 	for (int i = 0; i < childArrows.size(); ++i)
 		childArrows[i]->mouseReleaseEvent(event);
 }
+
+ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem)
+        : ArrowItem(_startItem->getOwner(), -1, _startItem, 0, Qt::green)
+{
+}
+
+void ArrowAttachItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+	QPointF endPos = event->scenePos();
+	
+	QList<QGraphicsItem *> colliding = scene()->items(endPos);
+        ArrowTarget *cursorItem = 0;
+        for (int i = colliding.size() - 1; i >= 0; i--)
+                if (qgraphicsitem_cast<CardItem *>(colliding.at(i))) {
+			cursorItem = static_cast<ArrowTarget *>(colliding.at(i));
+                        break;
+		}
+	if ((cursorItem != targetItem) && targetItem)
+		targetItem->setBeingPointedAt(false);
+        if (!cursorItem) {
+		fullColor = false;
+		targetItem = 0;
+		updatePath(endPos);
+	} else {
+		fullColor = true;
+		if (cursorItem != startItem)
+			cursorItem->setBeingPointedAt(true);
+		targetItem = cursorItem;
+		updatePath();
+	}
+	update();
+}
+
+void ArrowAttachItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * /*event*/)
+{
+	if (targetItem && (targetItem != startItem)) {
+		CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem);
+		CardZone *startZone = startCard->getZone();
+		CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
+		CardZone *targetZone = targetCard->getZone();
+
+		player->sendGameCommand(new Command_AttachCard(
+			-1,
+			startZone->getName(),
+			startCard->getId(),
+			targetZone->getPlayer()->getId(),
+			targetZone->getName(),
+			targetCard->getId()
+		));
+	}
+	deleteLater();
+}

cockatrice/src/arrowitem.h

@@ -23,6 +23,7 @@ protected:
 	void mousePressEvent(QGraphicsSceneMouseEvent *event);
 public:
 	ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &color);
+	~ArrowItem();
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 	QRectF boundingRect() const { return path.boundingRect(); }
 	QPainterPath shape() const { return path; }
@@ -30,6 +31,7 @@ public:
 	void updatePath(const QPointF &endPoint);
 	
 	int getId() const { return id; }
+	Player *getPlayer() const { return player; }
 	void setStartItem(ArrowTarget *_item) { startItem = _item; }
 	void setTargetItem(ArrowTarget *_item) { targetItem = _item; }
 	ArrowTarget *getStartItem() const { return startItem; }
@@ -41,11 +43,20 @@ class ArrowDragItem : public ArrowItem {
 private:
 	QList<ArrowDragItem *> childArrows;
 public:
-	ArrowDragItem(ArrowTarget *_startItem, const QColor &_color);
+	ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QColor &_color);
 	void addChildArrow(ArrowDragItem *childArrow);
 protected:
 	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
 	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
 };
 
+class ArrowAttachItem : public ArrowItem {
+	Q_OBJECT
+public:
+	ArrowAttachItem(ArrowTarget *_startItem);
+protected:
+	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+};
+
 #endif // ARROWITEM_H

cockatrice/src/arrowtarget.cpp

 #include "arrowtarget.h"
+#include "arrowitem.h"
+#include "player.h"
 
-ArrowTarget::ArrowTarget(QGraphicsItem *parent)
-	: AbstractGraphicsItem(parent), beingPointedAt(false)
+ArrowTarget::ArrowTarget(Player *_owner, QGraphicsItem *parent)
+	: AbstractGraphicsItem(parent), owner(_owner), beingPointedAt(false)
 {
 }
 
+ArrowTarget::~ArrowTarget()
+{
+	while (!arrowsFrom.isEmpty())
+		arrowsFrom.first()->getPlayer()->delArrow(arrowsFrom.first()->getId());
+	while (!arrowsTo.isEmpty())
+		arrowsTo.first()->getPlayer()->delArrow(arrowsTo.first()->getId());
+}
+
 void ArrowTarget::setBeingPointedAt(bool _beingPointedAt)
 {
 	beingPointedAt = _beingPointedAt;

cockatrice/src/arrowtarget.h

@@ -2,14 +2,33 @@
 #define ARROWTARGET_H
 
 #include "abstractgraphicsitem.h"
+#include <QList>
+
+class Player;
+class ArrowItem;
 
 class ArrowTarget : public AbstractGraphicsItem {
+protected:
+	Player *owner;
 private:
 	bool beingPointedAt;
+	QList<ArrowItem *> arrowsFrom, arrowsTo;
 public:
-	ArrowTarget(QGraphicsItem *parent = 0);
+	ArrowTarget(Player *_owner, QGraphicsItem *parent = 0);
+	~ArrowTarget();
+	
+	Player *getOwner() const { return owner; }
+	
 	void setBeingPointedAt(bool _beingPointedAt);
 	bool getBeingPointedAt() const { return beingPointedAt; }
+	
+	const QList<ArrowItem *> &getArrowsFrom() const { return arrowsFrom; }
+	void addArrowFrom(ArrowItem *arrow) { arrowsFrom.append(arrow); }
+	void removeArrowFrom(ArrowItem *arrow) { arrowsFrom.removeAt(arrowsFrom.indexOf(arrow)); }
+	
+	const QList<ArrowItem *> &getArrowsTo() const { return arrowsTo; }
+	void addArrowTo(ArrowItem *arrow) { arrowsTo.append(arrow); }
+	void removeArrowTo(ArrowItem *arrow) { arrowsTo.removeAt(arrowsTo.indexOf(arrow)); }
 };
 
 #endif
\ No newline at end of file

cockatrice/src/carddragitem.cpp

@@ -6,7 +6,7 @@
 #include <QGraphicsSceneMouseEvent>
 #include <QCursor>
 
-CardDragItem::CardDragItem(AbstractCardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag)
+CardDragItem::CardDragItem(CardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag)
 	: AbstractCardDragItem(_item, _hotSpot, parentDrag), id(_id), faceDown(_faceDown), currentZone(0)
 {
 }
@@ -53,7 +53,7 @@ void CardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 	sc->removeItem(this);
 
 	if (currentZone) {
-		CardZone *startZone = qgraphicsitem_cast<CardZone *>(item->parentItem());
+		CardZone *startZone = static_cast<CardItem *>(item)->getZone();
 		currentZone->handleDropEvent(id, startZone, (sp - currentZone->scenePos()).toPoint(), faceDown);
 		for (int i = 0; i < childDrags.size(); i++) {
 			CardDragItem *c = static_cast<CardDragItem *>(childDrags[i]);

cockatrice/src/carddragitem.h

@@ -3,13 +3,15 @@
 
 #include "abstractcarddragitem.h"
 
+class CardItem;
+
 class CardDragItem : public AbstractCardDragItem {
 private:
 	int id;
 	bool faceDown;
 	CardZone *currentZone;
 public:
-	CardDragItem(AbstractCardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag = 0);
+	CardDragItem(CardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag = 0);
 	void updatePosition(const QPointF &cursorScenePos);
 protected:
 	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);

cockatrice/src/carditem.cpp

@@ -10,9 +10,10 @@
 #include "main.h"
 #include "protocol_datastructures.h"
 #include "settingscache.h"
+#include "tab_game.h"
 
 CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, QGraphicsItem *parent)
-	: AbstractCardItem(_name, parent), owner(_owner), id(_cardid), attacking(false), facedown(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(NULL)
+	: AbstractCardItem(_name, _owner, parent), id(_cardid), attacking(false), facedown(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(0), attachedTo(0)
 {
 	owner->addCard(this);
 
@@ -106,6 +107,14 @@ CardItem::~CardItem()
 		owner->setCardMenu(0);
 	delete cardMenu;
 	
+	while (!attachedCards.isEmpty()) {
+		attachedCards.first()->setZone(0); // so that it won't try to call reorganizeCards()
+		attachedCards.first()->setAttachedTo(0);
+	}
+	
+	if (attachedTo)
+		attachedTo->removeAttachedCard(this);
+
 	deleteDragItem();
 }
 
@@ -118,6 +127,7 @@ void CardItem::retranslateUi()
 		aFlip->setText(tr("&Flip"));
 		aClone->setText(tr("&Clone"));
 		aAttach->setText(tr("&Attach to card..."));
+		aAttach->setShortcut(tr("Ctrl+A"));
 		aUnattach->setText(tr("Unattac&h"));
 		aSetPT->setText(tr("Set &P/T..."));
 		aSetAnnotation->setText(tr("&Set annotation..."));
@@ -214,6 +224,23 @@ void CardItem::setPT(const QString &_pt)
 	update();
 }
 
+void CardItem::setAttachedTo(CardItem *_attachedTo)
+{
+	if (attachedTo)
+		attachedTo->removeAttachedCard(this);
+	
+	gridPoint.setX(-1);
+	attachedTo = _attachedTo;
+	if (attachedTo) {
+		attachedTo->addAttachedCard(this);
+		if (zone != attachedTo->getZone())
+			attachedTo->getZone()->reorganizeCards();
+	}
+
+	if (zone)
+		zone->reorganizeCards();
+}
+
 void CardItem::resetState()
 {
 	attacking = false;
@@ -221,6 +248,8 @@ void CardItem::resetState()
 	counters.clear();
 	pt.clear();
 	annotation.clear();
+	attachedTo = 0;
+	attachedCards.clear();
 	setTapped(false);
 	setDoesntUntap(false);
 	update();
@@ -273,7 +302,8 @@ void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 		else if (event->modifiers().testFlag(Qt::ShiftModifier))
 			arrowColor = Qt::green;
 		
-		ArrowDragItem *arrow = new ArrowDragItem(this, arrowColor);
+		Player *arrowOwner = static_cast<TabGame *>(owner->parent())->getActiveLocalPlayer();
+		ArrowDragItem *arrow = new ArrowDragItem(arrowOwner, this, arrowColor);
 		scene()->addItem(arrow);
 		arrow->grabMouse();
 		
@@ -282,10 +312,10 @@ void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 			CardItem *c = qgraphicsitem_cast<CardItem *>(itemIterator.next());
 			if (!c || (c == this))
 				continue;
-			if (c->parentItem() != parentItem())
+			if (c->getZone() != zone)
 				continue;
 			
-			ArrowDragItem *childArrow = new ArrowDragItem(c, arrowColor);
+			ArrowDragItem *childArrow = new ArrowDragItem(arrowOwner, c, arrowColor);
 			scene()->addItem(childArrow);
 			arrow->addChildArrow(childArrow);
 		}
@@ -300,8 +330,6 @@ void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 		createDragItem(id, event->pos(), event->scenePos(), faceDown);
 		dragItem->grabMouse();
 		
-		CardZone *zone = static_cast<CardZone *>(parentItem());
-	
 		QList<QGraphicsItem *> sel = scene()->selectedItems();
 		int j = 0;
 		for (int i = 0; i < sel.size(); i++) {
@@ -324,9 +352,8 @@ void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 
 void CardItem::playCard(QGraphicsSceneMouseEvent *event)
 {
-	CardZone *zone = static_cast<CardZone *>(parentItem());
 	// Do nothing if the card belongs to another player
-	if (!zone->getPlayer()->getLocal())
+	if (!owner->getLocal())
 		return;
 
 	TableZone *tz = qobject_cast<TableZone *>(zone);

cockatrice/src/carditem.h

@@ -15,7 +15,7 @@ const int MAX_COUNTERS_ON_CARD = 999;
 class CardItem : public AbstractCardItem {
 	Q_OBJECT
 private:
-	Player *owner;
+	CardZone *zone;
 	int id;
 	bool attacking;
 	bool facedown;
@@ -26,6 +26,8 @@ private:
 	bool doesntUntap;
 	QPoint gridPoint;
 	CardDragItem *dragItem;
+	CardItem *attachedTo;
+	QList<CardItem *> attachedCards;
 	
 	QList<QAction *> aAddCounter, aSetCounter, aRemoveCounter;
 	QAction *aTap, *aUntap, *aDoesntUntap, *aAttach, *aUnattach, *aSetPT, *aSetAnnotation, *aFlip, *aClone,
@@ -39,6 +41,8 @@ public:
 	CardItem(Player *_owner, const QString &_name = QString(), int _cardid = -1, QGraphicsItem *parent = 0);
 	~CardItem();
 	void retranslateUi();
+	CardZone *getZone() const { return zone; }
+	void setZone(CardZone *_zone) { zone = _zone; }
 	QMenu *getCardMenu() const { return cardMenu; }
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 	QPoint getGridPoint() const { return gridPoint; }
@@ -61,6 +65,11 @@ public:
 	void setPT(const QString &_pt);
 	bool getDestroyOnZoneChange() const { return destroyOnZoneChange; }
 	void setDestroyOnZoneChange(bool _destroy) { destroyOnZoneChange = _destroy; }
+	CardItem *getAttachedTo() const { return attachedTo; }
+	void setAttachedTo(CardItem *_attachedTo);
+	void addAttachedCard(CardItem *card) { attachedCards.append(card); }
+	void removeAttachedCard(CardItem *card) { attachedCards.removeAt(attachedCards.indexOf(card)); }
+	const QList<CardItem *> &getAttachedCards() const { return attachedCards; }
 	void resetState();
 	void processCardInfo(ServerInfo_Card *info);
 

cockatrice/src/cardzone.cpp

@@ -27,8 +27,15 @@ void CardZone::retranslateUi()
 
 void CardZone::clearContents()
 {
-	for (int i = 0; i < cards.size(); i++)
+	for (int i = 0; i < cards.size(); i++) {
+		// If an incorrectly implemented server doesn't return attached cards to whom they belong before dropping a player,
+		// we have to return them to avoid a crash.
+		const QList<CardItem *> &attachedCards = cards[i]->getAttachedCards();
+		for (int j = 0; j < attachedCards.size(); ++j)
+			attachedCards[j]->setParentItem(attachedCards[j]->getZone());
+		
 		delete cards.at(i);
+	}
 	cards.clear();
 	emit cardCountChanged();
 }
@@ -93,6 +100,7 @@ void CardZone::addCard(CardItem *card, bool reorganize, int x, int y)
 		if ((x <= view->getCards().size()) || (view->getNumberCards() == -1))
 			view->addCard(new CardItem(player, card->getName(), card->getId()), reorganize, x, y);
 
+	card->setZone(this);
 	addCardImpl(card, x, y);
 
 	if (reorganize)

cockatrice/src/deckview.cpp

@@ -60,7 +60,7 @@ void DeckViewCardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 }
 
 DeckViewCard::DeckViewCard(const QString &_name, const QString &_originZone, QGraphicsItem *parent)
-	: AbstractCardItem(_name, parent), originZone(_originZone), dragItem(0)
+	: AbstractCardItem(_name, 0, parent), originZone(_originZone), dragItem(0)
 {
 }
 

cockatrice/src/messagelogwidget.cpp

@@ -207,6 +207,16 @@ void MessageLogWidget::logDestroyCard(Player *player, QString cardName)
 	append(tr("%1 destroys %2.").arg(sanitizeHtml(player->getName())).arg(QString("<font color=\"blue\">%1</font>").arg(sanitizeHtml(cardName))));
 }
 
+void MessageLogWidget::logAttachCard(Player *player, QString cardName, Player *targetPlayer, QString targetCardName)
+{
+	append(tr("%1 attaches %2 to %3's %4.").arg(sanitizeHtml(player->getName())).arg(QString("<font color=\"blue\">%1</font>").arg(sanitizeHtml(cardName))).arg(sanitizeHtml(targetPlayer->getName())).arg(QString("<font color=\"blue\">%1</font>").arg(sanitizeHtml(targetCardName))));
+}
+
+void MessageLogWidget::logUnattachCard(Player *player, QString cardName)
+{
+	append(tr("%1 unattaches %2.").arg(sanitizeHtml(player->getName())).arg(QString("<font color=\"blue\">%1</font>").arg(sanitizeHtml(cardName))));
+}
+
 void MessageLogWidget::logCreateToken(Player *player, QString cardName, QString pt)
 {
 	append(tr("%1 creates token: %2%3.").arg(sanitizeHtml(player->getName())).arg(QString("<font color=\"blue\">%1</font>").arg(sanitizeHtml(cardName))).arg(pt.isEmpty() ? QString() : QString(" (%1)").arg(sanitizeHtml(pt))));
@@ -341,6 +351,8 @@ void MessageLogWidget::connectToPlayer(Player *player)
 	connect(player, SIGNAL(logSetAnnotation(Player *, QString, QString)), this, SLOT(logSetAnnotation(Player *, QString, QString)));
 	connect(player, SIGNAL(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)), this, SLOT(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)));
 	connect(player, SIGNAL(logDestroyCard(Player *, QString)), this, SLOT(logDestroyCard(Player *, QString)));
+	connect(player, SIGNAL(logAttachCard(Player *, QString, Player *, QString)), this, SLOT(logAttachCard(Player *, QString, Player *, QString)));
+	connect(player, SIGNAL(logUnattachCard(Player *, QString)), this, SLOT(logUnattachCard(Player *, QString)));
 	connect(player, SIGNAL(logDumpZone(Player *, CardZone *, int)), this, SLOT(logDumpZone(Player *, CardZone *, int)));
 	connect(player, SIGNAL(logStopDumpZone(Player *, CardZone *)), this, SLOT(logStopDumpZone(Player *, CardZone *)));
 	connect(player, SIGNAL(logDrawCards(Player *, int)), this, SLOT(logDrawCards(Player *, int)));

cockatrice/src/messagelogwidget.h

@@ -40,6 +40,8 @@ public slots:
 	void logDrawCards(Player *player, int number);
 	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
 	void logDestroyCard(Player *player, QString cardName);
+	void logAttachCard(Player *player, QString cardName, Player *targetPlayer, QString targetCardName);
+	void logUnattachCard(Player *player, QString cardName);
 	void logCreateToken(Player *player, QString cardName, QString pt);
 	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard, bool playerTarget);
 	void logSetCardCounter(Player *player, QString cardName, int counterId, int value, int oldValue);

cockatrice/src/player.cpp

@@ -224,12 +224,13 @@ Player::~Player()
 
 	static_cast<GameScene *>(scene())->removePlayer(this);
 	
+	clearArrows();
+
 	QMapIterator<QString, CardZone *> i(zones);
 	while (i.hasNext())
 		delete i.next().value();
 
 	clearCounters();
-	clearArrows();
 	delete playerMenu;
 }
 
@@ -501,7 +502,7 @@ void Player::eventCreateArrows(Event_CreateArrows *event)
 		if (targetCard)
 			emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), targetCard->getOwner(), targetCard->getName(), false);
 		else
-			emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), static_cast<Player *>(arrow->getTargetItem()->parentItem()), QString(), true);
+			emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), arrow->getTargetItem()->getOwner(), QString(), true);
 	}
 }
 
@@ -677,6 +678,43 @@ void Player::eventDestroyCard(Event_DestroyCard *event)
 	delete card;
 }
 
+void Player::eventAttachCard(Event_AttachCard *event)
+{
+	const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
+	int targetPlayerId = event->getTargetPlayerId();
+	Player *targetPlayer = 0;
+	CardZone *targetZone = 0;
+	CardItem *targetCard = 0;
+	if (targetPlayerId != -1)
+		targetPlayer = playerList.value(targetPlayerId, 0);
+	if (targetPlayer)
+		targetZone = targetPlayer->getZones().value(event->getTargetZone(), 0);
+	if (targetZone)
+		targetCard = targetZone->getCard(event->getTargetCardId(), QString());
+	
+	CardZone *startZone = getZones().value(event->getStartZone(), 0);
+	if (!startZone)
+		return;
+	
+	CardItem *startCard = startZone->getCard(event->getCardId(), QString());
+	if (!startCard)
+		return;
+	
+	if (targetZone)
+		startCard->setParentItem(targetZone);
+	else
+		startCard->setParentItem(startZone);
+	startCard->setAttachedTo(targetCard);
+	startZone->reorganizeCards();
+	if ((startZone != targetZone) && targetZone)
+		targetZone->reorganizeCards();
+	
+	if (targetCard)
+		emit logAttachCard(this, startCard->getName(), targetPlayer, targetCard->getName());
+	else
+		emit logUnattachCard(this, startCard->getName());
+}
+
 void Player::eventDrawCards(Event_DrawCards *event)
 {
 	CardZone *deck = zones.value("deck");
@@ -712,6 +750,7 @@ void Player::processGameEvent(GameEvent *event, GameEventContext *context)
 		case ItemId_Event_StopDumpZone: eventStopDumpZone(qobject_cast<Event_StopDumpZone *>(event)); break;
 		case ItemId_Event_MoveCard: eventMoveCard(qobject_cast<Event_MoveCard *>(event)); break;
 		case ItemId_Event_DestroyCard: eventDestroyCard(qobject_cast<Event_DestroyCard *>(event)); break;
+		case ItemId_Event_AttachCard: eventAttachCard(qobject_cast<Event_AttachCard *>(event)); break;
 		case ItemId_Event_DrawCards: eventDrawCards(qobject_cast<Event_DrawCards *>(event)); break;
 		default: {
 			qDebug() << "unhandled game event";
@@ -746,8 +785,12 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
 	while (zoneIt.hasNext())
 		zoneIt.next().value()->clearContents();
 
-	for (int i = 0; i < info->getZoneList().size(); ++i) {
-		ServerInfo_Zone *zoneInfo = info->getZoneList()[i];
+	clearCounters();
+	clearArrows();
+	
+	QList<ServerInfo_Zone *> zl = info->getZoneList();
+	for (int i = 0; i < zl.size(); ++i) {
+		ServerInfo_Zone *zoneInfo = zl[i];
 		CardZone *zone = zones.value(zoneInfo->getName(), 0);
 		if (!zone)
 			continue;
@@ -766,14 +809,38 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
 		zone->reorganizeCards();
 	}
 
-	clearCounters();
-	for (int i = 0; i < info->getCounterList().size(); ++i) {
-		addCounter(info->getCounterList().at(i));
+	QList<ServerInfo_Counter *> cl = info->getCounterList();
+	for (int i = 0; i < cl.size(); ++i) {
+		addCounter(cl.at(i));
 	}
 
-	clearArrows();
-	for (int i = 0; i < info->getArrowList().size(); ++i)
-		addArrow(info->getArrowList().at(i));
+	QList<ServerInfo_Arrow *> al = info->getArrowList();
+	for (int i = 0; i < al.size(); ++i)
+		addArrow(al.at(i));
+}
+
+void Player::processCardAttachment(ServerInfo_Player *info)
+{
+	QList<ServerInfo_Zone *> zl = info->getZoneList();
+	for (int i = 0; i < zl.size(); ++i) {
+		ServerInfo_Zone *zoneInfo = zl[i];
+		CardZone *zone = zones.value(zoneInfo->getName(), 0);
+		if (!zone)
+			continue;
+
+		const QList<ServerInfo_Card *> &cardList = zoneInfo->getCardList();
+		for (int j = 0; j < cardList.size(); ++j) {
+			ServerInfo_Card *cardInfo = cardList[j];
+			if (cardInfo->getAttachPlayerId() != -1) {
+				CardItem *startCard = zone->getCard(cardInfo->getId(), QString());
+				CardItem *targetCard = static_cast<TabGame *>(parent())->getCard(cardInfo->getAttachPlayerId(), cardInfo->getAttachZone(), cardInfo->getAttachCardId());
+				if (!targetCard)
+					continue;
+				
+				startCard->setAttachedTo(targetCard);
+			}
+		}
+	}
 }
 
 void Player::addCard(CardItem *c)
@@ -924,34 +991,34 @@ void Player::cardMenuAction()
 		switch (a->data().toInt()) {
 			case 0:
 				if (!card->getTapped())
-					commandList.append(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "tapped", "1"));
+					commandList.append(new Command_SetCardAttr(-1, card->getZone()->getName(), card->getId(), "tapped", "1"));
 				break;
 			case 1:
 				if (card->getTapped())
-					commandList.append(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "tapped", "0"));
+					commandList.append(new Command_SetCardAttr(-1, card->getZone()->getName(), card->getId(), "tapped", "0"));
 				break;
 			case 2:
-				commandList.append(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "doesnt_untap", QString::number(!card->getDoesntUntap())));
+				commandList.append(new Command_SetCardAttr(-1, card->getZone()->getName(), card->getId(), "doesnt_untap", QString::number(!card->getDoesntUntap())));
 				break;
 			case 3: {
-				QString zone = qgraphicsitem_cast<CardZone *>(card->parentItem())->getName();
+				QString zone = card->getZone()->getName();
 				commandList.append(new Command_MoveCard(-1, zone, card->getId(), zone, card->getGridPoint().x(), card->getGridPoint().y(), !card->getFaceDown()));
 				break;
 			}
 			case 4:
-				commandList.append(new Command_CreateToken(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getName(), card->getColor(), card->getPT(), card->getAnnotation(), card->getDestroyOnZoneChange(), -1, card->getGridPoint().y()));
+				commandList.append(new Command_CreateToken(-1, card->getZone()->getName(), card->getName(), card->getColor(), card->getPT(), card->getAnnotation(), card->getDestroyOnZoneChange(), -1, card->getGridPoint().y()));
 				break;
 			case 5:
-				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "deck", 0, 0, false));
+				commandList.append(new Command_MoveCard(-1, card->getZone()->getName(), card->getId(), "deck", 0, 0, false));
 				break;
 			case 6:
-				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "deck", -1, 0, false));
+				commandList.append(new Command_MoveCard(-1, card->getZone()->getName(), card->getId(), "deck", -1, 0, false));
 				break;
 			case 7:
-				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "grave", 0, 0, false));
+				commandList.append(new Command_MoveCard(-1, card->getZone()->getName(), card->getId(), "grave", 0, 0, false));
 				break;
 			case 8:
-				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "rfg", 0, 0, false));
+				commandList.append(new Command_MoveCard(-1, card->getZone()->getName(), card->getId(), "rfg", 0, 0, false));
 				break;
 			default: ;
 		}
@@ -976,7 +1043,7 @@ void Player::actSetPT()
 	i.toFront();
 	while (i.hasNext()) {
 		CardItem *card = static_cast<CardItem *>(i.next());
-		sendGameCommand(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "pt", pt));
+		sendGameCommand(new Command_SetCardAttr(-1, card->getZone()->getName(), card->getId(), "pt", pt));
 	}
 }
 
@@ -998,16 +1065,22 @@ void Player::actSetAnnotation()
 	i.toFront();
 	while (i.hasNext()) {
 		CardItem *card = static_cast<CardItem *>(i.next());
-		sendGameCommand(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "annotation", annotation));
+		sendGameCommand(new Command_SetCardAttr(-1, card->getZone()->getName(), card->getId(), "annotation", annotation));
 	}
 }
 
 void Player::actAttach()
 {
+	CardItem *card = static_cast<CardItem *>(sender()->parent());
+	ArrowAttachItem *arrow = new ArrowAttachItem(card);
+	scene()->addItem(arrow);
+	arrow->grabMouse();
 }
 
 void Player::actUnattach()
 {
+	CardItem *card = static_cast<CardItem *>(sender()->parent());
+	sendGameCommand(new Command_AttachCard(-1, card->getZone()->getName(), card->getId(), -1, QString(), -1));
 }
 
 void Player::actCardCounterTrigger()
@@ -1022,7 +1095,7 @@ void Player::actCardCounterTrigger()
 			while (i.hasNext()) {
 				CardItem *card = static_cast<CardItem *>(i.next());
 				if (card->getCounters().value(counterId, 0) < MAX_COUNTERS_ON_CARD)
-					sendGameCommand(new Command_SetCardCounter(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), counterId, card->getCounters().value(counterId, 0) + 1));
+					sendGameCommand(new Command_SetCardCounter(-1, card->getZone()->getName(), card->getId(), counterId, card->getCounters().value(counterId, 0) + 1));
 			}
 			break;
 		}
@@ -1031,7 +1104,7 @@ void Player::actCardCounterTrigger()
 			while (i.hasNext()) {
 				CardItem *card = static_cast<CardItem *>(i.next());
 				if (card->getCounters().value(counterId, 0))
-					sendGameCommand(new Command_SetCardCounter(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), counterId, card->getCounters().value(counterId, 0) - 1));
+					sendGameCommand(new Command_SetCardCounter(-1, card->getZone()->getName(), card->getId(), counterId, card->getCounters().value(counterId, 0) - 1));
 			}
 			break;
 		}
@@ -1044,7 +1117,7 @@ void Player::actCardCounterTrigger()
 			QListIterator<QGraphicsItem *> i(scene()->selectedItems());
 			while (i.hasNext()) {
 				CardItem *card = static_cast<CardItem *>(i.next());
-				sendGameCommand(new Command_SetCardCounter(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), counterId, number));
+				sendGameCommand(new Command_SetCardCounter(-1, card->getZone()->getName(), card->getId(), counterId, number));
 			}
 			break;
 		}

cockatrice/src/player.h

@@ -40,6 +40,7 @@ class Event_DumpZone;
 class Event_StopDumpZone;
 class Event_MoveCard;
 class Event_DestroyCard;
+class Event_AttachCard;
 class Event_DrawCards;
 
 class Player : public QObject, public QGraphicsItem {
@@ -55,6 +56,8 @@ signals:
 	void logDrawCards(Player *player, int number);
 	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
 	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, QString cardName, bool tapped);
 	void logSetCounter(Player *player, QString counterName, int value, int oldValue);
@@ -144,6 +147,7 @@ private:
 	void eventStopDumpZone(Event_StopDumpZone *event);
 	void eventMoveCard(Event_MoveCard *event);
 	void eventDestroyCard(Event_DestroyCard *event);
+	void eventAttachCard(Event_AttachCard *event);
 	void eventDrawCards(Event_DrawCards *event);
 public:
 	static const int counterAreaWidth = 65;
@@ -189,6 +193,8 @@ public:
 	void processSceneSizeChange(const QSizeF &newSize);
 	
 	void processPlayerInfo(ServerInfo_Player *info);
+	void processCardAttachment(ServerInfo_Player *info);
+	
 	void processGameEvent(GameEvent *event, GameEventContext *context);
 	void sendGameCommand(GameCommand *command);
 	void sendCommandContainer(CommandContainer *cont);

cockatrice/src/playertarget.cpp

 #include "playertarget.h"
+#include "player.h"
 #include <QPainter>
 
-PlayerTarget::PlayerTarget(const QString &_name, int _maxWidth, QGraphicsItem *parent)
-	: ArrowTarget(parent), name(_name), maxWidth(_maxWidth)
+PlayerTarget::PlayerTarget(const QString &_name, int _maxWidth, Player *_owner)
+	: ArrowTarget(_owner, _owner), name(_name), maxWidth(_maxWidth)
 {
 	font = QFont("Times");
 	font.setStyleHint(QFont::Serif);

cockatrice/src/playertarget.h

@@ -4,6 +4,8 @@
 #include "arrowtarget.h"
 #include <QFont>
 
+class Player;
+
 class PlayerTarget : public ArrowTarget {
 private:
 	QString name;
@@ -13,7 +15,7 @@ public:
 	enum { Type = typePlayerTarget };
 	int type() const { return Type; }
 	
-	PlayerTarget(const QString &_name, int _maxWidth, QGraphicsItem *parent = 0);
+	PlayerTarget(const QString &_name, int _maxWidth, Player *parent = 0);
 	QRectF boundingRect() const;
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 };

cockatrice/src/tab_game.cpp

@@ -316,6 +316,7 @@ void TabGame::startGame()
 void TabGame::stopGame()
 {
 	currentPhase = -1;
+	activePlayer = -1;
 	
 	playerListWidget->setActivePlayer(-1);
 	playerListWidget->setGameStarted(false);
@@ -365,6 +366,16 @@ void TabGame::eventGameStateChanged(Event_GameStateChanged *event, GameEventCont
 			}
 		}
 	}
+	for (int i = 0; i < plList.size(); ++i) {
+		ServerInfo_Player *pl = plList[i];
+		ServerInfo_PlayerProperties *prop = pl->getProperties();
+		if (!prop->getSpectator()) {
+			Player *player = players.value(prop->getPlayerId(), 0);
+			if (!player)
+				continue;
+			player->processCardAttachment(pl);
+		}
+	}
 	if (event->getGameStarted() && !started) {
 		startGame();
 		if (!resuming)
@@ -444,6 +455,7 @@ Player *TabGame::setActivePlayer(int id)
 	Player *player = players.value(id, 0);
 	if (!player)
 		return 0;
+	activePlayer = id;
 	playerListWidget->setActivePlayer(id);
 	QMapIterator<int, Player *> i(players);
 	while (i.hasNext()) {
@@ -547,3 +559,33 @@ void TabGame::sideboardPlanChanged()
 	QList<MoveCardToZone *> newPlan = deckView->getSideboardPlan();
 	client->sendCommand(new Command_SetSideboardPlan(gameId, newPlan));
 }
+
+CardItem *TabGame::getCard(int playerId, const QString &zoneName, int cardId) const
+{
+	Player *player = players.value(playerId, 0);
+	if (!player)
+		return 0;
+	
+	CardZone *zone = player->getZones().value(zoneName, 0);
+	if (!zone)
+		return 0;
+	
+	return zone->getCard(cardId, QString());
+}
+
+Player *TabGame::getActiveLocalPlayer() const
+{
+	Player *active = players.value(activePlayer, 0);
+	if (active)
+		if (active->getLocal())
+			return active;
+	
+	QMapIterator<int, Player *> playerIterator(players);
+	while (playerIterator.hasNext()) {
+		Player *temp = playerIterator.next().value();
+		if (temp->getLocal())
+			return temp;
+	}
+	
+	return 0;
+}

cockatrice/src/tab_game.h

@@ -66,6 +66,7 @@ private:
 	bool started;
 	bool resuming;
 	int currentPhase;
+	int activePlayer;
 
 	QPushButton *loadLocalButton, *loadRemoteButton;
 	ReadyStartButton *readyStartButton;
@@ -123,11 +124,13 @@ public:
 	~TabGame();
 	void retranslateUi();
 	const QMap<int, Player *> &getPlayers() const { return players; }
+	CardItem *getCard(int playerId, const QString &zoneName, int cardId) const;
 	int getGameId() const { return gameId; }
 	QString getTabText() const { return tr("Game %1: %2").arg(gameId).arg(gameDescription); }
 	bool getSpectator() const { return spectator; }
 	bool getSpectatorsCanTalk() const { return spectatorsCanTalk; }
 	bool getSpectatorsSeeEverything() const { return spectatorsSeeEverything; }
+	Player *getActiveLocalPlayer() const;
 
 	void processGameEventContainer(GameEventContainer *cont);
 public slots: