arrows can target players now

cockatrice/cockatrice.pro

@@ -16,6 +16,7 @@ HEADERS += src/counter.h \
  src/window_main.h \
  src/cardzone.h \
  src/player.h \
+ src/playertarget.h \
  src/cardlist.h \
  src/abstractcarditem.h \
  src/carditem.h \
@@ -45,6 +46,7 @@ HEADERS += src/counter.h \
  src/phasestoolbar.h \
  src/gamescene.h \
  src/arrowitem.h \
+ src/arrowtarget.h \
  src/tab.h \
  src/tab_server.h \
  src/tab_chatchannel.h \
@@ -71,6 +73,7 @@ SOURCES += src/counter.cpp \
  src/window_main.cpp \
  src/gamesmodel.cpp \
  src/player.cpp \
+ src/playertarget.cpp \
  src/cardzone.cpp \
  src/cardlist.cpp \
  src/abstractcarditem.cpp \
@@ -101,6 +104,7 @@ SOURCES += src/counter.cpp \
  src/phasestoolbar.cpp \
  src/gamescene.cpp \
  src/arrowitem.cpp \
+ src/arrowtarget.cpp \
  src/tab_server.cpp \
  src/tab_chatchannel.cpp \
  src/tab_game.cpp \

cockatrice/src/abstractcarditem.cpp

@@ -9,7 +9,7 @@
 #include <QDebug>
 
 AbstractCardItem::AbstractCardItem(const QString &_name, QGraphicsItem *parent)
