PB: enough for today

cockatrice/src/deckview.h

@@ -6,7 +6,6 @@
 #include <QMap>
 #include <QMultiMap>
 #include <QPixmap>
-#include "abstractcarditem.h"
 #include "abstractcarddragitem.h"
 
 class DeckList;

cockatrice/src/handcounter.h

@@ -2,7 +2,7 @@
 #define HANDCOUNTER_H
 
 #include <QString>
-#include "abstractcarditem.h"
+#include "abstractgraphicsitem.h"
 
 class QPainter;
 class QPixmap;

cockatrice/src/player.cpp

@@ -10,6 +10,7 @@
 #include "tablezone.h"
 #include "handzone.h"
 #include "handcounter.h"
+#include "carditem.h"
 #include "cardlist.h"
 #include "tab_game.h"
 #include "gamescene.h"
@@ -34,7 +35,28 @@
 #include "pb/command_create_token.pb.h"
 #include "pb/command_flip_card.pb.h"
 #include "pb/command_game_say.pb.h"
-
+#include "pb/serverinfo_user.pb.h"
+#include "pb/context_move_card.pb.h"
+#include "pb/event_connection_state_changed.pb.h"
+#include "pb/event_game_say.pb.h"
+#include "pb/event_shuffle.pb.h"
+#include "pb/event_roll_die.pb.h"
+#include "pb/event_create_arrow.pb.h"
+#include "pb/event_delete_arrow.pb.h"
+#include "pb/event_create_token.pb.h"
+#include "pb/event_set_card_attr.pb.h"
+#include "pb/event_set_card_counter.pb.h"
+#include "pb/event_create_counter.pb.h"
+#include "pb/event_set_counter.pb.h"
+#include "pb/event_del_counter.pb.h"
+#include "pb/event_dump_zone.pb.h"
+#include "pb/event_stop_dump_zone.pb.h"
+#include "pb/event_move_card.pb.h"
+#include "pb/event_flip_card.pb.h"
+#include "pb/event_destroy_card.pb.h"
+#include "pb/event_attach_card.pb.h"
+#include "pb/event_draw_cards.pb.h"
+#include "pb/event_reveal_cards.pb.h"
 
 PlayerArea::PlayerArea(QGraphicsItem *parentItem)
 	: QObject(), QGraphicsItem(parentItem)
@@ -67,9 +89,12 @@ void PlayerArea::setSize(qreal width, qreal height)
 	bRect = QRectF(0, 0, width, height);
 }
 
