PB: everything compiles except for deck storage

cockatrice/cockatrice.pro

@@ -5,6 +5,8 @@ INCLUDEPATH += . src ../common
 MOC_DIR = build
 OBJECTS_DIR = build
 RESOURCES = cockatrice.qrc
+QMAKE_CXXFLAGS_RELEASE += -O2
+CPPFLAGS += -O2
 QT += network script svg
 LIBS += -lprotobuf
 unix:!macx {
@@ -84,6 +86,7 @@ HEADERS += src/abstractcounter.h \
  src/priceupdater.h \
  src/soundengine.h \
  src/pending_command.h \
+ 	../common/get_pb_extension.h \
  	../common/color.h \
  	../common/serializable_item.h \
 	../common/decklist.h \
@@ -168,6 +171,7 @@ SOURCES += src/abstractcounter.cpp \
  src/localclient.cpp \
  src/priceupdater.cpp \
  src/soundengine.cpp \
+ 	../common/get_pb_extension.cpp \
  	../common/serializable_item.cpp \
 	../common/decklist.cpp \
 	../common/protocol.cpp \

cockatrice/src/abstractclient.cpp

@@ -14,6 +14,7 @@
 #include "pb/event_user_joined.pb.h"
 #include "pb/event_user_left.pb.h"
 #include "pb/event_game_joined.pb.h"
+#include "get_pb_extension.h"
 #include <google/protobuf/descriptor.h>
 
 AbstractClient::AbstractClient(QObject *parent)
@@ -42,15 +43,7 @@ void AbstractClient::processProtocolItem(const ServerMessage &item)
 		}
 		case ServerMessage::SESSION_EVENT: {
 			const SessionEvent &event = item.session_event();
-			std::vector< const ::google::protobuf::FieldDescriptor * > fieldList;
-			event.GetReflection()->ListFields(event, &fieldList);
-			int num = 0;
-			for (unsigned int j = 0; j < fieldList.size(); ++j)
-				if (fieldList[j]->is_extension()) {
-					num = fieldList[j]->number();
-					break;
-				}
-			switch ((SessionEvent::SessionEventType) num) {
+			switch ((SessionEvent::SessionEventType) getPbExtension(event)) {
 				case SessionEvent::SERVER_IDENTIFICATION: emit serverIdentificationEventReceived(event.GetExtension(Event_ServerIdentification::ext)); break;
 				case SessionEvent::SERVER_MESSAGE: emit serverMessageEventReceived(event.GetExtension(Event_ServerMessage::ext)); break;
 				case SessionEvent::SERVER_SHUTDOWN: emit serverShutdownEventReceived(event.GetExtension(Event_ServerShutdown::ext)); break;

cockatrice/src/arrowitem.cpp

@@ -10,7 +10,6 @@
 #include <QDebug>
 
 #include "color.h"
-// XXX
 #include "pb/command_attach_card.pb.h"
 #include "pb/command_create_arrow.pb.h"
 #include "pb/command_delete_arrow.pb.h"
@@ -207,7 +206,7 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 		CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
 
 		Command_CreateArrow cmd;
-		cmd.mutable_arrow_color()->CopyFrom(Color(color).get_color()); // XXX
+		cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(color));
 		cmd.set_start_player_id(startZone->getPlayer()->getId());
 		cmd.set_start_zone(startZone->getName().toStdString());
 		cmd.set_start_card_id(startCard->getId());

cockatrice/src/carditem.cpp

@@ -14,6 +14,7 @@
 #include "main.h"
 #include "settingscache.h"
 #include "tab_game.h"
+#include "pb/serverinfo_card.pb.h"
 
 CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, bool _revealedCard, QGraphicsItem *parent)
 	: AbstractCardItem(_name, _owner, parent), zone(0), id(_cardid), revealedCard(_revealedCard), attacking(false), facedown(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(0), attachedTo(0)
@@ -373,23 +374,25 @@ void CardItem::resetState()
 	update();
 }
 
-void CardItem::processCardInfo(ServerInfo_Card *info)
+void CardItem::processCardInfo(const ServerInfo_Card &info)
 {
 	counters.clear();
-	const QList<ServerInfo_CardCounter *> &_counterList = info->getCounters();
-	for (int i = 0; i < _counterList.size(); ++i)
-		counters.insert(_counterList[i]->getId(), _counterList[i]->getValue());
+	const int counterListSize = info.counter_list_size();
+	for (int i = 0; i < counterListSize; ++i) {
+		const ServerInfo_CardCounter &counterInfo = info.counter_list(i);
+		counters.insert(counterInfo.id(), counterInfo.value());
+	}
 	
-	setId(info->getId());
-	setName(info->getName());
-	setAttacking(info->getAttacking());
-	setFaceDown(info->getFaceDown());
-	setPT(info->getPT());
-	setAnnotation(info->getAnnotation());
-	setColor(info->getColor());
-	setTapped(info->getTapped());
-	setDestroyOnZoneChange(info->getDestroyOnZoneChange());
-	setDoesntUntap(info->getDoesntUntap());
+	setId(info.id());
+	setName(QString::fromStdString(info.name()));
+	setAttacking(info.attacking());
+	setFaceDown(info.face_down());
+	setPT(QString::fromStdString(info.pt()));
+	setAnnotation(QString::fromStdString(info.annotation()));
+	setColor(QString::fromStdString(info.color()));
+	setTapped(info.tapped());
+	setDestroyOnZoneChange(info.destroy_on_zone_change());
+	setDoesntUntap(info.doesnt_untap());
 }
 
 CardDragItem *CardItem::createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown)