-	: AbstractGraphicsItem(parent), info(db->getCard(_name)), name(_name), tapped(false)
+	: ArrowTarget(parent), info(db->getCard(_name)), name(_name), tapped(false)
 {
 	setCursor(Qt::OpenHandCursor);
 	setFlag(ItemIsSelectable);
@@ -51,7 +51,7 @@ void AbstractCardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *
 		}
 		painter->drawPixmap(translatedPixmap->rect(), *translatedPixmap, translatedPixmap->rect());
 	} else {
-		QFont f("Serif");
+		QFont f("Times");
 		f.setStyleHint(QFont::Serif);
 		f.setPixelSize(12);
 		painter->setFont(f);

cockatrice/src/abstractcarditem.h

 #ifndef ABSTRACTCARDITEM_H
 #define ABSTRACTCARDITEM_H
 
-#include "abstractgraphicsitem.h"
+#include "arrowtarget.h"
 
 class CardInfo;
 
 const int CARD_WIDTH = 72;
 const int CARD_HEIGHT = 102;
 
-enum CardItemType {
-	typeCard = QGraphicsItem::UserType + 1,
-	typeCardDrag = QGraphicsItem::UserType + 2,
-	typeZone = QGraphicsItem::UserType + 3,
-	typeOther = QGraphicsItem::UserType + 5
-};
-
-class AbstractCardItem : public QObject, public AbstractGraphicsItem {
+class AbstractCardItem : public QObject, public ArrowTarget {
 	Q_OBJECT
 protected:
 	CardInfo *info;

cockatrice/src/abstractgraphicsitem.h

@@ -3,6 +3,14 @@
 
 #include <QGraphicsItem>
 
+enum GraphicsItemType {
+	typeCard = QGraphicsItem::UserType + 1,
+	typeCardDrag = QGraphicsItem::UserType + 2,
+	typeZone = QGraphicsItem::UserType + 3,
+	typePlayerTarget = QGraphicsItem::UserType + 4,
+	typeOther = QGraphicsItem::UserType + 5
+};
+
 class AbstractGraphicsItem : public QGraphicsItem {
 protected:
 	void paintNumberEllipse(int number, int radius, const QColor &color, int position, int count, QPainter *painter);

cockatrice/src/arrowitem.cpp

 #include "arrowitem.h"
+#include "playertarget.h"
 #include "carditem.h"
 #include "cardzone.h"
 #include "player.h"
@@ -8,7 +9,7 @@
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsScene>
 
-ArrowItem::ArrowItem(Player *_player, int _id, CardItem *_startItem, CardItem *_targetItem, const QColor &_color)
+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);
@@ -96,7 +97,7 @@ void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 		player->sendGameCommand(new Command_DeleteArrow(-1, id));
 }
 
-ArrowDragItem::ArrowDragItem(CardItem *_startItem, const QColor &_color)
+ArrowDragItem::ArrowDragItem(ArrowTarget *_startItem, const QColor &_color)
         : ArrowItem(static_cast<CardZone *>(_startItem->parentItem())->getPlayer(), -1, _startItem, 0, _color)
 {
 }
@@ -111,10 +112,12 @@ void ArrowDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 	QPointF endPos = event->scenePos();
 	
 	QList<QGraphicsItem *> colliding = scene()->items(endPos);
-        CardItem *cursorItem = 0;
+        ArrowTarget *cursorItem = 0;
         for (int i = colliding.size() - 1; i >= 0; i--)
-                if ((cursorItem = qgraphicsitem_cast<CardItem *>(colliding.at(i))))
+                if (qgraphicsitem_cast<PlayerTarget *>(colliding.at(i)) || qgraphicsitem_cast<CardItem *>(colliding.at(i))) {
+			cursorItem = static_cast<ArrowTarget *>(colliding.at(i));
                         break;
+		}
 	if ((cursorItem != targetItem) && targetItem)
 		targetItem->setBeingPointedAt(false);
         if (!cursorItem) {
@@ -139,17 +142,35 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 	if (targetItem && (targetItem != startItem)) {
 		targetItem->setBeingPointedAt(false);
 		CardZone *startZone = static_cast<CardZone *>(startItem->parentItem());
-		CardZone *targetZone = static_cast<CardZone *>(targetItem->parentItem());
-		player->sendGameCommand(new Command_CreateArrow(
-			-1,
-			startZone->getPlayer()->getId(),
-			startZone->getName(),
-			startItem->getId(),
-			targetZone->getPlayer()->getId(),
-			targetZone->getName(),
-			targetItem->getId(),
-			color
-		));
+		// 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());
+			player->sendGameCommand(new Command_CreateArrow(
+				-1,
+				startZone->getPlayer()->getId(),
+				startZone->getName(),
+				startCard->getId(),
+				targetZone->getPlayer()->getId(),
+				targetZone->getName(),
+				targetCard->getId(),
+				color
+			));
+		} else {
+			PlayerTarget *targetPlayer = qgraphicsitem_cast<PlayerTarget *>(targetItem);
+			player->sendGameCommand(new Command_CreateArrow(
+				-1,
+				startZone->getPlayer()->getId(),
+				startZone->getName(),
+				startCard->getId(),
+				static_cast<Player *>(targetPlayer->parentItem())->getId(),
+				QString(),
+				-1,
+				color
+			));
+		}
 	}
 	deleteLater();
 

cockatrice/src/arrowitem.h

@@ -7,6 +7,7 @@ class CardItem;
 class QGraphicsSceneMouseEvent;
 class QMenu;
 class Player;
+class ArrowTarget;
 
 class ArrowItem : public QObject, public QGraphicsItem {
 	Q_OBJECT
@@ -16,12 +17,12 @@ private:
 protected:
 	Player *player;
 	int id;
-	CardItem *startItem, *targetItem;
+	ArrowTarget *startItem, *targetItem;
 	QColor color;
 	bool fullColor;
 	void mousePressEvent(QGraphicsSceneMouseEvent *event);
 public:
-	ArrowItem(Player *_player, int _id, CardItem *_startItem, CardItem *_targetItem, const QColor &color);
+	ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &color);
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 	QRectF boundingRect() const { return path.boundingRect(); }
 	QPainterPath shape() const { return path; }
@@ -29,10 +30,10 @@ public:
 	void updatePath(const QPointF &endPoint);
 	
 	int getId() const { return id; }
-	void setStartItem(CardItem *_item) { startItem = _item; }
-	void setTargetItem(CardItem *_item) { targetItem = _item; }
-	CardItem *getStartItem() const { return startItem; }
-	CardItem *getTargetItem() const { return targetItem; }
+	void setStartItem(ArrowTarget *_item) { startItem = _item; }
+	void setTargetItem(ArrowTarget *_item) { targetItem = _item; }
+	ArrowTarget *getStartItem() const { return startItem; }
+	ArrowTarget *getTargetItem() const { return targetItem; }
 };
 
 class ArrowDragItem : public ArrowItem {
@@ -40,7 +41,7 @@ class ArrowDragItem : public ArrowItem {
 private:
 	QList<ArrowDragItem *> childArrows;
 public:
-	ArrowDragItem(CardItem *_startItem, const QColor &_color);
+	ArrowDragItem(ArrowTarget *_startItem, const QColor &_color);
 	void addChildArrow(ArrowDragItem *childArrow);
 protected:
 	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);

cockatrice/src/arrowtarget.cpp

+#include "arrowtarget.h"
+
+ArrowTarget::ArrowTarget(QGraphicsItem *parent)
+	: AbstractGraphicsItem(parent), beingPointedAt(false)
+{
+}
+
+void ArrowTarget::setBeingPointedAt(bool _beingPointedAt)
+{
+	beingPointedAt = _beingPointedAt;
+	update();
+}

cockatrice/src/arrowtarget.h

+#ifndef ARROWTARGET_H
+#define ARROWTARGET_H
+
+#include "abstractgraphicsitem.h"
+
+class ArrowTarget : public AbstractGraphicsItem {
+private:
+	bool beingPointedAt;
+public:
+	ArrowTarget(QGraphicsItem *parent = 0);
+	void setBeingPointedAt(bool _beingPointedAt);
+	bool getBeingPointedAt() const { return beingPointedAt; }
+};
+
+#endif
\ No newline at end of file

cockatrice/src/carditem.cpp

@@ -12,7 +12,7 @@
 #include "settingscache.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), beingPointedAt(false), dragItem(NULL)
+	: AbstractCardItem(_name, parent), owner(_owner), id(_cardid), attacking(false), facedown(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(NULL)
 {
 	owner->addCard(this);
 
@@ -117,8 +117,8 @@ void CardItem::retranslateUi()
 		aDoesntUntap->setText(tr("Toggle &normal untapping"));
 		aFlip->setText(tr("&Flip"));
 		aClone->setText(tr("&Clone"));
-		aAttach->setText(tr("Attach to card..."));
-		aUnattach->setText(tr("Unattach"));
+		aAttach->setText(tr("&Attach to card..."));
+		aUnattach->setText(tr("Unattac&h"));
 		aSetPT->setText(tr("Set &P/T..."));
 		aSetAnnotation->setText(tr("&Set annotation..."));
 		QStringList counterColors;
@@ -157,7 +157,7 @@ void CardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
 		++i;
 	}
 	if (!pt.isEmpty()) {
-		QFont font("Serif");
+		QFont font("Times");
 		font.setPixelSize(16);
 		painter->setFont(font);
 		QPen pen(Qt::white);
@@ -168,7 +168,7 @@ void CardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
 		
 		painter->drawText(QRectF(0, 0, boundingRect().width() - 5, boundingRect().height() - 5), Qt::AlignRight | Qt::AlignBottom, pt);
 	}
-	if (beingPointedAt)
+	if (getBeingPointedAt())
 		painter->fillRect(boundingRect(), QBrush(QColor(255, 0, 0, 100)));
 	painter->restore();
 }
@@ -214,12 +214,6 @@ void CardItem::setPT(const QString &_pt)
 	update();
 }
 
-void CardItem::setBeingPointedAt(bool _beingPointedAt)
-{
-	beingPointedAt = _beingPointedAt;
-	update();
-}
-
 void CardItem::resetState()
 {
 	attacking = false;
@@ -286,7 +280,7 @@ void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 		QListIterator<QGraphicsItem *> itemIterator(scene()->selectedItems());
 		while (itemIterator.hasNext()) {
 			CardItem *c = qgraphicsitem_cast<CardItem *>(itemIterator.next());
-			if (!c)
+			if (!c || (c == this))
 				continue;
 			if (c->parentItem() != parentItem())
 				continue;

cockatrice/src/carditem.h

@@ -25,7 +25,6 @@ private:
 	bool destroyOnZoneChange;
 	bool doesntUntap;
 	QPoint gridPoint;
-	bool beingPointedAt;
 	CardDragItem *dragItem;
 	
 	QList<QAction *> aAddCounter, aSetCounter, aRemoveCounter;
@@ -62,7 +61,6 @@ public:
 	void setPT(const QString &_pt);
 	bool getDestroyOnZoneChange() const { return destroyOnZoneChange; }
 	void setDestroyOnZoneChange(bool _destroy) { destroyOnZoneChange = _destroy; }
-	void setBeingPointedAt(bool _beingPointedAt);
 	void resetState();
 	void processCardInfo(ServerInfo_Card *info);
 

cockatrice/src/messagelogwidget.cpp

@@ -212,15 +212,23 @@ void MessageLogWidget::logCreateToken(Player *player, QString cardName, QString
 	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))));
 }
 