-Player::Player(ServerInfo_User *info, int _id, bool _local, TabGame *_parent)
+Player::Player(const ServerInfo_User &info, int _id, bool _local, TabGame *_parent)
-	: QObject(_parent), shortcutsActive(false), defaultNumberTopCards(3), lastTokenDestroy(true), userInfo(new ServerInfo_User(info)), id(_id), active(false), local(_local), mirrored(false), handVisible(false), conceded(false), dialogSemaphore(false)
+	: QObject(_parent), shortcutsActive(false), defaultNumberTopCards(3), lastTokenDestroy(true), id(_id), active(false), local(_local), mirrored(false), handVisible(false), conceded(false), dialogSemaphore(false)
 {
+	userInfo = new ServerInfo_User;
+	userInfo->CopyFrom(info);
+	
 	connect(settingsCache, SIGNAL(horizontalHandChanged()), this, SLOT(rearrangeZones()));
 	
 	playerArea = new PlayerArea(this);
@@ -448,7 +473,7 @@ void Player::retranslateUi()
 {
 	aViewGraveyard->setText(tr("&View graveyard"));
 	aViewRfg->setText(tr("&View exile"));
-	playerMenu->setTitle(tr("Player \"%1\"").arg(userInfo->getName()));
+	playerMenu->setTitle(tr("Player \"%1\"").arg(QString::fromStdString(userInfo->name())));
 	graveMenu->setTitle(tr("&Graveyard"));
 	rfgMenu->setTitle(tr("&Exile"));
 	
@@ -751,9 +776,9 @@ void Player::actSayMessage()
 	sendGameCommand(cmd);
 }
 
-void Player::setCardAttrHelper(GameEventContext *context, CardItem *card, const QString &aname, const QString &avalue, bool allCards)
+void Player::setCardAttrHelper(const GameEventContext &context, CardItem *card, const QString &aname, const QString &avalue, bool allCards)
 {
-	bool moveCardContext = qobject_cast<Context_MoveCard *>(context);
+	bool moveCardContext = context.HasExtension(Context_MoveCard::ext);
 	if (aname == "tapped") {
 		bool tapped = avalue == "1";
 		if (!(!tapped && card->getDoesntUntap() && allCards)) {
@@ -778,147 +803,145 @@ void Player::setCardAttrHelper(GameEventContext *context, CardItem *card, const
 	}
 }
 
-void Player::eventConnectionStateChanged(Event_ConnectionStateChanged *event)
+void Player::eventConnectionStateChanged(const Event_ConnectionStateChanged &event)
 {
-	emit logConnectionStateChanged(this, event->getConnected());
+	emit logConnectionStateChanged(this, event.connected());
 }
 
-void Player::eventSay(Event_Say *event)
+void Player::eventGameSay(const Event_GameSay &event)
 {
-	emit logSay(this, event->getMessage());
+	emit logSay(this, QString::fromStdString(event.message()));
 }
 
-void Player::eventShuffle(Event_Shuffle * /*event*/)
+void Player::eventShuffle(const Event_Shuffle &event)
 {
-	emit logShuffle(this, zones.value("deck"));
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()));
+	if (!zone)
+		return;
+	emit logShuffle(this, zone);
 }
 
-void Player::eventRollDie(Event_RollDie *event)
+void Player::eventRollDie(const Event_RollDie &event)
 {
-	emit logRollDie(this, event->getSides(), event->getValue());
+	emit logRollDie(this, event.sides(), event.value());
 }
 
-void Player::eventCreateArrows(Event_CreateArrows *event)
+void Player::eventCreateArrow(const Event_CreateArrow &event)
 {
-	const QList<ServerInfo_Arrow *> eventArrowList = event->getArrowList();
+	ArrowItem *arrow = addArrow(event.arrow_info());
-	for (int i = 0; i < eventArrowList.size(); ++i) {
+	if (!arrow)
-		ArrowItem *arrow = addArrow(eventArrowList[i]);
+		return;
-		if (!arrow)
+	
-			return;
+	CardItem *startCard = static_cast<CardItem *>(arrow->getStartItem());
-		
+	CardItem *targetCard = qgraphicsitem_cast<CardItem *>(arrow->getTargetItem());
-		CardItem *startCard = static_cast<CardItem *>(arrow->getStartItem());
+	if (targetCard)
-		CardItem *targetCard = qgraphicsitem_cast<CardItem *>(arrow->getTargetItem());
+		emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), targetCard->getOwner(), targetCard->getName(), false);
-		if (targetCard)
+	else
-			emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), targetCard->getOwner(), targetCard->getName(), false);
+		emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), arrow->getTargetItem()->getOwner(), QString(), true);
-		else
-			emit logCreateArrow(this, startCard->getOwner(), startCard->getName(), arrow->getTargetItem()->getOwner(), QString(), true);
-	}
 }
 
-void Player::eventDeleteArrow(Event_DeleteArrow *event)
+void Player::eventDeleteArrow(const Event_DeleteArrow &event)
 {
-	delArrow(event->getArrowId());
+	delArrow(event.arrow_id());
 }
 