cockatrice/src/carditem.h

@@ -96,7 +96,7 @@ public:
 	void removeAttachedCard(CardItem *card) { attachedCards.removeAt(attachedCards.indexOf(card)); }
 	const QList<CardItem *> &getAttachedCards() const { return attachedCards; }
 	void resetState();
-	void processCardInfo(ServerInfo_Card *info);
+	void processCardInfo(const ServerInfo_Card &info);
 	void updateCardMenu();
 
 	bool animationEvent();

cockatrice/src/gamescene.cpp

@@ -4,6 +4,7 @@
 #include "zoneviewzone.h"
 #include "phasestoolbar.h"
 #include "settingscache.h"
+#include "carditem.h"
 #include <math.h>
 #include <QAction>
 #include <QGraphicsSceneMouseEvent>
@@ -127,7 +128,7 @@ void GameScene::toggleZoneView(Player *player, const QString &zoneName, int numb
 	item->setPos(50, 50);
 }
 
-void GameScene::addRevealedZoneView(Player *player, CardZone *zone, const QList<ServerInfo_Card *> &cardList)
+void GameScene::addRevealedZoneView(Player *player, CardZone *zone, const QList<const ServerInfo_Card *> &cardList)
 {
 	ZoneViewWidget *item = new ZoneViewWidget(player, zone, -2, true, cardList);
 	zoneViews.append(item);

cockatrice/src/gamescene.h

@@ -45,7 +45,7 @@ public:
 	void unregisterAnimationItem(AbstractCardItem *card);
 public slots:
 	void toggleZoneView(Player *player, const QString &zoneName, int numberCards);
-	void addRevealedZoneView(Player *player, CardZone *zone, const QList<ServerInfo_Card *> &cardList);
+	void addRevealedZoneView(Player *player, CardZone *zone, const QList<const ServerInfo_Card *> &cardList);
 	void removeZoneView(ZoneViewWidget *item);
 	void addPlayer(Player *player);
 	void removePlayer(Player *player);

cockatrice/src/handzone.cpp

@@ -3,6 +3,7 @@
 #include "settingscache.h"
 #include "player.h"
 #include "carddragitem.h"
+#include "carditem.h"
 
 #include "pb/command_move_card.pb.h"
 

cockatrice/src/messagelogwidget.cpp

 #include "messagelogwidget.h"
 #include "player.h"
 #include "cardzone.h"
+#include "carditem.h"
 #include "soundengine.h"
 #include "pb/serverinfo_user.pb.h"
 #include "pb/context_move_card.pb.h"

cockatrice/src/phasestoolbar.h

@@ -4,8 +4,8 @@
 #include <QFrame>
 #include <QList>
 #include <QGraphicsObject>
-#include <google/protobuf/message.h>
 
+namespace google { namespace protobuf { class Message; } }
 class Player;
 class GameCommand;
 

cockatrice/src/pilezone.cpp

@@ -5,6 +5,7 @@
 #include "player.h"
 #include "carddragitem.h"
 #include "zoneviewzone.h"
+#include "carditem.h"
 
 #include "pb/command_move_card.pb.h"
 

cockatrice/src/player.cpp

@@ -17,6 +17,7 @@
 #include "settingscache.h"
 #include "dlg_create_token.h"
 #include "carddatabase.h"
+#include "color.h"
 #include <QSettings>
 #include <QPainter>
 #include <QMenu>
@@ -36,7 +37,10 @@
 #include "pb/command_flip_card.pb.h"
 #include "pb/command_game_say.pb.h"
 #include "pb/serverinfo_user.pb.h"
+#include "pb/serverinfo_player.pb.h"
+#include "pb/serverinfo_zone.pb.h"
 #include "pb/context_move_card.pb.h"
+#include "pb/context_undo_draw.pb.h"
 #include "pb/event_connection_state_changed.pb.h"
 #include "pb/event_game_say.pb.h"
 #include "pb/event_shuffle.pb.h"
@@ -941,30 +945,34 @@ void Player::eventStopDumpZone(const Event_StopDumpZone &event)
 	emit logStopDumpZone(this, zone);
 }
 
-void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *context)
+void Player::eventMoveCard(const Event_MoveCard &event, const GameEventContext &context)
 {
-	CardZone *startZone = zones.value(event->getStartZone(), 0);
-	Player *targetPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event->getTargetPlayerId());
+	CardZone *startZone = zones.value(QString::fromStdString(event.start_zone()), 0);
+	Player *targetPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event.target_player_id());
 	if (!targetPlayer)
 		return;
-	CardZone *targetZone = targetPlayer->getZones().value(event->getTargetZone(), 0);
+	CardZone *targetZone;
+	if (event.has_target_zone())
+		targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
+	else
+		targetZone = startZone;
 	if (!startZone || !targetZone)
 		return;
 	
