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.cpp

@@ -18,7 +18,6 @@
 #include "zoneviewwidget.h"
 #include "deckview.h"
 #include "decklist.h"
-#include "protocol_items.h"
 #include "dlg_load_remote_deck.h"
 #include "abstractclient.h"
 #include "carditem.h"
@@ -38,6 +37,22 @@
 #include "pb/command_set_active_phase.pb.h"
 #include "pb/command_next_turn.pb.h"
 #include "pb/command_delete_arrow.pb.h"
+#include "pb/response_deck_download.pb.h"
+#include "pb/game_event_container.pb.h"
+#include "pb/event_game_joined.pb.h"
+#include "pb/event_game_say.pb.h"
+#include "pb/event_game_state_changed.pb.h"
+#include "pb/event_player_properties_changed.pb.h"
+#include "pb/event_join.pb.h"
+#include "pb/event_leave.pb.h"
+#include "pb/event_kicked.pb.h"
+#include "pb/event_game_host_changed.pb.h"
+#include "pb/event_game_closed.pb.h"
+#include "pb/event_set_active_player.pb.h"
+#include "pb/event_set_active_phase.pb.h"
+#include "pb/event_ping.pb.h"
+#include "pb/context_deck_select.pb.h"
+#include "get_pb_extension.h"
 
 ReadyStartButton::ReadyStartButton(QWidget *parent)
 	: QPushButton(parent), readyStart(false)
@@ -125,7 +140,7 @@ void DeckViewContainer::loadLocalDeck()
 	Command_DeckSelect cmd;
 	cmd.set_deck(deck->writeToString_Native().toStdString());
 	PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd);
-	connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckSelectFinished(ProtocolResponse *)));
+	connect(pend, SIGNAL(finished(const Response &)), this, SLOT(deckSelectFinished(const Response &)));
 	static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId);
 }
 
@@ -136,19 +151,17 @@ void DeckViewContainer::loadRemoteDeck()
 		Command_DeckSelect cmd;
 		cmd.set_deck_id(dlg.getDeckId());
 		PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd);
-		connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckSelectFinished(ProtocolResponse *)));
+		connect(pend, SIGNAL(finished(const Response &)), this, SLOT(deckSelectFinished(const Response &)));
 		static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId);
 	}
 }
 
-void DeckViewContainer::deckSelectFinished(ProtocolResponse *r)
+void DeckViewContainer::deckSelectFinished(const Response &r)
 {
-	Response_DeckDownload *resp = qobject_cast<Response_DeckDownload *>(r);
-	if (!resp)
-		return;
-	
-	db->cacheCardPixmaps(resp->getDeck()->getCardList());
-	deckView->setDeck(new DeckList(resp->getDeck()));
+	const Response_DeckDownload &resp = r.GetExtension(Response_DeckDownload::ext);
+	DeckList *newDeck = new DeckList(QString::fromStdString(resp.deck()));
+	db->cacheCardPixmaps(newDeck->getCardList());
+	deckView->setDeck(newDeck);
 	readyStartButton->setEnabled(true);
 }
 
@@ -180,8 +193,20 @@ void DeckViewContainer::setDeck(DeckList *deck)
 	readyStartButton->setEnabled(true);
 }
 
-TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, int _gameId, const QString &_gameDescription, int _hostId, int _localPlayerId, bool _spectator, bool _spectatorsCanTalk, bool _spectatorsSeeEverything, bool _resuming)
-	: Tab(_tabSupervisor), clients(_clients), gameId(_gameId), gameDescription(_gameDescription), hostId(_hostId), localPlayerId(_localPlayerId), spectator(_spectator), spectatorsCanTalk(_spectatorsCanTalk), spectatorsSeeEverything(_spectatorsSeeEverything), gameStateKnown(false), started(false), resuming(_resuming), currentPhase(-1)
+TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event)
+	: Tab(_tabSupervisor),
+	clients(_clients),
+	gameId(event.game_id()),
+	gameDescription(QString::fromStdString(event.game_description())),
+	hostId(event.host_id()),
+	localPlayerId(event.player_id()),
+	spectator(event.spectator()),
+	spectatorsCanTalk(event.spectators_can_talk()),
+	spectatorsSeeEverything(event.spectators_see_everything()),
+	gameStateKnown(false),
+	started(false),
+	resuming(event.resuming()),
+	currentPhase(-1)
 {
 	phasesToolbar = new PhasesToolbar;
 	phasesToolbar->hide();
@@ -198,7 +223,7 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_client
 	
 	timeElapsedLabel = new QLabel;
 	timeElapsedLabel->setAlignment(Qt::AlignCenter);
-	messageLog = new MessageLogWidget(tabSupervisor->getUserInfo()->getName(), tabSupervisor->getUserInfo()->getGender() == ServerInfo_User::Female);
+	messageLog = new MessageLogWidget(QString::fromStdString(tabSupervisor->getUserInfo()->name()), tabSupervisor->getUserInfo()->gender() == ServerInfo_User::Female);
 	connect(messageLog, SIGNAL(cardNameHovered(QString)), cardInfo, SLOT(setCard(QString)));
 	connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString)));
 	connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString)));