-void Player::eventCreateToken(Event_CreateToken *event)
+void Player::eventCreateToken(const Event_CreateToken &event)
 {
-	CardZone *zone = zones.value(event->getZone(), 0);
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
 
-	CardItem *card = new CardItem(this, event->getCardName(), event->getCardId());
+	CardItem *card = new CardItem(this, QString::fromStdString(event.card_name()), event.card_id());
-	card->setColor(event->getColor());
+	card->setColor(QString::fromStdString(event.color()));
-	card->setPT(event->getPt());
+	card->setPT(QString::fromStdString(event.pt()));
-	card->setAnnotation(event->getAnnotation());
+	card->setAnnotation(QString::fromStdString(event.annotation()));
-	card->setDestroyOnZoneChange(event->getDestroyOnZoneChange());
+	card->setDestroyOnZoneChange(event.destroy_on_zone_change());
 
 	emit logCreateToken(this, card->getName(), card->getPT());
-	zone->addCard(card, true, event->getX(), event->getY());
+	zone->addCard(card, true, event.x(), event.y());
 
 }
 
-void Player::eventSetCardAttr(Event_SetCardAttr *event, GameEventContext *context)
+void Player::eventSetCardAttr(const Event_SetCardAttr &event, const GameEventContext &context)
 {
-	CardZone *zone = zones.value(event->getZone(), 0);
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
 
-	if (event->getCardId() == -1) {
+	if (!event.has_card_id()) {
 		const CardList &cards = zone->getCards();
 		for (int i = 0; i < cards.size(); i++)
-			setCardAttrHelper(context, cards.at(i), event->getAttrName(), event->getAttrValue(), true);
+			setCardAttrHelper(context, cards.at(i), QString::fromStdString(event.attr_name()), QString::fromStdString(event.attr_value()), true);
-		if (event->getAttrName() == "tapped")
+		if (event.attr_name() == "tapped")
-			emit logSetTapped(this, 0, event->getAttrValue() == "1");
+			emit logSetTapped(this, 0, event.attr_value() == "1");
 	} else {
-		CardItem *card = zone->getCard(event->getCardId(), QString());
+		CardItem *card = zone->getCard(event.card_id(), QString());
 		if (!card) {
-			qDebug() << "Player::eventSetCardAttr: card id=" << event->getCardId() << "not found";
+			qDebug() << "Player::eventSetCardAttr: card id=" << event.card_id() << "not found";
 			return;
 		}
-		setCardAttrHelper(context, card, event->getAttrName(), event->getAttrValue(), false);
+		setCardAttrHelper(context, card, QString::fromStdString(event.attr_name()), QString::fromStdString(event.attr_value()), false);
 	}
 }
 
-void Player::eventSetCardCounter(Event_SetCardCounter *event)
+void Player::eventSetCardCounter(const Event_SetCardCounter &event)
 {
-	CardZone *zone = zones.value(event->getZone(), 0);
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
 
-	CardItem *card = zone->getCard(event->getCardId(), QString());
+	CardItem *card = zone->getCard(event.card_id(), QString());
 	if (!card)
 		return;
 	
-	int oldValue = card->getCounters().value(event->getCounterId(), 0);
+	int oldValue = card->getCounters().value(event.counter_id(), 0);
-	card->setCounter(event->getCounterId(), event->getCounterValue());
+	card->setCounter(event.counter_id(), event.counter_value());
-	emit logSetCardCounter(this, card->getName(), event->getCounterId(), event->getCounterValue(), oldValue);
+	emit logSetCardCounter(this, card->getName(), event.counter_id(), event.counter_value(), oldValue);
 }
 
-void Player::eventCreateCounters(Event_CreateCounters *event)
+void Player::eventCreateCounter(const Event_CreateCounter &event)
 {
-	const QList<ServerInfo_Counter *> &eventCounterList = event->getCounterList();
+	addCounter(event.counter_info());
-	for (int i = 0; i < eventCounterList.size(); ++i)
-		addCounter(eventCounterList[i]);
 }
 
-void Player::eventSetCounter(Event_SetCounter *event)
+void Player::eventSetCounter(const Event_SetCounter &event)
 {
-	AbstractCounter *c = counters.value(event->getCounterId(), 0);
+	AbstractCounter *c = counters.value(event.counter_id(), 0);
 	if (!c)
 		return;
 	int oldValue = c->getValue();
-	c->setValue(event->getValue());
+	c->setValue(event.value());
-	emit logSetCounter(this, c->getName(), event->getValue(), oldValue);
+	emit logSetCounter(this, c->getName(), event.value(), oldValue);
 }
 
-void Player::eventDelCounter(Event_DelCounter *event)
+void Player::eventDelCounter(const Event_DelCounter &event)
 {
-	delCounter(event->getCounterId());
+	delCounter(event.counter_id());
 }
 
-void Player::eventDumpZone(Event_DumpZone *event)
+void Player::eventDumpZone(const Event_DumpZone &event)
 {
-	Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event->getZoneOwnerId(), 0);
+	Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event.zone_owner_id(), 0);
 	if (!zoneOwner)
 		return;