-	int position = event->getPosition();
-	int x = event->getX();
-	int y = event->getY();
+	int position = event.position();
+	int x = event.x();
+	int y = event.y();
 
 	int logPosition = position;
 	int logX = x;
 	if (x == -1)
 		x = 0;
-	CardItem *card = startZone->takeCard(position, event->getCardId(), startZone != targetZone);
+	CardItem *card = startZone->takeCard(position, event.card_id(), startZone != targetZone);
 	if (!card)
 		return;
 	if (startZone != targetZone)
 		card->deleteCardInfoPopup();
-	card->setName(event->getCardName());
+	card->setName(QString::fromStdString(event.card_name()));
 	
 	if (card->getAttachedTo() && (startZone != targetZone)) {
 		CardItem *parentCard = card->getAttachedTo();
@@ -974,8 +982,8 @@ void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *contex
 
 	card->deleteDragItem();
 
-	card->setId(event->getNewCardId());
-	card->setFaceDown(event->getFaceDown());
+	card->setId(event.new_card_id());
+	card->setFaceDown(event.face_down());
 	if (startZone != targetZone) {
 		card->setBeingPointedAt(false);
 		card->setHovered(false);
@@ -990,11 +998,8 @@ void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *contex
 
 	// The log event has to be sent before the card is added to the target zone
 	// because the addCard function can modify the card object.
-	if (context)
-		switch (context->getItemId()) {
-			case ItemId_Context_UndoDraw: emit logUndoDraw(this, card->getName()); break;
-			default: emit logMoveCard(this, card, startZone, logPosition, targetZone, logX);
-		}
+	if (context.HasExtension(Context_UndoDraw::ext))
+		emit logUndoDraw(this, card->getName());
 	else
 		emit logMoveCard(this, card, startZone, logPosition, targetZone, logX);
 
@@ -1097,68 +1102,76 @@ void Player::eventDrawCards(const Event_DrawCards &event)
 {
 	CardZone *deck = zones.value("deck");
 	CardZone *hand = zones.value("hand");
-	const QList<ServerInfo_Card *> &cardList = event->getCardList();
-	if (!cardList.isEmpty())
-		for (int i = 0; i < cardList.size(); ++i) {
-			CardItem *card = deck->takeCard(0, cardList[i]->getId());
-			card->setName(cardList[i]->getName());
+	
+	const int listSize = event.cards_size();
+	if (listSize) {
+		for (int i = 0; i < listSize; ++i) {
+			const ServerInfo_Card &cardInfo = event.cards(i);
+			CardItem *card = deck->takeCard(0, cardInfo.id());
+			card->setName(QString::fromStdString(cardInfo.name()));
 			hand->addCard(card, false, -1);
 		}
-	else
-		for (int i = 0; i < event->getNumberCards(); ++i)
+	} else {
+		const int number = event.number();
+		for (int i = 0; i < number; ++i)
 			hand->addCard(deck->takeCard(0, -1), false, -1);
+	}
 	
 	hand->reorganizeCards();
 	deck->reorganizeCards();
-	emit logDrawCards(this, event->getNumberCards());
+	emit logDrawCards(this, event.number());
 }
 
-void Player::eventRevealCards(Event_RevealCards *event)
+void Player::eventRevealCards(const Event_RevealCards &event)
 {
-	CardZone *zone = zones.value(event->getZoneName());
+	CardZone *zone = zones.value(QString::fromStdString(event.zone_name()));
 	if (!zone)
 		return;
 	Player *otherPlayer = 0;
-	if (event->getOtherPlayerId() != -1) {
-		otherPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event->getOtherPlayerId());
+	if (event.has_other_player_id()) {
+		otherPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event.other_player_id());
 		if (!otherPlayer)
 			return;
 	}
 	
-	QList<ServerInfo_Card *> cardList = event->getCardList();
+	QList<const ServerInfo_Card *> cardList;
+	const int cardListSize = event.cards_size();
+	for (int i = 0; i < cardListSize; ++i) {
+		const ServerInfo_Card *temp = &event.cards(i);
+		cardList.append(temp);
+	}
 	if (!cardList.isEmpty())
 		static_cast<GameScene *>(scene())->addRevealedZoneView(this, zone, cardList);
 	
 	QString cardName;
 	if (cardList.size() == 1)
-		cardName = cardList.first()->getName();
-	emit logRevealCards(this, zone, event->getCardId(), cardName, otherPlayer);
-}
-
-void Player::processGameEvent(GameEvent *event, GameEventContext *context)
-{
-	qDebug() << "player event: id=" << event->getItemId();
-	switch (event->getItemId()) {
-		case ItemId_Event_ConnectionStateChanged: eventConnectionStateChanged(static_cast<Event_ConnectionStateChanged *>(event)); break;
-		case ItemId_Event_Say: eventSay(static_cast<Event_Say *>(event)); break;
-		case ItemId_Event_Shuffle: eventShuffle(static_cast<Event_Shuffle *>(event)); break;
-		case ItemId_Event_RollDie: eventRollDie(static_cast<Event_RollDie *>(event)); break;
-		case ItemId_Event_CreateArrows: eventCreateArrows(static_cast<Event_CreateArrows *>(event)); break;
-		case ItemId_Event_DeleteArrow: eventDeleteArrow(static_cast<Event_DeleteArrow *>(event)); break;
-		case ItemId_Event_CreateToken: eventCreateToken(static_cast<Event_CreateToken *>(event)); break;
-		case ItemId_Event_SetCardAttr: eventSetCardAttr(static_cast<Event_SetCardAttr *>(event), context); break;
-		case ItemId_Event_SetCardCounter: eventSetCardCounter(static_cast<Event_SetCardCounter *>(event)); break;
-		case ItemId_Event_CreateCounters: eventCreateCounters(static_cast<Event_CreateCounters *>(event)); break;
-		case ItemId_Event_SetCounter: eventSetCounter(static_cast<Event_SetCounter *>(event)); break;
-		case ItemId_Event_DelCounter: eventDelCounter(static_cast<Event_DelCounter *>(event)); break;
-		case ItemId_Event_DumpZone: eventDumpZone(static_cast<Event_DumpZone *>(event)); break;
-		case ItemId_Event_StopDumpZone: eventStopDumpZone(static_cast<Event_StopDumpZone *>(event)); break;
-		case ItemId_Event_MoveCard: eventMoveCard(static_cast<Event_MoveCard *>(event), context); break;
-		case ItemId_Event_FlipCard: eventFlipCard(static_cast<Event_FlipCard *>(event)); break;
-		case ItemId_Event_DestroyCard: eventDestroyCard(static_cast<Event_DestroyCard *>(event)); break;
-		case ItemId_Event_AttachCard: eventAttachCard(static_cast<Event_AttachCard *>(event)); break;
-		case ItemId_Event_DrawCards: eventDrawCards(static_cast<Event_DrawCards *>(event)); break;
-		case ItemId_Event_RevealCards: eventRevealCards(static_cast<Event_RevealCards *>(event)); break;
+		cardName = QString::fromStdString(cardList.first()->name());
+	emit logRevealCards(this, zone, event.card_id(), cardName, otherPlayer);
+}
+
+void Player::processGameEvent(GameEvent::GameEventType type, const GameEvent &event, const GameEventContext &context)
+{
+	switch (type) {
+		case GameEvent::CONNECTION_STATE_CHANGED: eventConnectionStateChanged(event.GetExtension(Event_ConnectionStateChanged::ext)); break;
+		case GameEvent::GAME_SAY: eventGameSay(event.GetExtension(Event_GameSay::ext)); break;
+		case GameEvent::SHUFFLE: eventShuffle(event.GetExtension(Event_Shuffle::ext)); break;
+		case GameEvent::ROLL_DIE: eventRollDie(event.GetExtension(Event_RollDie::ext)); break;
+		case GameEvent::CREATE_ARROW: eventCreateArrow(event.GetExtension(Event_CreateArrow::ext)); break;
+		case GameEvent::DELETE_ARROW: eventDeleteArrow(event.GetExtension(Event_DeleteArrow::ext)); break;
+		case GameEvent::CREATE_TOKEN: eventCreateToken(event.GetExtension(Event_CreateToken::ext)); break;
+		case GameEvent::SET_CARD_ATTR: eventSetCardAttr(event.GetExtension(Event_SetCardAttr::ext), context); break;
+		case GameEvent::SET_CARD_COUNTER: eventSetCardCounter(event.GetExtension(Event_SetCardCounter::ext)); break;
+		case GameEvent::CREATE_COUNTER: eventCreateCounter(event.GetExtension(Event_CreateCounter::ext)); break;
+		case GameEvent::SET_COUNTER: eventSetCounter(event.GetExtension(Event_SetCounter::ext)); break;
+		case GameEvent::DEL_COUNTER: eventDelCounter(event.GetExtension(Event_DelCounter::ext)); break;
+		case GameEvent::DUMP_ZONE: eventDumpZone(event.GetExtension(Event_DumpZone::ext)); break;
+		case GameEvent::STOP_DUMP_ZONE: eventStopDumpZone(event.GetExtension(Event_StopDumpZone::ext)); break;
+		case GameEvent::MOVE_CARD: eventMoveCard(event.GetExtension(Event_MoveCard::ext), context); break;
+		case GameEvent::FLIP_CARD: eventFlipCard(event.GetExtension(Event_FlipCard::ext)); break;
+		case GameEvent::DESTROY_CARD: eventDestroyCard(event.GetExtension(Event_DestroyCard::ext)); break;
+		case GameEvent::ATTACH_CARD: eventAttachCard(event.GetExtension(Event_AttachCard::ext)); break;
+		case GameEvent::DRAW_CARDS: eventDrawCards(event.GetExtension(Event_DrawCards::ext)); break;
+		case GameEvent::REVEAL_CARDS: eventRevealCards(event.GetExtension(Event_RevealCards::ext)); break;
 		default: {
 			qDebug() << "unhandled game event";
 		}
@@ -1181,7 +1194,7 @@ void Player::paint(QPainter * /*painter*/, const QStyleOptionGraphicsItem */*opt
 {
 }
 
-void Player::processPlayerInfo(ServerInfo_Player *info)
+void Player::processPlayerInfo(const ServerInfo_Player &info)
 {
 	clearCounters();
 	clearArrows();
@@ -1189,55 +1202,55 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
 	QMapIterator<QString, CardZone *> zoneIt(zones);
 	while (zoneIt.hasNext())
 		zoneIt.next().value()->clearContents();
-
-	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);
+	
+	const int zoneListSize = info.zone_list_size();
+	for (int i = 0; i < zoneListSize; ++i) {
+		const ServerInfo_Zone &zoneInfo = info.zone_list(i);
+		CardZone *zone = zones.value(QString::fromStdString(zoneInfo.name()), 0);
 		if (!zone)
 			continue;
-
-		const QList<ServerInfo_Card *> &cardList = zoneInfo->getCardList();
-		if (cardList.isEmpty()) {
-			for (int j = 0; j < zoneInfo->getCardCount(); ++j)
+		
+		const int cardListSize = zoneInfo.card_list_size();
+		if (!cardListSize) {
+			for (int j = 0; j < zoneInfo.card_count(); ++j)
 				zone->addCard(new CardItem(this), false, -1);
 		} else {
-			for (int j = 0; j < cardList.size(); ++j) {
+			for (int j = 0; j < cardListSize; ++j) {
+				const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
 				CardItem *card = new CardItem(this);
-				card->processCardInfo(cardList[j]);
-				zone->addCard(card, false, cardList[j]->getX(), cardList[j]->getY());
+				card->processCardInfo(cardInfo);
+				zone->addCard(card, false, cardInfo.x(), cardInfo.y());
 			}
 		}
 		zone->reorganizeCards();
 	}
-
-	QList<ServerInfo_Counter *> cl = info->getCounterList();
-	for (int i = 0; i < cl.size(); ++i) {
-		addCounter(cl.at(i));
-	}
-
-	QList<ServerInfo_Arrow *> al = info->getArrowList();
-	for (int i = 0; i < al.size(); ++i)
-		addArrow(al.at(i));
-
-	setConceded(info->getProperties()->getConceded());
+	
+	const int counterListSize = info.counter_list_size();
+	for (int i = 0; i < counterListSize; ++i)
+		addCounter(info.counter_list(i));
+	
+	const int arrowListSize = info.arrow_list_size();
+	for (int i = 0; i < arrowListSize; ++i)
+		addArrow(info.arrow_list(i));
+	
+	setConceded(info.properties().conceded());
 }
 
-void Player::processCardAttachment(ServerInfo_Player *info)
+void Player::processCardAttachment(const 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);
+	const int zoneListSize = info.zone_list_size();
+	for (int i = 0; i < zoneListSize; ++i) {
+		const ServerInfo_Zone &zoneInfo = info.zone_list(i);
+		CardZone *zone = zones.value(QString::fromStdString(zoneInfo.name()), 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());
+		
+		const int cardListSize = zoneInfo.card_list_size();
+		for (int j = 0; j < cardListSize; ++j) {
+			const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
+			if (cardInfo.has_attach_player_id()) {
+				CardItem *startCard = zone->getCard(cardInfo.id(), QString());
+				CardItem *targetCard = static_cast<TabGame *>(parent())->getCard(cardInfo.attach_player_id(), QString::fromStdString(cardInfo.attach_zone()), cardInfo.attach_card_id());
 				if (!targetCard)
 					continue;
 				
@@ -1292,7 +1305,7 @@ void Player::addZone(CardZone *z)
 
 AbstractCounter *Player::addCounter(const ServerInfo_Counter &counter)
 {
-	return addCounter(counter.id(), QString::fromStdString(counter.name()), counter.color(), counter.radius(), counter.count());
+	return addCounter(counter.id(), QString::fromStdString(counter.name()), convertColorToQColor(counter.counter_color()), counter.radius(), counter.count());
 }
 
 AbstractCounter *Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
@@ -1339,27 +1352,29 @@ void Player::clearCounters()
 ArrowItem *Player::addArrow(const ServerInfo_Arrow &arrow)
 {
 	const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
-	Player *startPlayer = playerList.value(arrow->getStartPlayerId(), 0);
-	Player *targetPlayer = playerList.value(arrow->getTargetPlayerId(), 0);
+	Player *startPlayer = playerList.value(arrow.start_player_id(), 0);
+	Player *targetPlayer = playerList.value(arrow.target_player_id(), 0);
 	if (!startPlayer || !targetPlayer)
 		return 0;
 	
-	CardZone *startZone = startPlayer->getZones().value(arrow->getStartZone(), 0);
-	CardZone *targetZone = targetPlayer->getZones().value(arrow->getTargetZone(), 0);
-	if (!startZone || (!targetZone && !arrow->getTargetZone().isEmpty()))
+	CardZone *startZone = startPlayer->getZones().value(QString::fromStdString(arrow.start_zone()), 0);
+	CardZone *targetZone = 0;
+	if (arrow.has_target_zone())
+		targetZone = targetPlayer->getZones().value(QString::fromStdString(arrow.target_zone()), 0);
+	if (!startZone || (!targetZone && arrow.has_target_zone()))
 		return 0;
 	
-	CardItem *startCard = startZone->getCard(arrow->getStartCardId(), QString());
+	CardItem *startCard = startZone->getCard(arrow.start_card_id(), QString());
 	CardItem *targetCard = 0;
 	if (targetZone)
-		targetCard = targetZone->getCard(arrow->getTargetCardId(), QString());
-	if (!startCard || (!targetCard && !arrow->getTargetZone().isEmpty()))
+		targetCard = targetZone->getCard(arrow.target_card_id(), QString());
+	if (!startCard || (!targetCard && arrow.has_target_card_id()))
 		return 0;
 	
 	if (targetCard)
-		return addArrow(arrow->getId(), startCard, targetCard, arrow->getColor().getQColor());
+		return addArrow(arrow.id(), startCard, targetCard, convertColorToQColor(arrow.arrow_color()));
 	else
-		return addArrow(arrow->getId(), startCard, targetPlayer->getPlayerTarget(), arrow->getColor().getQColor());
+		return addArrow(arrow.id(), startCard, targetPlayer->getPlayerTarget(), convertColorToQColor(arrow.arrow_color()));
 }
 
 ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color)
@@ -1740,7 +1755,7 @@ QMenu *Player::getCardMenu() const
 
 QString Player::getName() const
 {
-	return userInfo->getName();
+	return QString::fromStdString(userInfo->name());
 }
 
 qreal Player::getMinimumWidth() const

cockatrice/src/player.h

@@ -5,8 +5,9 @@
 #include <QPoint>
 #include <QMap>
 #include "abstractgraphicsitem.h"
-#include <google/protobuf/message.h>
+#include "pb/game_event.pb.h"
 
+namespace google { namespace protobuf { class Message; } }
 class CardDatabase;
 class QMenu;
 class QAction;
@@ -197,7 +198,7 @@ private:
 	void eventDelCounter(const Event_DelCounter &event);
 	void eventDumpZone(const Event_DumpZone &event);
 	void eventStopDumpZone(const Event_StopDumpZone &event);
-	void eventMoveCard(const Event_MoveCard &event, GameEventContext &context);
+	void eventMoveCard(const Event_MoveCard &event, const GameEventContext &context);
 	void eventFlipCard(const Event_FlipCard &event);
 	void eventDestroyCard(const Event_DestroyCard &event);
 	void eventAttachCard(const Event_AttachCard &event);
@@ -255,10 +256,10 @@ public:
 	void setMirrored(bool _mirrored);
 	void processSceneSizeChange(int newPlayerWidth);
 	
-	void processPlayerInfo(ServerInfo_Player *info);
-	void processCardAttachment(ServerInfo_Player *info);
+	void processPlayerInfo(const ServerInfo_Player &info);
+	void processCardAttachment(const ServerInfo_Player &info);
 	
-	void processGameEvent(GameEvent *event, GameEventContext *context);
+	void processGameEvent(GameEvent::GameEventType type, const GameEvent &event, const GameEventContext &context);
 
 	PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
 	PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList);

cockatrice/src/playertarget.cpp

 #include "playertarget.h"
 #include "player.h"
-#include "protocol_datastructures.h"
 #include "pixmapgenerator.h"
+#include "pb/serverinfo_user.pb.h"
 #include <QPainter>
 #include <QPixmapCache>
 #include <QDebug>
@@ -50,8 +50,9 @@ PlayerTarget::PlayerTarget(Player *_owner, QGraphicsItem *parentItem)
 	: ArrowTarget(_owner, parentItem), playerCounter(0)
 {
 	setCacheMode(DeviceCoordinateCache);
-
-	if (!fullPixmap.loadFromData(_owner->getUserInfo()->getAvatarBmp()))
+	
+	const std::string bmp = _owner->getUserInfo()->avatar_bmp();
+	if (!fullPixmap.loadFromData((const uchar *) bmp.data(), bmp.size()))
 		fullPixmap = QPixmap();
 }
 
@@ -62,7 +63,7 @@ QRectF PlayerTarget::boundingRect() const
 
 void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
-	ServerInfo_User *info = owner->getUserInfo();
+	const ServerInfo_User *const info = owner->getUserInfo();
 
 	const qreal border = 2;
 
@@ -70,7 +71,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
 	QRectF translatedRect = painter->combinedTransform().mapRect(avatarBoundingRect);
 	QSize translatedSize = translatedRect.size().toSize();
 	QPixmap cachedPixmap;
-	const QString cacheKey = "avatar" + QString::number(translatedSize.width()) + "_" + QString::number(info->getUserLevel()) + "_" + QString::number(fullPixmap.cacheKey());
+	const QString cacheKey = "avatar" + QString::number(translatedSize.width()) + "_" + QString::number(info->user_level()) + "_" + QString::number(fullPixmap.cacheKey());
 #if QT_VERSION >= 0x040600
 	if (!QPixmapCache::find(cacheKey, &cachedPixmap)) {
 #else
@@ -86,7 +87,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
 		
 		QPixmap tempPixmap;
 		if (fullPixmap.isNull())
-			tempPixmap = UserLevelPixmapGenerator::generatePixmap(translatedSize.height(), info->getUserLevel());
+			tempPixmap = UserLevelPixmapGenerator::generatePixmap(translatedSize.height(), info->user_level());
 		else
 			tempPixmap = fullPixmap.scaled(translatedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
 		
@@ -107,7 +108,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
 	painter->save();
 	painter->resetTransform();
 	
-	QString name = info->getName();
+	QString name = QString::fromStdString(info->name());
 	if (name.size() > 13)
 		name = name.mid(0, 10) + "...";
 	

cockatrice/src/remotedecklist_treewidget.cpp

@@ -2,11 +2,11 @@
 #include <QHeaderView>
 #include <QSortFilterProxyModel>
 #include "remotedecklist_treewidget.h"
-#include "protocol_items.h"
 #include "abstractclient.h"
 
 #include "pending_command.h"
 #include "pb/session_commands.pb.h"
+//#include "pb/response_deck_list.pb.h"
 
 RemoteDeckList_TreeModel::DirectoryNode::DirectoryNode(const QString &_name, RemoteDeckList_TreeModel::DirectoryNode *_parent)
 	: RemoteDeckList_TreeModel::Node(_name, _parent)
@@ -204,19 +204,21 @@ QModelIndex RemoteDeckList_TreeModel::nodeToIndex(Node *node) const
 
 void RemoteDeckList_TreeModel::addFileToTree(DeckList_File *file, DirectoryNode *parent)
 {
-	beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
+/*	beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
 	parent->append(new FileNode(file->getName(), file->getId(), file->getUploadTime(), parent));
 	endInsertRows();
+*/
+	
 }
 
 void RemoteDeckList_TreeModel::addFolderToTree(DeckList_Directory *folder, DirectoryNode *parent)
 {
-	addFolderToTree(folder->getName(), folder->getTreeItems(), parent);
+//	addFolderToTree(folder->getName(), folder->getTreeItems(), parent);
 }
 
 void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<DeckList_TreeItem *> &folderItems, DirectoryNode *parent)
 {
-	DirectoryNode *newItem = new DirectoryNode(name, parent);
+/*	DirectoryNode *newItem = new DirectoryNode(name, parent);
 	beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
 	parent->append(newItem);
 	endInsertRows();
@@ -228,6 +230,7 @@ void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<
 		else
 			addFileToTree(dynamic_cast<DeckList_File *>(folderItems[i]), newItem);
 	}
+*/
 }
 
 void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
@@ -242,22 +245,21 @@ void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
 void RemoteDeckList_TreeModel::refreshTree()
 {
 	PendingCommand *pend = client->prepareSessionCommand(Command_DeckList());
-	connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckListFinished(ProtocolResponse *)));
+	connect(pend, SIGNAL(finished(const Response &)), this, SLOT(deckListFinished(const Response &)));
 	
 	client->sendCommand(pend);
 }
 
-void RemoteDeckList_TreeModel::deckListFinished(ProtocolResponse *r)
+void RemoteDeckList_TreeModel::deckListFinished(const Response &r)
 {
-	Response_DeckList *resp = qobject_cast<Response_DeckList *>(r);
-	if (!resp)
-		return;
+/*	const Response_DeckList &resp = r.GetExtension(Response_DeckList::ext);
 
 	root->clearTree();
 	reset();
 	
 	addFolderToTree(resp->getRoot(), root);
 	emit treeRefreshed();
+*/
 }
 
 RemoteDeckList_TreeWidget::RemoteDeckList_TreeWidget(AbstractClient *_client, QWidget *parent)

cockatrice/src/remotedecklist_treewidget.h

@@ -5,7 +5,7 @@
 #include <QDateTime>
 #include <QTreeView>
 
-class ProtocolResponse;
+class Response;
 class AbstractClient;
 class QSortFilterProxyModel;
 class DeckList_File;
@@ -64,7 +64,7 @@ private:
 signals:
 	void treeRefreshed();
 private slots:
-	void deckListFinished(ProtocolResponse *r);
+	void deckListFinished(const Response &r);
 public:
 	RemoteDeckList_TreeModel(AbstractClient *_client, QObject *parent = 0);
 	~RemoteDeckList_TreeModel();

cockatrice/src/stackzone.cpp

@@ -5,6 +5,7 @@
 #include "settingscache.h"
 #include "player.h"
 #include "carddragitem.h"
+#include "carditem.h"
 
 #include "pb/command_move_card.pb.h"
 

cockatrice/src/tab_game.h

@@ -4,8 +4,8 @@
 #include <QMap>
 #include <QPushButton>
 #include "tab.h"
-#include <google/protobuf/message.h>
 
+namespace google { namespace protobuf { class Message; } }
 class AbstractClient;
 class CardDatabase;
 class GameView;
@@ -22,11 +22,12 @@ class ZoneViewLayout;
 class ZoneViewWidget;
 class PhasesToolbar;
 class PlayerListWidget;
-class ProtocolResponse;
+class Response;
 class GameEventContainer;
 class GameEventContext;
 class GameCommand;
 class CommandContainer;
+class Event_GameJoined;
 class Event_GameStateChanged;
 class Event_PlayerPropertiesChanged;
 class Event_Join;
@@ -37,7 +38,7 @@ class Event_GameStart;
 class Event_SetActivePlayer;
 class Event_SetActivePhase;
 class Event_Ping;
-class Event_Say;
+class Event_GameSay;
 class Event_Kicked;
 class Player;
 class CardZone;
@@ -73,7 +74,7 @@ private slots:
 	void loadLocalDeck();
 	void loadRemoteDeck();
 	void readyStart();
-	void deckSelectFinished(ProtocolResponse *r);
+	void deckSelectFinished(const Response &r);
 	void sideboardPlanChanged();
 signals:
 	void newCardAdded(AbstractCardItem *card);
@@ -123,31 +124,31 @@ private:
 	QAction *aConcede, *aLeaveGame, *aNextPhase, *aNextTurn, *aRemoveLocalArrows;
 	QList<QAction *> phaseActions;
 
-	Player *addPlayer(int playerId, ServerInfo_User *info);
+	Player *addPlayer(int playerId, const ServerInfo_User &info);
 
 	void startGame(bool resuming);
 	void stopGame();
 
-	void eventSpectatorSay(Event_Say *event, GameEventContext *context);
-	void eventSpectatorLeave(Event_Leave *event, GameEventContext *context);
+	void eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext &context);
+	void eventSpectatorLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
 	
-	void eventGameStateChanged(Event_GameStateChanged *event, GameEventContext *context);
-	void eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event, GameEventContext *context);
-	void eventJoin(Event_Join *event, GameEventContext *context);
-	void eventLeave(Event_Leave *event, GameEventContext *context);
-	void eventKicked(Event_Kicked *event, GameEventContext *context);
-	void eventGameHostChanged(Event_GameHostChanged *event, GameEventContext *context);
-	void eventGameClosed(Event_GameClosed *event, GameEventContext *context);
+	void eventGameStateChanged(const Event_GameStateChanged &event, int eventPlayerId, const GameEventContext &context);
+	void eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event, int eventPlayerId, const GameEventContext &context);
+	void eventJoin(const Event_Join &event, int eventPlayerId, const GameEventContext &context);
+	void eventLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
+	void eventKicked(const Event_Kicked &event, int eventPlayerId, const GameEventContext &context);
+	void eventGameHostChanged(const Event_GameHostChanged &event, int eventPlayerId, const GameEventContext &context);
+	void eventGameClosed(const Event_GameClosed &event, int eventPlayerId, const GameEventContext &context);
 	Player *setActivePlayer(int id);