-void MessageLogWidget::logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard)
-{
-	append(tr("%1 points from %2's %3 to %4's %5.")
-		.arg(sanitizeHtml(player->getName()))
-		.arg(sanitizeHtml(startPlayer->getName()))
-		.arg(sanitizeHtml(startCard))
-		.arg(sanitizeHtml(targetPlayer->getName()))
-		.arg(sanitizeHtml(targetCard))
-	);
+void MessageLogWidget::logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard, bool playerTarget)
+{
+	if (playerTarget)
+		append(tr("%1 points from %2's %3 to %4.")
+			.arg(sanitizeHtml(player->getName()))
+			.arg(sanitizeHtml(startPlayer->getName()))
+			.arg(sanitizeHtml(startCard))
+			.arg(sanitizeHtml(targetPlayer->getName()))
+		);
+	else
+		append(tr("%1 points from %2's %3 to %4's %5.")
+			.arg(sanitizeHtml(player->getName()))
+			.arg(sanitizeHtml(startPlayer->getName()))
+			.arg(sanitizeHtml(startCard))
+			.arg(sanitizeHtml(targetPlayer->getName()))
+			.arg(sanitizeHtml(targetCard))
+		);
 }
 
 void MessageLogWidget::logSetCardCounter(Player *player, QString cardName, int counterId, int value, int oldValue)