-	CardZone *zone = zoneOwner->getZones().value(event->getZone(), 0);
+	CardZone *zone = zoneOwner->getZones().value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
-	emit logDumpZone(this, zone, event->getNumberCards());
+	emit logDumpZone(this, zone, event.number_cards());
 }
 
-void Player::eventStopDumpZone(Event_StopDumpZone *event)
+void Player::eventStopDumpZone(const Event_StopDumpZone &event)
 {
-	Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event->getZoneOwnerId(), 0);
+	Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event.zone_owner_id(), 0);
 	if (!zoneOwner)
 		return;
-	CardZone *zone = zoneOwner->getZones().value(event->getZone(), 0);
+	CardZone *zone = zoneOwner->getZones().value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
 	emit logStopDumpZone(this, zone);
 }
 
-void Player::eventMoveCard(Event_MoveCard *event, GameEventContext *context)
+void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *context)
 {
 	CardZone *startZone = zones.value(event->getStartZone(), 0);
 	Player *targetPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event->getTargetPlayerId());
@@ -999,25 +1022,25 @@ void Player::eventMoveCard(Event_MoveCard *event, GameEventContext *context)
 	}
 }
 
-void Player::eventFlipCard(Event_FlipCard *event)
+void Player::eventFlipCard(const Event_FlipCard &event)
 {
-	CardZone *zone = zones.value(event->getZone(), 0);
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
-	CardItem *card = zone->getCard(event->getCardId(), event->getCardName());
+	CardItem *card = zone->getCard(event.card_id(), QString::fromStdString(event.card_name()));
 	if (!card)
 		return;
-	emit logFlipCard(this, card->getName(), event->getFaceDown());
+	emit logFlipCard(this, card->getName(), event.face_down());
-	card->setFaceDown(event->getFaceDown());
+	card->setFaceDown(event.face_down());
 }
 
-void Player::eventDestroyCard(Event_DestroyCard *event)
+void Player::eventDestroyCard(const Event_DestroyCard &event)
 {
-	CardZone *zone = zones.value(event->getZone(), 0);
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()), 0);
 	if (!zone)
 		return;
 	
-	CardItem *card = zone->getCard(event->getCardId(), QString());
+	CardItem *card = zone->getCard(event.card_id(), QString());
 	if (!card)
 		return;
 	
@@ -1027,29 +1050,30 @@ void Player::eventDestroyCard(Event_DestroyCard *event)
 		attachedCards[i]->setAttachedTo(0);
 	
 	emit logDestroyCard(this, card->getName());
-	zone->takeCard(-1, event->getCardId(), true);
+	zone->takeCard(-1, event.card_id(), true);
 	card->deleteLater();
 }
 
-void Player::eventAttachCard(Event_AttachCard *event)
+void Player::eventAttachCard(const 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)
+	if (event.has_target_player_id()) {
-		targetPlayer = playerList.value(targetPlayerId, 0);
+		targetPlayer = playerList.value(event.target_player_id(), 0);
-	if (targetPlayer)
+		if (targetPlayer) {
-		targetZone = targetPlayer->getZones().value(event->getTargetZone(), 0);
+			targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
-	if (targetZone)
+			if (targetZone)
-		targetCard = targetZone->getCard(event->getTargetCardId(), QString());
+				targetCard = targetZone->getCard(event.target_card_id(), QString());
+		}
+	}
 	
-	CardZone *startZone = getZones().value(event->getStartZone(), 0);
+	CardZone *startZone = getZones().value(QString::fromStdString(event.start_zone()), 0);
 	if (!startZone)
 		return;
 	