-	void eventSetActivePlayer(Event_SetActivePlayer *event, GameEventContext *context);
+	void eventSetActivePlayer(const Event_SetActivePlayer &event, int eventPlayerId, const GameEventContext &context);
 	void setActivePhase(int phase);
-	void eventSetActivePhase(Event_SetActivePhase *event, GameEventContext *context);
-	void eventPing(Event_Ping *event, GameEventContext *context);
+	void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);
+	void eventPing(const Event_Ping &event, int eventPlayerId, const GameEventContext &context);
 signals:
 	void gameClosing(TabGame *tab);
 	void playerAdded(Player *player);
 	void playerRemoved(Player *player);
-	void containerProcessingStarted(GameEventContext *context);
+	void containerProcessingStarted(const GameEventContext &context);
 	void containerProcessingDone();
 	void openMessageDialog(const QString &userName, bool focus);
 private slots:
@@ -162,7 +163,7 @@ private slots:
 	void actNextPhase();
 	void actNextTurn();
 public:
-	TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, int _gameId, const QString &_gameDescription, int _hostId, int _localPlayerId, bool _spectator, bool _spectatorsCanTalk, bool _spectatorsSeeEverything, bool _resuming);
+	TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event);
 	~TabGame();
 	void retranslateUi();
 	void closeRequest();