@@ -411,7 +436,7 @@ void TabGame::actRemoveLocalArrows()
 	}
 }
 
-Player *TabGame::addPlayer(int playerId, ServerInfo_User *info)
+Player *TabGame::addPlayer(int playerId, const ServerInfo_User &info)
 {
 	bool local = ((clients.size() > 1) || (playerId == localPlayerId));
 	Player *newPlayer = new Player(info, playerId, local, this);
@@ -438,47 +463,48 @@ Player *TabGame::addPlayer(int playerId, ServerInfo_User *info)
 	return newPlayer;
 }
 
-void TabGame::processGameEventContainer(GameEventContainer *cont, AbstractClient *client)
+void TabGame::processGameEventContainer(const GameEventContainer &cont, AbstractClient *client)
 {
-	const QList<GameEvent *> &eventList = cont->getEventList();
-	GameEventContext *context = cont->getContext();
+	const GameEventContext &context = cont.context();
 	messageLog->containerProcessingStarted(context);
-	for (int i = 0; i < eventList.size(); ++i) {
-		GameEvent *event = eventList[i];
-		
-		if (spectators.contains(event->getPlayerId())) {
-			switch (event->getItemId()) {
-				case ItemId_Event_Say: eventSpectatorSay(static_cast<Event_Say *>(event), context); break;
-				case ItemId_Event_Leave: eventSpectatorLeave(static_cast<Event_Leave *>(event), context); break;
+	const int eventListSize = cont.event_list_size();
+	for (int i = 0; i < eventListSize; ++i) {
+		const GameEvent &event = cont.event_list(i);
+		const int playerId = event.player_id();
+		const GameEvent::GameEventType eventType = static_cast<GameEvent::GameEventType>(getPbExtension(event));
+		if (spectators.contains(playerId)) {
+			switch (eventType) {
+				case GameEvent::GAME_SAY: eventSpectatorSay(event.GetExtension(Event_GameSay::ext), playerId, context); break;
+				case GameEvent::LEAVE: eventSpectatorLeave(event.GetExtension(Event_Leave::ext), playerId, context); break;
 				default: {
 					qDebug() << "unhandled spectator game event";
 					break;
 				}
 			}
 		} else {
-			if ((clients.size() > 1) && (event->getPlayerId() != -1))
-				if (clients.at(event->getPlayerId()) != client)
+			if ((clients.size() > 1) && (playerId != -1))
+				if (clients.at(playerId) != client)
 					continue;
-				
-			switch (event->getItemId()) {
-				case ItemId_Event_GameStateChanged: eventGameStateChanged(static_cast<Event_GameStateChanged *>(event), context); break;
-				case ItemId_Event_PlayerPropertiesChanged: eventPlayerPropertiesChanged(static_cast<Event_PlayerPropertiesChanged *>(event), context); break;
-				case ItemId_Event_Join: eventJoin(static_cast<Event_Join *>(event), context); break;
-				case ItemId_Event_Leave: eventLeave(static_cast<Event_Leave *>(event), context); break;
-				case ItemId_Event_Kicked: eventKicked(static_cast<Event_Kicked *>(event), context); break;
-				case ItemId_Event_GameHostChanged: eventGameHostChanged(static_cast<Event_GameHostChanged *>(event), context); break;
-				case ItemId_Event_GameClosed: eventGameClosed(static_cast<Event_GameClosed *>(event), context); break;
-				case ItemId_Event_SetActivePlayer: eventSetActivePlayer(static_cast<Event_SetActivePlayer *>(event), context); break;
-				case ItemId_Event_SetActivePhase: eventSetActivePhase(static_cast<Event_SetActivePhase *>(event), context); break;
-				case ItemId_Event_Ping: eventPing(static_cast<Event_Ping *>(event), context); break;
+			
+			switch (eventType) {
+				case GameEvent::GAME_STATE_CHANGED: eventGameStateChanged(event.GetExtension(Event_GameStateChanged::ext), playerId, context); break;
+				case GameEvent::PLAYER_PROPERTIES_CHANGED: eventPlayerPropertiesChanged(event.GetExtension(Event_PlayerPropertiesChanged::ext), playerId, context); break;
+				case GameEvent::JOIN: eventJoin(event.GetExtension(Event_Join::ext), playerId, context); break;
+				case GameEvent::LEAVE: eventLeave(event.GetExtension(Event_Leave::ext), playerId, context); break;
+				case GameEvent::KICKED: eventKicked(event.GetExtension(Event_Kicked::ext), playerId, context); break;
+				case GameEvent::GAME_HOST_CHANGED: eventGameHostChanged(event.GetExtension(Event_GameHostChanged::ext), playerId, context); break;
+				case GameEvent::GAME_CLOSED: eventGameClosed(event.GetExtension(Event_GameClosed::ext), playerId, context); break;
+				case GameEvent::SET_ACTIVE_PLAYER: eventSetActivePlayer(event.GetExtension(Event_SetActivePlayer::ext), playerId, context); break;
+				case GameEvent::SET_ACTIVE_PHASE: eventSetActivePhase(event.GetExtension(Event_SetActivePhase::ext), playerId, context); break;
+				case GameEvent::PING: eventPing(event.GetExtension(Event_Ping::ext), playerId, context); break;
 		
 				default: {
-					Player *player = players.value(event->getPlayerId(), 0);
+					Player *player = players.value(playerId, 0);
 					if (!player) {
 						qDebug() << "unhandled game event: invalid player id";
 						break;
 					}
-					player->processGameEvent(event, context);
+					player->processGameEvent(eventType, event, context);
 					emit userEvent();
 				}
 			}
@@ -574,62 +600,63 @@ void TabGame::stopGame()
 	phasesToolbar->hide();
 }
 
-void TabGame::eventSpectatorSay(Event_Say *event, GameEventContext * /*context*/)
+void TabGame::eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext & /*context*/)
 {
-	messageLog->logSpectatorSay(spectators.value(event->getPlayerId()), event->getMessage());
+	messageLog->logSpectatorSay(spectators.value(eventPlayerId), QString::fromStdString(event.message()));
 }
 
-void TabGame::eventSpectatorLeave(Event_Leave *event, GameEventContext * /*context*/)
+void TabGame::eventSpectatorLeave(const Event_Leave & /*event*/, int eventPlayerId, const GameEventContext & /*context*/)
 {
-	int playerId = event->getPlayerId();
-	messageLog->logLeaveSpectator(spectators.value(playerId));
-	playerListWidget->removePlayer(playerId);
-	spectators.remove(playerId);
+	messageLog->logLeaveSpectator(spectators.value(eventPlayerId));
+	playerListWidget->removePlayer(eventPlayerId);
+	spectators.remove(eventPlayerId);
 	
 	emit userEvent();
 }
 
-void TabGame::eventGameStateChanged(Event_GameStateChanged *event, GameEventContext * /*context*/)
+void TabGame::eventGameStateChanged(const Event_GameStateChanged &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
-	const QList<ServerInfo_Player *> &plList = event->getPlayerList();
-	for (int i = 0; i < plList.size(); ++i) {
-		ServerInfo_Player *pl = plList[i];
-		ServerInfo_PlayerProperties *prop = pl->getProperties();
-		if (prop->getSpectator()) {
-			if (!spectators.contains(prop->getPlayerId())) {
-				spectators.insert(prop->getPlayerId(), prop->getUserInfo()->getName());
+	const int playerListSize = event.player_list_size();
+	for (int i = 0; i < playerListSize; ++i) {
+		const ServerInfo_Player &playerInfo = event.player_list(i);
+		const ServerInfo_PlayerProperties &prop = playerInfo.properties();
+		const int playerId = prop.player_id();
+		if (prop.spectator()) {
+			if (!spectators.contains(playerId)) {
+				spectators.insert(playerId, QString::fromStdString(prop.user_info().name()));
 				playerListWidget->addPlayer(prop);
 			}
 		} else {
-			Player *player = players.value(prop->getPlayerId(), 0);
+			Player *player = players.value(playerId, 0);
 			if (!player) {
-				player = addPlayer(prop->getPlayerId(), prop->getUserInfo());
+				player = addPlayer(playerId, prop.user_info());
 				playerListWidget->addPlayer(prop);
 			}
-			player->processPlayerInfo(pl);
-			if (player->getLocal() && !pl->getDeck()->isEmpty()) {
-				db->cacheCardPixmaps(pl->getDeck()->getCardList());
-				deckViewContainers.value(player->getId())->setDeck(new DeckList(pl->getDeck()));
+			player->processPlayerInfo(playerInfo);
+			if (player->getLocal() && playerInfo.has_deck_list()) {
+				DeckList *newDeck = new DeckList(QString::fromStdString(playerInfo.deck_list()));
+				db->cacheCardPixmaps(newDeck->getCardList());
+				deckViewContainers.value(playerId)->setDeck(newDeck);
 			}
 		}
 	}
-	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);
+	for (int i = 0; i < playerListSize; ++i) {
+		const ServerInfo_Player &playerInfo = event.player_list(i);
+		const ServerInfo_PlayerProperties &prop = playerInfo.properties();
+		if (!prop.spectator()) {
+			Player *player = players.value(prop.player_id(), 0);
 			if (!player)
 				continue;
-			player->processCardAttachment(pl);
+			player->processCardAttachment(playerInfo);
 		}
 	}
-	if (event->getGameStarted() && !started) {
+	if (event.game_started() && !started) {
 		startGame(!gameStateKnown);
 		if (gameStateKnown)
 			messageLog->logGameStart();
-		setActivePlayer(event->getActivePlayer());
-		setActivePhase(event->getActivePhase());
-	} else if (!event->getGameStarted() && started) {
+		setActivePlayer(event.active_player_id());
+		setActivePhase(event.active_phase());
+	} else if (!event.game_started() && started) {
 		stopGame();
 		scene->clearViews();
 	}
@@ -637,15 +664,17 @@ void TabGame::eventGameStateChanged(Event_GameStateChanged *event, GameEventCont
 	emit userEvent();
 }
 
-void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event, GameEventContext *context)
+void TabGame::eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event, int eventPlayerId, const GameEventContext &context)
 {
-	Player *player = players.value(event->getProperties()->getPlayerId(), 0);
+	Player *player = players.value(eventPlayerId, 0);
 	if (!player)
 		return;
-	playerListWidget->updatePlayerProperties(event->getProperties());
-	if (context) switch (context->getItemId()) {
-		case ItemId_Context_ReadyStart: {
-			bool ready = event->getProperties()->getReadyStart();
+	playerListWidget->updatePlayerProperties(event.player_properties());
+	
+	const GameEventContext::ContextType contextType = static_cast<const GameEventContext::ContextType>(getPbExtension(context));
+	switch (contextType) {
+		case GameEventContext::READY_START: {
+			bool ready = event.player_properties().ready_start();
 			if (player->getLocal())
 				deckViewContainers.value(player->getId())->setReadyStart(ready);
 			if (ready)
@@ -654,7 +683,7 @@ void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event,
 				messageLog->logNotReadyStart(player);
 			break;
 		}
-		case ItemId_Context_Concede: {
+		case GameEventContext::CONCEDE: {
 			messageLog->logConcede(player);
 			player->setConceded(true);
 			
@@ -664,39 +693,40 @@ void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event,
 			
 			break;
 		}
-		case ItemId_Context_DeckSelect: messageLog->logDeckSelect(player, static_cast<Context_DeckSelect *>(context)->getDeckHash()); break;
+		case GameEventContext::DECK_SELECT: {
+			messageLog->logDeckSelect(player, QString::fromStdString(context.GetExtension(Context_DeckSelect::ext).deck_hash()));
+			break;
+		}
 		default: ;
 	}
 }
 
-void TabGame::eventJoin(Event_Join *event, GameEventContext * /*context*/)
+void TabGame::eventJoin(const Event_Join &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
-	ServerInfo_PlayerProperties *playerInfo = event->getPlayer();
-	if (players.contains(playerInfo->getPlayerId()))
+	const ServerInfo_PlayerProperties &playerInfo = event.player_properties();
+	const int playerId = playerInfo.player_id();
+	if (players.contains(playerId))
 		return;
-	if (playerInfo->getSpectator()) {
-		spectators.insert(playerInfo->getPlayerId(), playerInfo->getUserInfo()->getName());
-		messageLog->logJoinSpectator(playerInfo->getUserInfo()->getName());
-		playerListWidget->addPlayer(playerInfo);
+	if (playerInfo.spectator()) {
+		spectators.insert(playerId, QString::fromStdString(playerInfo.user_info().name()));
+		messageLog->logJoinSpectator(QString::fromStdString(playerInfo.user_info().name()));
 	} else {
-		Player *newPlayer = addPlayer(playerInfo->getPlayerId(), playerInfo->getUserInfo());
+		Player *newPlayer = addPlayer(playerId, playerInfo.user_info());
 		messageLog->logJoin(newPlayer);
-		playerListWidget->addPlayer(playerInfo);
 	}
+	playerListWidget->addPlayer(playerInfo);
 	emit userEvent();
 }
 
-void TabGame::eventLeave(Event_Leave *event, GameEventContext * /*context*/)
+void TabGame::eventLeave(const Event_Leave & /*event*/, int eventPlayerId, const GameEventContext & /*context*/)
 {
-	int playerId = event->getPlayerId();
-
-	Player *player = players.value(playerId, 0);
+	Player *player = players.value(eventPlayerId, 0);
 	if (!player)
 		return;
 	
 	messageLog->logLeave(player);
-	playerListWidget->removePlayer(playerId);
-	players.remove(playerId);
+	playerListWidget->removePlayer(eventPlayerId);
+	players.remove(eventPlayerId);
 	emit playerRemoved(player);
 	player->clear();
 	player->deleteLater();
@@ -709,19 +739,19 @@ void TabGame::eventLeave(Event_Leave *event, GameEventContext * /*context*/)
 	emit userEvent();
 }
 
-void TabGame::eventKicked(Event_Kicked * /*event*/, GameEventContext * /*context*/)
+void TabGame::eventKicked(const Event_Kicked & /*event*/, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
 	emit userEvent();
 	QMessageBox::critical(this, tr("Kicked"), tr("You have been kicked out of the game."));
 	deleteLater();
 }
 
-void TabGame::eventGameHostChanged(Event_GameHostChanged *event, GameEventContext * /*context*/)
+void TabGame::eventGameHostChanged(const Event_GameHostChanged & /*event*/, int eventPlayerId, const GameEventContext & /*context*/)
 {
-	hostId = event->getPlayerId();
+	hostId = eventPlayerId;
 }
 
-void TabGame::eventGameClosed(Event_GameClosed * /*event*/, GameEventContext * /*context*/)
+void TabGame::eventGameClosed(const Event_GameClosed & /*event*/, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
 	started = false;
 	messageLog->logGameClosed();
@@ -753,9 +783,9 @@ Player *TabGame::setActivePlayer(int id)
 	return player;
 }
 
-void TabGame::eventSetActivePlayer(Event_SetActivePlayer *event, GameEventContext * /*context*/)
+void TabGame::eventSetActivePlayer(const Event_SetActivePlayer &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
-	Player *player = setActivePlayer(event->getActivePlayerId());
+	Player *player = setActivePlayer(event.active_player_id());
 	if (!player)
 		return;
 	messageLog->logSetActivePlayer(player);
@@ -770,22 +800,22 @@ void TabGame::setActivePhase(int phase)
 	}
 }
 
-void TabGame::eventSetActivePhase(Event_SetActivePhase *event, GameEventContext * /*context*/)
+void TabGame::eventSetActivePhase(const Event_SetActivePhase &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
-	int phase = event->getPhase();
+	const int phase = event.phase();
 	if (currentPhase != phase)
 		messageLog->logSetActivePhase(phase);
 	setActivePhase(phase);
 	emit userEvent();
 }
 
-void TabGame::eventPing(Event_Ping *event, GameEventContext * /*context*/)
+void TabGame::eventPing(const Event_Ping &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
 {
-	const QList<ServerInfo_PlayerPing *> &pingList = event->getPingList();
-	for (int i = 0; i < pingList.size(); ++i)
-		playerListWidget->updatePing(pingList[i]->getPlayerId(), pingList[i]->getPingTime());
+	const int pingListSize = event.ping_list_size();
+	for (int i = 0; i < pingListSize; ++i)
+		playerListWidget->updatePing(event.ping_list(i).player_id(), event.ping_list(i).ping_time());
 	
-	int seconds = event->getSecondsElapsed();
+	int seconds = event.seconds_elapsed();
 	int minutes = seconds / 60;
 	seconds -= minutes * 60;
 	int hours = minutes / 60;

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();
 }