@@ -323,7 +331,7 @@ void MessageLogWidget::connectToPlayer(Player *player)
 	connect(player, SIGNAL(logSay(Player *, QString)), this, SLOT(logSay(Player *, QString)));
 	connect(player, SIGNAL(logShuffle(Player *)), this, SLOT(logShuffle(Player *)));
 	connect(player, SIGNAL(logRollDie(Player *, int, int)), this, SLOT(logRollDie(Player *, int, int)));
-	connect(player, SIGNAL(logCreateArrow(Player *, Player *, QString, Player *, QString)), this, SLOT(logCreateArrow(Player *, Player *, QString, Player *, QString)));
+	connect(player, SIGNAL(logCreateArrow(Player *, Player *, QString, Player *, QString, bool)), this, SLOT(logCreateArrow(Player *, Player *, QString, Player *, QString, bool)));
 	connect(player, SIGNAL(logCreateToken(Player *, QString, QString)), this, SLOT(logCreateToken(Player *, QString, QString)));
 	connect(player, SIGNAL(logSetCounter(Player *, QString, int, int)), this, SLOT(logSetCounter(Player *, QString, int, int)));
 	connect(player, SIGNAL(logSetCardCounter(Player *, QString, int, int, int)), this, SLOT(logSetCardCounter(Player *, QString, int, int, int)));

cockatrice/src/messagelogwidget.h

@@ -41,7 +41,7 @@ public slots:
 	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
 	void logDestroyCard(Player *player, QString cardName);
 	void logCreateToken(Player *player, QString cardName, QString pt);
-	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
+	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);
 	void logSetTapped(Player *player, QString cardName, bool tapped);
 	void logSetCounter(Player *player, QString counterName, int value, int oldValue);

cockatrice/src/player.cpp

 #include "player.h"
 #include "client.h"
 #include "cardzone.h"