@@ -177,7 +178,7 @@ public:
 	Player *getActiveLocalPlayer() const;
 	AbstractClient *getClientForPlayer(int playerId) const;
 
-	void processGameEventContainer(GameEventContainer *cont, AbstractClient *client);
+	void processGameEventContainer(const GameEventContainer &cont, AbstractClient *client);
 	PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
 	PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList);
 public slots:

cockatrice/src/tab_message.cpp

@@ -5,11 +5,11 @@
 #include <QAction>
 #include "tab_message.h"
 #include "abstractclient.h"
-#include "protocol_items.h"
 #include "chatview.h"
 
 #include "pending_command.h"
 #include "pb/session_commands.pb.h"
+#include "pb/event_user_message.pb.h"
 
 TabMessage::TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const QString &_userName)
 	: Tab(_tabSupervisor), client(_client), userName(_userName), userOnline(true)
@@ -60,15 +60,15 @@ void TabMessage::sendMessage()
 	cmd.set_message(sayEdit->text().toStdString());
 	
 	PendingCommand *pend = client->prepareSessionCommand(cmd);
-	connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(messageSent(ProtocolResponse *)));
+	connect(pend, SIGNAL(finished(const Response &)), this, SLOT(messageSent(const Response &)));
 	client->sendCommand(pend);
 	
 	sayEdit->clear();
 }
 
-void TabMessage::messageSent(ProtocolResponse *response)
+void TabMessage::messageSent(const Response &response)
 {
-	if (response->getResponseCode() == RespInIgnoreList)
+	if (response.response_code() == Response::RespInIgnoreList)
 		chatView->appendMessage(QString(), tr("This user is ignoring you."));
 }
 
@@ -77,9 +77,9 @@ void TabMessage::actLeave()
 	deleteLater();
 }
 
-void TabMessage::processMessageEvent(Event_Message *event)
+void TabMessage::processUserMessageEvent(const Event_UserMessage &event)
 {
-	chatView->appendMessage(event->getSenderName(), event->getText());
+	chatView->appendMessage(QString::fromStdString(event.sender_name()), QString::fromStdString(event.message()));
 	emit userEvent();
 }