-	CardItem *startCard = startZone->getCard(event->getCardId(), QString());
+	CardItem *startCard = startZone->getCard(event.card_id(), QString());
 	if (!startCard)
 		return;
 	
@@ -1069,7 +1093,7 @@ void Player::eventAttachCard(Event_AttachCard *event)
 		emit logUnattachCard(this, startCard->getName());
 }
 
-void Player::eventDrawCards(Event_DrawCards *event)
+void Player::eventDrawCards(const Event_DrawCards &event)
 {
 	CardZone *deck = zones.value("deck");
 	CardZone *hand = zones.value("hand");
@@ -1266,9 +1290,9 @@ void Player::addZone(CardZone *z)
 	zones.insert(z->getName(), z);
 }
 
-AbstractCounter *Player::addCounter(ServerInfo_Counter *counter)
+AbstractCounter *Player::addCounter(const ServerInfo_Counter &counter)
 {
-	return addCounter(counter->getId(), counter->getName(), counter->getColor().getQColor(), counter->getRadius(), counter->getCount());
+	return addCounter(counter.id(), QString::fromStdString(counter.name()), counter.color(), counter.radius(), counter.count());
 }
 
 AbstractCounter *Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
@@ -1312,7 +1336,7 @@ void Player::clearCounters()
 	playerTarget->delCounter();
 }
 