+#include "playertarget.h"
 #include "counter.h"
 #include "arrowitem.h"
 #include "zoneviewzone.h"
@@ -28,6 +29,9 @@ Player::Player(const QString &_name, int _id, bool _local, Client *_client, TabG
 	connect(settingsCache, SIGNAL(playerBgPathChanged()), this, SLOT(updateBgPixmap()));
 	updateBgPixmap();
 	
+	playerTarget = new PlayerTarget(name, CARD_WIDTH + counterAreaWidth + 5, this);
+	playerTarget->setPos(QPointF(0, 0));
+
 	QPointF base = QPointF(counterAreaWidth, 50);
 
 	PileZone *deck = new PileZone(this, "deck", true, false, this);
@@ -207,6 +211,7 @@ Player::Player(const QString &_name, int _id, bool _local, Client *_client, TabG
 		countersMenu = 0;
 		sbMenu = 0;
 		aCreateAnotherToken = 0;
+		aCardMenu = 0;
 	}
 	
 	rearrangeZones();
@@ -490,7 +495,13 @@ void Player::eventCreateArrows(Event_CreateArrows *event)
 		ArrowItem *arrow = addArrow(eventArrowList[i]);
 		if (!arrow)
 			return;
-		emit logCreateArrow(this, arrow->getStartItem()->getOwner(), arrow->getStartItem()->getName(), arrow->getTargetItem()->getOwner(), arrow->getTargetItem()->getName());
+		
+		CardItem *startCard = static_cast<CardItem *>(arrow->getStartItem());
+		CardItem *targetCard = qgraphicsitem_cast<CardItem *>(arrow->getTargetItem());
+		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);
 	}
 }
 
@@ -722,20 +733,11 @@ QRectF Player::boundingRect() const
 
 void Player::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
 {
-	QString nameStr = getName();
-	QFont font("Times");
-	font.setPixelSize(20);
-//	font.setWeight(QFont::Bold);
-	
 	int totalWidth = CARD_WIDTH + counterAreaWidth + 5;
 	if (bgPixmap.isNull())
 		painter->fillRect(QRectF(0, 0, totalWidth, boundingRect().height()), QColor(200, 200, 200));
 	else
 		painter->fillRect(QRectF(0, 0, totalWidth, boundingRect().height()), QBrush(bgPixmap));
-	
-	painter->setFont(font);
-	painter->setPen(QPen(Qt::black));
-	painter->drawText(QRectF(0, 0, totalWidth, 40), Qt::AlignCenter, nameStr);
 }
 
 void Player::processPlayerInfo(ServerInfo_Player *info)
@@ -827,20 +829,25 @@ ArrowItem *Player::addArrow(ServerInfo_Arrow *arrow)
 	
 	CardZone *startZone = startPlayer->getZones().value(arrow->getStartZone(), 0);
 	CardZone *targetZone = targetPlayer->getZones().value(arrow->getTargetZone(), 0);
-	if (!startZone || !targetZone)
+	if (!startZone || (!targetZone && !arrow->getTargetZone().isEmpty()))
 		return 0;
 	
 	CardItem *startCard = startZone->getCard(arrow->getStartCardId(), QString());
-	CardItem *targetCard = targetZone->getCard(arrow->getTargetCardId(), QString());
-	if (!startCard || !targetCard)
+	CardItem *targetCard = 0;
+	if (targetZone)
+		targetCard = targetZone->getCard(arrow->getTargetCardId(), QString());
+	if (!startCard || (!targetCard && !arrow->getTargetZone().isEmpty()))
 		return 0;
 	
-	return addArrow(arrow->getId(), startCard, targetCard, arrow->getColor());
+	if (targetCard)
+		return addArrow(arrow->getId(), startCard, targetCard, arrow->getColor());
+	else
+		return addArrow(arrow->getId(), startCard, targetPlayer->getPlayerTarget(), arrow->getColor());
 }
 
-ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color)
+ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color)
 {
-	ArrowItem *arrow = new ArrowItem(this, arrowId, startCard, targetCard, color);
+	ArrowItem *arrow = new ArrowItem(this, arrowId, startCard, targetItem, color);
 	arrows.insert(arrowId, arrow);
 	scene()->addItem(arrow);
 	return arrow;
@@ -909,6 +916,7 @@ void Player::cardMenuAction()
 {
 	QAction *a = static_cast<QAction *>(sender());
 	QList<QGraphicsItem *> sel = scene()->selectedItems();
+	QList<Command *> commandList;
 	while (!sel.isEmpty()) {
 		unsigned int i = (unsigned int) (((double) sel.size()) * qrand() / (RAND_MAX + 1.0));
 		CardItem *card = qgraphicsitem_cast<CardItem *>(sel.takeAt(i));
@@ -916,38 +924,39 @@ void Player::cardMenuAction()
 		switch (a->data().toInt()) {
 			case 0:
 				if (!card->getTapped())
-					sendGameCommand(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "tapped", "1"));
+					commandList.append(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "tapped", "1"));
 				break;
 			case 1:
 				if (card->getTapped())
-					sendGameCommand(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "tapped", "0"));
+					commandList.append(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "tapped", "0"));
 				break;
 			case 2:
-				sendGameCommand(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "doesnt_untap", QString::number(!card->getDoesntUntap())));
+				commandList.append(new Command_SetCardAttr(-1, qgraphicsitem_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "doesnt_untap", QString::number(!card->getDoesntUntap())));
 				break;
 			case 3: {
 				QString zone = qgraphicsitem_cast<CardZone *>(card->parentItem())->getName();
-				sendGameCommand(new Command_MoveCard(-1, zone, card->getId(), zone, card->getGridPoint().x(), card->getGridPoint().y(), !card->getFaceDown()));
+				commandList.append(new Command_MoveCard(-1, zone, card->getId(), zone, card->getGridPoint().x(), card->getGridPoint().y(), !card->getFaceDown()));
 				break;
 			}
 			case 4:
-				sendGameCommand(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, static_cast<CardZone *>(card->parentItem())->getName(), card->getName(), card->getColor(), card->getPT(), card->getAnnotation(), card->getDestroyOnZoneChange(), -1, card->getGridPoint().y()));
 				break;
 			case 5:
-				sendGameCommand(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "deck", 0, 0, false));
+				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "deck", 0, 0, false));
 				break;
 			case 6:
-				sendGameCommand(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "deck", -1, 0, false));
+				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "deck", -1, 0, false));
 				break;
 			case 7:
-				sendGameCommand(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "grave", 0, 0, false));
+				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "grave", 0, 0, false));
 				break;
 			case 8:
-				sendGameCommand(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "rfg", 0, 0, false));
+				commandList.append(new Command_MoveCard(-1, static_cast<CardZone *>(card->parentItem())->getName(), card->getId(), "rfg", 0, 0, false));
 				break;
 			default: ;
 		}
 	}
+	sendCommandContainer(new CommandContainer(commandList));
 }
 
 void Player::actSetPT()
@@ -1045,12 +1054,15 @@ void Player::actCardCounterTrigger()
 
 void Player::setCardMenu(QMenu *menu)
 {
-	aCardMenu->setMenu(menu);
+	if (aCardMenu)
+		aCardMenu->setMenu(menu);
 }
 
 QMenu *Player::getCardMenu() const
 {
-	return aCardMenu->menu();
+	if (aCardMenu)
+		return aCardMenu->menu();
+	return 0;
 }
 
 qreal Player::getMinimumWidth() const

cockatrice/src/player.h

@@ -17,6 +17,7 @@ class ArrowItem;
 class CardZone;
 class TableZone;
 class HandZone;
+class PlayerTarget;
 class ServerInfo_Player;
 class ServerInfo_Arrow;
 class ServerInfo_Counter;
@@ -49,7 +50,7 @@ signals:
 	void logSay(Player *player, QString message);
 	void logShuffle(Player *player);
 	void logRollDie(Player *player, int sides, int roll);
-	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
+	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 logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
@@ -90,7 +91,6 @@ public slots:
 	void actCardCounterTrigger();
 
 private slots:
-	
 	void updateBgPixmap();
 	void updateBoundingRect();
 	void rearrangeZones();
@@ -104,9 +104,6 @@ private:
 		*aUntapAll, *aRollDie, *aCreateToken, *aCreateAnotherToken,
 		*aCardMenu;
 
-	typedef void (Player::*CardMenuHandler)(CardItem *card);
-	QHash<QAction *, CardMenuHandler> cardMenuHandlers;
-	
 	int defaultNumberTopCards;
 	QString lastTokenName, lastTokenColor, lastTokenPT, lastTokenAnnotation;
 	bool lastTokenDestroy;
@@ -119,6 +116,7 @@ private:
 	QMap<QString, CardZone *> zones;
 	TableZone *table;
 	HandZone *hand;
+	PlayerTarget *playerTarget;
 	
 	void setCardAttrHelper(CardItem *card, const QString &aname, const QString &avalue, bool allCards);
 
@@ -164,9 +162,10 @@ public:
 	void clearCounters();
 	
 	ArrowItem *addArrow(ServerInfo_Arrow *arrow);
-	ArrowItem *addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color);
+	ArrowItem *addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color);
 	void delArrow(int arrowId);
 	void clearArrows();
+	PlayerTarget *getPlayerTarget() const { return playerTarget; }
 
 	Client *client;
 	Player(const QString &_name, int _id, bool _local, Client *_client, TabGame *_parent);

cockatrice/src/playertarget.cpp

+#include "playertarget.h"
+#include <QPainter>
+
+PlayerTarget::PlayerTarget(const QString &_name, int _maxWidth, QGraphicsItem *parent)
+	: ArrowTarget(parent), name(_name), maxWidth(_maxWidth)
+{
+	font = QFont("Times");
+	font.setStyleHint(QFont::Serif);
+	font.setPixelSize(20);
+}
+
+QRectF PlayerTarget::boundingRect() const
+{
+	return QRectF(0, 0, maxWidth, 30);
+}
+
+void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
+{
+	painter->fillRect(boundingRect(), QColor(255, 255, 255, 100));
+	painter->setFont(font);
+	painter->setPen(Qt::black);
+	painter->drawText(boundingRect(), Qt::AlignCenter, name);
+}

cockatrice/src/playertarget.h

+#ifndef PLAYERTARGET_H
+#define PLAYERTARGET_H
+
+#include "arrowtarget.h"
+#include <QFont>
+
+class PlayerTarget : public ArrowTarget {
+private:
+	QString name;
+	QFont font;
+	int maxWidth;
+public:
+	enum { Type = typePlayerTarget };
+	int type() const { return Type; }
+	
+	PlayerTarget(const QString &_name, int _maxWidth, QGraphicsItem *parent = 0);
+	QRectF boundingRect() const;
+	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+};
+
+#endif
\ No newline at end of file

common/server_arrow.h

@@ -4,18 +4,20 @@
 #include <QColor>
 
 class Server_Card;
+class Server_ArrowTarget;
 
 class Server_Arrow {
 private:
 	int id;
-	Server_Card *startCard, *targetCard;
+	Server_Card *startCard;
+	Server_ArrowTarget *targetItem;
 	QColor color;
 public:
-	Server_Arrow(int _id, Server_Card *_startCard, Server_Card *_targetCard, const QColor &_color)
-		: id(_id), startCard(_startCard), targetCard(_targetCard), color(_color) { }
+	Server_Arrow(int _id, Server_Card *_startCard, Server_ArrowTarget *_targetItem, const QColor &_color)
+		: id(_id), startCard(_startCard), targetItem(_targetItem), color(_color) { }
 	int getId() const { return id; }
 	Server_Card *getStartCard() const { return startCard; }
-	Server_Card *getTargetCard() const { return targetCard; }
+	Server_ArrowTarget *getTargetItem() const { return targetItem; }
 	QColor getColor() const { return color; }
 };
 

common/server_arrowtarget.h

+#ifndef SERVER_ARROWTARGET_H
+#define SERVER_ARROWTARGET_H
+
+#include <QObject>
+
+class Server_ArrowTarget : public QObject {
+	Q_OBJECT
+};
+
+#endif
\ No newline at end of file