-ArrowItem *Player::addArrow(ServerInfo_Arrow *arrow)
+ArrowItem *Player::addArrow(const ServerInfo_Arrow &arrow)
 {
 	const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
 	Player *startPlayer = playerList.value(arrow->getStartPlayerId(), 0);

cockatrice/src/player.h

@@ -4,7 +4,7 @@
 #include <QInputDialog>
 #include <QPoint>
 #include <QMap>
-#include "carditem.h"
+#include "abstractgraphicsitem.h"
 #include <google/protobuf/message.h>
 
 class CardDatabase;
@@ -13,6 +13,9 @@ class QAction;
 class ZoneViewZone;
 class TabGame;
 class AbstractCounter;
+class AbstractCardItem;
+class CardItem;
+class ArrowTarget;
 class ArrowItem;
 class CardZone;
 class StackZone;
@@ -28,15 +31,15 @@ class GameCommand;
 class GameEvent;
 class GameEventContext;
 class Event_ConnectionStateChanged;
-class Event_Say;
+class Event_GameSay;
 class Event_Shuffle;
 class Event_RollDie;
-class Event_CreateArrows;
+class Event_CreateArrow;
 class Event_DeleteArrow;
 class Event_CreateToken;
 class Event_SetCardAttr;
 class Event_SetCardCounter;
-class Event_CreateCounters;
+class Event_CreateCounter;
 class Event_SetCounter;
 class Event_DelCounter;
 class Event_DumpZone;
@@ -170,7 +173,7 @@ private:
 	HandZone *hand;
 	PlayerTarget *playerTarget;
 	
-	void setCardAttrHelper(GameEventContext *context, CardItem *card, const QString &aname, const QString &avalue, bool allCards);
+	void setCardAttrHelper(const GameEventContext &context, CardItem *card, const QString &aname, const QString &avalue, bool allCards);
 
 	QRectF bRect;
 
@@ -180,26 +183,26 @@ private:
 	
 	void initSayMenu();
 	
-	void eventConnectionStateChanged(Event_ConnectionStateChanged *event);
+	void eventConnectionStateChanged(const Event_ConnectionStateChanged &event);
-	void eventSay(Event_Say *event);
+	void eventGameSay(const Event_GameSay &event);
-	void eventShuffle(Event_Shuffle *event);
+	void eventShuffle(const Event_Shuffle &event);
-	void eventRollDie(Event_RollDie *event);
+	void eventRollDie(const Event_RollDie &event);
-	void eventCreateArrows(Event_CreateArrows *event);
+	void eventCreateArrow(const Event_CreateArrow &event);
-	void eventDeleteArrow(Event_DeleteArrow *event);
+	void eventDeleteArrow(const Event_DeleteArrow &event);
-	void eventCreateToken(Event_CreateToken *event);
+	void eventCreateToken(const Event_CreateToken &event);
-	void eventSetCardAttr(Event_SetCardAttr *event, GameEventContext *context);
+	void eventSetCardAttr(const Event_SetCardAttr &event, const GameEventContext &context);
-	void eventSetCardCounter(Event_SetCardCounter *event);
+	void eventSetCardCounter(const Event_SetCardCounter &event);
-	void eventCreateCounters(Event_CreateCounters *event);
+	void eventCreateCounter(const Event_CreateCounter &event);
-	void eventSetCounter(Event_SetCounter *event);
+	void eventSetCounter(const Event_SetCounter &event);
-	void eventDelCounter(Event_DelCounter *event);
+	void eventDelCounter(const Event_DelCounter &event);
-	void eventDumpZone(Event_DumpZone *event);
+	void eventDumpZone(const Event_DumpZone &event);
-	void eventStopDumpZone(Event_StopDumpZone *event);
+	void eventStopDumpZone(const Event_StopDumpZone &event);
-	void eventMoveCard(Event_MoveCard *event, GameEventContext *context);
+	void eventMoveCard(const Event_MoveCard &event, GameEventContext &context);
-	void eventFlipCard(Event_FlipCard *event);
+	void eventFlipCard(const Event_FlipCard &event);
-	void eventDestroyCard(Event_DestroyCard *event);
+	void eventDestroyCard(const Event_DestroyCard &event);
-	void eventAttachCard(Event_AttachCard *event);
+	void eventAttachCard(const Event_AttachCard &event);
-	void eventDrawCards(Event_DrawCards *event);
+	void eventDrawCards(const Event_DrawCards &event);
-	void eventRevealCards(Event_RevealCards *event);
+	void eventRevealCards(const Event_RevealCards &event);
 public:
 	static const int counterAreaWidth = 55;
 	
@@ -213,19 +216,19 @@ public:
 	void deleteCard(CardItem *c);
 	void addZone(CardZone *z);
 
-	AbstractCounter *addCounter(ServerInfo_Counter *counter);
+	AbstractCounter *addCounter(const ServerInfo_Counter &counter);
 	AbstractCounter *addCounter(int counterId, const QString &name, QColor color, int radius, int value);
 	void delCounter(int counterId);
 	void clearCounters();
 	
-	ArrowItem *addArrow(ServerInfo_Arrow *arrow);
+	ArrowItem *addArrow(const ServerInfo_Arrow &arrow);
 	ArrowItem *addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color);
 	void delArrow(int arrowId);
 	void removeArrow(ArrowItem *arrow);
 	void clearArrows();
 	PlayerTarget *getPlayerTarget() const { return playerTarget; }
 
-	Player(ServerInfo_User *info, int _id, bool _local, TabGame *_parent);
+	Player(const ServerInfo_User &info, int _id, bool _local, TabGame *_parent);
 	~Player();
 	void retranslateUi();
 	void clear();

cockatrice/src/tablezone.h

@@ -2,6 +2,7 @@
 #define TABLEZONE_H
 
 #include "selectzone.h"
+#include "abstractcarditem.h"
 
 class TableZone : public SelectZone {
 	Q_OBJECT

common/pb/proto/event_shuffle.proto

@@ -4,4 +4,5 @@ message Event_Shuffle {
 	extend GameEvent {
 		optional Event_Shuffle ext = 2007;
 	}
+	optional string zone_name = 1;
 }

common/server_protocolhandler.cpp

@@ -979,7 +979,10 @@ Response::ResponseCode Server_ProtocolHandler::cmdShuffle(const Command_Shuffle
 		
 	player->getZones().value("deck")->shuffle();
 	
-	ges.enqueueGameEvent(Event_Shuffle(), player->getPlayerId());
+	Event_Shuffle event;
+	event.set_zone_name("deck");
+	ges.enqueueGameEvent(event, player->getPlayerId());
+	
 	return Response::RespOk;
 }