event handling

cockatrice/cockatrice.pro

@@ -20,7 +20,6 @@ HEADERS += src/counter.h \
  src/carditem.h \
  src/tablezone.h \
  src/handzone.h \
- src/game.h \
  src/carddatabase.h \
  src/gameview.h \
  src/deck_picturecacher.h \
@@ -49,7 +48,8 @@ HEADERS += src/counter.h \
  src/tab_supervisor.h \
  src/remotedecklist_treewidget.h \
  src/deckview.h \
- 	../common/decklist.h \
+ src/playerlistwidget.h \
+	../common/decklist.h \
 	../common/protocol.h \
 	../common/protocol_items.h \
 	../common/protocol_datastructures.h
@@ -68,7 +68,6 @@ SOURCES += src/counter.cpp \
  src/carditem.cpp \
  src/tablezone.cpp \
  src/handzone.cpp \
- src/game.cpp \
  src/carddatabase.cpp \
  src/gameview.cpp \
  src/deck_picturecacher.cpp \
@@ -97,7 +96,8 @@ SOURCES += src/counter.cpp \
  src/tab_supervisor.cpp \
  src/remotedecklist_treewidget.cpp \
  src/deckview.cpp \
- 	../common/decklist.cpp \
+ src/playerlistwidget.cpp \
+	../common/decklist.cpp \
 	../common/protocol.cpp \
 	../common/protocol_items.cpp \
 	../common/protocol_datastructures.cpp

cockatrice/src/cardinfowidget.cpp

-#include "cardinfowidget.h"
-#include "carditem.h"
 #include <QGridLayout>
 #include <QLabel>
 #include <QTextEdit>
-#include <QMessageBox>
+#include "cardinfowidget.h"
+#include "carditem.h"
+#include "carddatabase.h"
+#include "main.h"
 
-CardInfoWidget::CardInfoWidget(CardDatabase *_db, QWidget *parent)
-	: QFrame(parent), db(_db), pixmapHeight(pixmapWidth), info(0)
+CardInfoWidget::CardInfoWidget(QWidget *parent)
+	: QFrame(parent), pixmapHeight(pixmapWidth), info(0)
 {
 	cardPicture = new QLabel;
 	cardPicture->setAlignment(Qt::AlignCenter);
@@ -62,15 +63,12 @@ CardInfoWidget::CardInfoWidget(CardDatabase *_db, QWidget *parent)
 
 	retranslateUi();
 	setFrameStyle(QFrame::Panel | QFrame::Raised);
-	textLabel->setFixedHeight(130);
+	textLabel->setFixedHeight(100);
 	setFixedSize(sizeHint());
 }
 
 void CardInfoWidget::setCard(CardInfo *card)
 {
-	if (!card)
-		return;
-
 	if (info)
 		disconnect(info, 0, this, 0);
 	info = card;
@@ -89,6 +87,11 @@ void CardInfoWidget::setCard(const QString &cardName)
 	setCard(db->getCard(cardName));
 }
 
+void CardInfoWidget::setCard(CardItem *card)
+{
+	setCard(card->getInfo());
+}
+
 void CardInfoWidget::updatePixmap()
 {
 	QPixmap *resizedPixmap = info->getPixmap(QSize(pixmapWidth, pixmapHeight));

cockatrice/src/cardinfowidget.h

 #ifndef CARDINFOWIDGET_H
 #define CARDINFOWIDGET_H
 
-#include "carddatabase.h"
 #include <QFrame>
 
 class QLabel;
 class QTextEdit;
+class CardItem;
+class CardInfo;
 
 class CardInfoWidget : public QFrame {
 	Q_OBJECT
 private:
-	CardDatabase *db;
-	static const int pixmapWidth = 180;
+	static const int pixmapWidth = 160;
 	int pixmapHeight;
 
 	QLabel *cardPicture;
@@ -23,11 +23,12 @@ private:
 	
 	CardInfo *info;
 public:
-	CardInfoWidget(CardDatabase *_db, QWidget *parent = 0);
+	CardInfoWidget(QWidget *parent = 0);
 	void retranslateUi();
 public slots:
 	void setCard(CardInfo *card);
 	void setCard(const QString &cardName);
+	void setCard(CardItem *card);
 private slots:
 	void updatePixmap();
 };

cockatrice/src/carditem.cpp

@@ -6,13 +6,14 @@
 #include "cardzone.h"
 #include "tablezone.h"
 #include "player.h"
-#include "game.h"
 #include "arrowitem.h"
 #include "main.h"
+#include "protocol_datastructures.h"
 
-CardItem::CardItem(const QString &_name, int _cardid, QGraphicsItem *parent)
-	: AbstractCardItem(_name, parent), id(_cardid), attacking(false), facedown(false), counters(0), doesntUntap(false), dragItem(NULL)
+CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, QGraphicsItem *parent)
+	: AbstractCardItem(_name, parent), owner(_owner), id(_cardid), attacking(false), facedown(false), counters(0), doesntUntap(false), dragItem(NULL)
 {
+	owner->addCard(this);
 }
 
 CardItem::~CardItem()
@@ -172,8 +173,13 @@ void CardItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 	}
 }
 
+void CardItem::processHoverEvent()
+{
+	emit hovered(this);
+}
+
 void CardItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
-	((Game *) ((CardZone *) parentItem())->getPlayer()->parent())->hoverCardEvent(this);
+	processHoverEvent();
 	QGraphicsItem::hoverEnterEvent(event);
 }

cockatrice/src/carditem.h

@@ -7,12 +7,14 @@ class CardDatabase;
 class CardDragItem;
 class CardZone;
 class ServerInfo_Card;
+class Player;
 
 const int MAX_COUNTERS_ON_CARD = 999;
 
 class CardItem : public AbstractCardItem {
 	Q_OBJECT
 private:
+	Player *owner;
 	int id;
 	bool attacking;
 	bool facedown;
@@ -24,11 +26,12 @@ private:
 public:
 	enum { Type = typeCard };
 	int type() const { return Type; }
-	CardItem(const QString &_name = QString(), int _cardid = -1, QGraphicsItem *parent = 0);
+	CardItem(Player *_owner, const QString &_name = QString(), int _cardid = -1, QGraphicsItem *parent = 0);
 	~CardItem();
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 	QPoint getGridPoint() const { return gridPoint; }
 	void setGridPoint(const QPoint &_gridPoint) { gridPoint = _gridPoint; }
+	Player *getOwner() const { return owner; }
 	int getId() const { return id; }
 	void setId(int _id) { id = _id; }
 	bool getAttacking() const { return attacking; }
@@ -46,6 +49,9 @@ public:
 
 	CardDragItem *createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown);
 	void deleteDragItem();
+	void processHoverEvent();
+signals:
+	void hovered(CardItem *card);
 protected:
 	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
 	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);

cockatrice/src/cardzone.cpp

@@ -84,7 +84,7 @@ void CardZone::addCard(CardItem *card, bool reorganize, int x, int y)
 {
 	if (view)
 		if ((x <= view->getCards().size()) || (view->getNumberCards() == -1))
-			view->addCard(new CardItem(card->getName(), card->getId()), reorganize, x, y);
+			view->addCard(new CardItem(player, card->getName(), card->getId()), reorganize, x, y);
 
 	addCardImpl(card, x, y);
 

cockatrice/src/deckview.cpp

@@ -89,6 +89,13 @@ DeckViewScene::~DeckViewScene()
 
 void DeckViewScene::setDeck(DeckList *_deck)
 {
+	if (deck)
+		delete deck;
+	QMapIterator<QString, DeckViewCardContainer *> i(cardContainers);
+	while (i.hasNext())
+		delete i.next().value();
+	cardContainers.clear();
+	
 	deck = _deck;
 	rebuildTree();
 	rearrangeItems();

cockatrice/src/game.cpp

@@ -19,12 +19,6 @@ Game::Game(Client *_client, GameScene *_scene, QMenuBar *menuBar, QObject *paren
 {
 	connect(client, SIGNAL(gameEvent(const ServerEventData &)), this, SLOT(gameEvent(const ServerEventData &)));
 
-	aNextPhase = new QAction(this);
-	connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
-	aNextTurn = new QAction(this);
-	connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
-	aRemoveLocalArrows = new QAction(this);
-	connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
 	aTap = new QAction(this);
 	aUntap = new QAction(this);
 	aDoesntUntap = new QAction(this);
@@ -38,12 +32,6 @@ Game::Game(Client *_client, GameScene *_scene, QMenuBar *menuBar, QObject *paren
 	aMoveToGraveyard = new QAction(this);
 	aMoveToExile = new QAction(this);
 
-	gameMenu = menuBar->addMenu(QString());
-	gameMenu->addAction(aNextPhase);
-	gameMenu->addAction(aNextTurn);
-	gameMenu->addSeparator();
-	gameMenu->addAction(aRemoveLocalArrows);
-	
 	cardMenu = menuBar->addMenu(QString());
 	cardMenu->addAction(aTap);
 	cardMenu->addAction(aUntap);
@@ -99,14 +87,6 @@ Game::~Game()
 
 void Game::retranslateUi()
 {
-	gameMenu->setTitle(tr("&Game"));
-	aNextPhase->setText(tr("Next &phase"));
-	aNextPhase->setShortcut(tr("Ctrl+Space"));
-	aNextTurn->setText(tr("Next &turn"));
-	aNextTurn->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+Return")) << QKeySequence(tr("Ctrl+Enter")));
-	aRemoveLocalArrows->setText(tr("&Remove all local arrows"));
-	aRemoveLocalArrows->setShortcut(tr("Ctrl+R"));
-	
 	cardMenu->setTitle(tr("C&ard"));
 	aTap->setText(tr("&Tap"));
 	aUntap->setText(tr("&Untap"));
@@ -123,248 +103,12 @@ void Game::retranslateUi()
 	
 	moveMenu->setTitle(tr("&Move to"));
 	
-	QMapIterator<int, Player *> i(players);
-	while (i.hasNext())
-		i.next().value()->retranslateUi();
-}
-
-/*
-
-void Game::counterListReceived(QList<ServerCounter> list)
-{
-	QMapIterator<int, Player *> i(players);
-	while (i.hasNext())
-		i.next().value()->clearCounters();
-	
-	for (int i = 0; i < list.size(); ++i) {
-		Player *p = players.value(list[i].getPlayerId(), 0);
-		if (!p)
-			continue;
-		p->addCounter(list[i].getId(), list[i].getName(), list[i].getColor(), list[i].getRadius(), list[i].getCount());
-	}
-}
-
-void Game::arrowListReceived(QList<ServerArrow> list)
-{
-	QMapIterator<int, Player *> i(players);
-	while (i.hasNext())
-		i.next().value()->clearArrows();
-	
-	for (int i = 0; i < list.size(); ++i) {
-		Player *p = players.value(list[i].getPlayerId(), 0);
-		if (!p)
-			continue;
-		
-		Player *startPlayer = players.value(list[i].getStartPlayerId(), 0);
-		Player *targetPlayer = players.value(list[i].getTargetPlayerId(), 0);
-		if (!startPlayer || !targetPlayer)
-			continue;
-		
-		CardZone *startZone = startPlayer->getZones().value(list[i].getStartZone(), 0);
-		CardZone *targetZone = targetPlayer->getZones().value(list[i].getTargetZone(), 0);
-		if (!startZone || !targetZone)
-			continue;
-		
-		CardItem *startCard = startZone->getCard(list[i].getStartCardId(), QString());
-		CardItem *targetCard = targetZone->getCard(list[i].getTargetCardId(), QString());
-		if (!startCard || !targetCard)
-			continue;
-
-		p->addArrow(list[i].getId(), startCard, targetCard, list[i].getColor());
-	}
 }
 
-void Game::playerListReceived(QList<ServerPlayer> playerList)
-{
-	QStringList nameList;
-	for (int i = 0; i < playerList.size(); ++i) {
-		nameList << playerList[i].getName();
-		addPlayer(playerList[i].getPlayerId(), playerList[i].getName(), playerList[i].getLocal());
-	}
-	emit logPlayerListReceived(nameList);
-	restartGameDialog();
-}
-*/
 void Game::restartGameDialog()
 {
 //	dlgStartGame->show();
 }
-/*
-void Game::gameEvent(const ServerEventData &msg)
-{
-	qDebug(QString("game::gameEvent: public=%1, player=%2, name=%3, type=%4, data=%5").arg(msg.getPublic()).arg(msg.getPlayerId()).arg(msg.getPlayerName()).arg(msg.getEventType()).arg(msg.getEventData().join("/")).toLatin1());
-	Player *p = players.value(msg.getPlayerId(), 0);
-	if (!msg.getPublic()) {
-		if (!p)
-			return;
-		p->gameEvent(msg);
-	} else {
-		if ((msg.getPlayerId() != -1) && (!p) && (msg.getEventType() != eventJoin) && (msg.getEventType() != eventLeave)) {
-			qDebug("Game::gameEvent: invalid player");
-			return;
-		}
-
-		switch(msg.getEventType()) {
-		case eventSay:
-			emit logSay(p, msg.getEventData()[0]);
-			break;
-		case eventJoin: {
-			const QStringList &data = msg.getEventData();
-			if (data.size() != 1)
-				return;
-			bool spectator = data[0].toInt();
-			if (spectator) {
-				spectatorList << msg.getPlayerName();
-				emit logJoinSpectator(msg.getPlayerName());
-			} else {
-				Player *newPlayer = addPlayer(msg.getPlayerId(), msg.getPlayerName(), false);
-				emit logJoin(newPlayer);
-			}
-			break;
-		}
-		case eventLeave: {
-			if (p)
-				emit logLeave(p);
-				// XXX Spieler natürlich noch rauswerfen
-			else {
-				int spectatorIndex = spectatorList.indexOf(msg.getPlayerName());
-				if (spectatorIndex != -1) {
-					spectatorList.removeAt(spectatorIndex);
-					emit logLeaveSpectator(msg.getPlayerName());
-				}
-			}
-			break;
-		}
-		case eventGameClosed: {
-			started = false;
-			emit logGameClosed();
-			break;
-		}
-		case eventReadyStart:
-			if (started) {
-				started = false;
-				emit logReadyStart(p);
-				if (!p->getLocal())
-					restartGameDialog();
-			}
-			break;
-		case eventGameStart:
-			started = true;
-			emit logGameStart();
-			break;
-		case eventShuffle:
-			emit logShuffle(p);
-			break;
-		case eventRollDie: {
-			QStringList data = msg.getEventData();
-			int sides = data[0].toInt();
-			int roll = data[1].toInt();
-			emit logRollDie(p, sides, roll);
-			break;
-		}
-		case eventSetActivePlayer: {
-			QStringList data = msg.getEventData();
-			int playerId = data[0].toInt();
-			Player *player = players.value(playerId, 0);
-			if (!player) {
-				qDebug(QString("setActivePlayer: invalid player: %1").arg(playerId).toLatin1());
-				break;
-			}
-			QMapIterator<int, Player *> i(players);
-			while (i.hasNext()) {
-				i.next();
-				i.value()->setActive(i.value() == player);
-			}
-			emit logSetActivePlayer(player);
-			break;
-		}
-		case eventSetActivePhase: {
-			QStringList data = msg.getEventData();
-			int phase = data[0].toInt();
-			if (currentPhase != phase) {
-				currentPhase = phase;
-				emit setActivePhase(phase);
-			}
-			break;
-		}
-		case eventCreateArrow:
-		case eventDeleteArrow:
-		case eventCreateToken:
-		case eventSetupZones:
-		case eventSetCardAttr:
-		case eventAddCounter:
-		case eventSetCounter:
-		case eventDelCounter: {
-			p->gameEvent(msg);
-			break;
-		}
-		case eventDumpZone: {
-			QStringList data = msg.getEventData();
-			Player *zoneOwner = players.value(data[0].toInt(), 0);
-			if (!zoneOwner)
-				break;
-			CardZone *zone = zoneOwner->getZones().value(data[1], 0);
-			if (!zone)
-				break;
-			emit logDumpZone(p, zone, data[2].toInt());
-			break;
-		}
-		case eventStopDumpZone: {
-			QStringList data = msg.getEventData();
-			Player *zoneOwner = players.value(data[0].toInt(), 0);
-			if (!zoneOwner)
-				break;
-			CardZone *zone = zoneOwner->getZones().value(data[1], 0);
-			if (!zone)
-				break;
-			emit logStopDumpZone(p, zone);
-			break;
-		}
-		case eventMoveCard: {
-			if (!p->getLocal())
-				p->gameEvent(msg);
-			break;
-		}
-		case eventDraw: {
-			emit logDraw(p, msg.getEventData()[0].toInt());
-			if (!p->getLocal())
-				p->gameEvent(msg);
-			break;
-		}
-		case eventInvalid: {
-			qDebug("Unhandled global event");
-		}
-		default: {
-		}
-		}
-	}
-}
-*/
-void Game::actNextPhase()
-{
-	int phase = currentPhase;
-	if (++phase >= phaseCount)
-		phase = 0;
-//	client->setActivePhase(phase);
-}
-
-void Game::actNextTurn()
-{
-//	client->nextTurn();
-}
-
-void Game::actRemoveLocalArrows()
-{
-	for (int i = 0; i < players.size(); ++i) {
-		if (!players[i]->getLocal())
-			continue;
-		QMapIterator<int, ArrowItem *> arrowIterator(players[i]->getArrows());
-		while (arrowIterator.hasNext()) {
-			ArrowItem *a = arrowIterator.next().value();
-//			players[i]->client->deleteArrow(a->getId());
-		}
-	}
-}
 
 void Game::showCardMenu(QPoint p)
 {
@@ -458,49 +202,3 @@ void Game::actMoveToExile(CardItem *card)
 //	CardZone *startZone = qgraphicsitem_cast<CardZone *>(card->parentItem());
 //	client->moveCard(card->getId(), startZone->getName(), "rfg", 0, 0, false);
 }
-
-void Game::hoverCardEvent(CardItem *card)
-{
-	emit hoverCard(card->getName());
-}
-
-void Game::queryGameState()
-{
-/*	PendingCommand_DumpAll *pc = client->dumpAll();
-	connect(pc, SIGNAL(playerListReceived(QList<ServerPlayer>)), this, SLOT(playerListReceived(QList<ServerPlayer>)));
-	connect(pc, SIGNAL(zoneListReceived(QList<ServerZone>)), this, SLOT(zoneListReceived(QList<ServerZone>)));
-	connect(pc, SIGNAL(cardListReceived(QList<ServerZoneCard>)), this, SLOT(cardListReceived(QList<ServerZoneCard>)));
-	connect(pc, SIGNAL(counterListReceived(QList<ServerCounter>)), this, SLOT(counterListReceived(QList<ServerCounter>)));
-	connect(pc, SIGNAL(arrowListReceived(QList<ServerArrow>)), this, SLOT(arrowListReceived(QList<ServerArrow>)));
-*/}
-
-void Game::activePlayerDrawCard()
-{
-	Player *p = getActiveLocalPlayer();
-	if (p)
-		p->actDrawCard();
-}
-
-void Game::activePlayerUntapAll()
-{
-	Player *p = getActiveLocalPlayer();
-	if (p)
-		p->actUntapAll();
-}
-
-Player *Game::getActiveLocalPlayer() const
-{
-	int localPlayerCount = 0;
-	QMapIterator<int, Player *> i(players);
-	while (i.hasNext())
-		if (i.next().value()->getLocal())
-			++localPlayerCount;
-	
-	i.toFront();
-	while (i.hasNext()) {
-		Player *p = i.next().value();
-		if (p->getLocal() && (p->getActive() || (localPlayerCount == 1)))
-			return p;
-	}
-	return 0;
-}

cockatrice/src/messagelogwidget.cpp

 #include "messagelogwidget.h"
-#include "game.h"
 #include "player.h"
 #include "cardzone.h"
 #include <QApplication>
@@ -50,23 +49,19 @@ void MessageLogWidget::logProtocolError()
 	append(tr("Protocol error."));
 }
 
-void MessageLogWidget::logPlayerListReceived(QStringList players)
+void MessageLogWidget::logGameJoined(int gameId)
 {
-	append("---");
-	append(tr("You have joined the game. Player list:"));
-	for (int i = 0; i < players.size(); i++)
-		append(sanitizeHtml(players.at(i)));
-	append("---");
+	append(tr("You have joined game #%1.").arg(gameId));
 }
 
 void MessageLogWidget::logJoin(Player *player)
 {
-	append(tr("%1 has joined the game").arg(sanitizeHtml(player->getName())));
+	append(tr("%1 has joined the game.").arg(sanitizeHtml(player->getName())));
 }
 
 void MessageLogWidget::logLeave(Player *player)
 {
-	append(tr("%1 has left the game").arg(sanitizeHtml(player->getName())));
+	append(tr("%1 has left the game.").arg(sanitizeHtml(player->getName())));
 }
 
 void MessageLogWidget::logGameClosed()
@@ -84,9 +79,17 @@ void MessageLogWidget::logLeaveSpectator(QString name)
 	append(tr("%1 is not watching the game any more.").arg(sanitizeHtml(name)));
 }
 
+void MessageLogWidget::logDeckSelect(Player *player, int deckId)
+{
+	if (deckId == -1)
+		append(tr("%1 has loaded a local deck.").arg(sanitizeHtml(player->getName())));
+	else
+		append(tr("%1 has loaded deck #%2.").arg(sanitizeHtml(player->getName())).arg(deckId));
+}
+
 void MessageLogWidget::logReadyStart(Player *player)
 {
-	append(tr("%1 is ready to start a new game.").arg(sanitizeHtml(player->getName())));
+	append(tr("%1 is ready to start the game.").arg(sanitizeHtml(player->getName())));
 }
 
 void MessageLogWidget::logGameStart()
@@ -109,7 +112,7 @@ void MessageLogWidget::logRollDie(Player *player, int sides, int roll)
 	append(tr("%1 rolls a %2 with a %3-sided die.").arg(sanitizeHtml(player->getName())).arg(roll).arg(sides));
 }
 
-void MessageLogWidget::logDraw(Player *player, int number)
+void MessageLogWidget::logDrawCards(Player *player, int number)
 {
 	if (number == 1)
 		append(tr("%1 draws a card.").arg(sanitizeHtml(player->getName())));
@@ -277,29 +280,27 @@ void MessageLogWidget::logSetActivePhase(int phase)
 
 void MessageLogWidget::connectToPlayer(Player *player)
 {
-/*	connect(game, SIGNAL(logPlayerListReceived(QStringList)), this, SLOT(logPlayerListReceived(QStringList)));
+	connect(player, SIGNAL(logSay(Player *, QString)), this, SLOT(logSay(Player *, QString)));
+	connect(player, SIGNAL(logDeckSelect(Player *, int)), this, SLOT(logDeckSelect(Player *, int)));
+	connect(player, SIGNAL(logReadyStart(Player *)), this, SLOT(logReadyStart(Player *)));
+	connect(player, SIGNAL(logShuffle(Player *)), this, SLOT(logShuffle(Player *)));
+	connect(player, SIGNAL(logRollDie(Player *, int, int)), this, SLOT(logRollDie(Player *, int, int)));
+	connect(player, SIGNAL(logCreateArrow(Player *, Player *, QString, Player *, QString)), this, SLOT(logCreateArrow(Player *, Player *, QString, Player *, QString)));
+	connect(player, SIGNAL(logCreateToken(Player *, QString)), this, SLOT(logCreateToken(Player *, QString)));
+	connect(player, SIGNAL(logSetCounter(Player *, QString, int, int)), this, SLOT(logSetCounter(Player *, QString, int, int)));
+	connect(player, SIGNAL(logSetCardCounters(Player *, QString, int, int)), this, SLOT(logSetCardCounters(Player *, QString, int, int)));
+	connect(player, SIGNAL(logSetTapped(Player *, QString, bool)), this, SLOT(logSetTapped(Player *, QString, bool)));
+	connect(player, SIGNAL(logSetDoesntUntap(Player *, QString, bool)), this, SLOT(logSetDoesntUntap(Player *, QString, bool)));
+	connect(player, SIGNAL(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)), this, SLOT(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)));
+	connect(player, SIGNAL(logDumpZone(Player *, CardZone *, int)), this, SLOT(logDumpZone(Player *, CardZone *, int)));
+	connect(player, SIGNAL(logStopDumpZone(Player *, CardZone *)), this, SLOT(logStopDumpZone(Player *, CardZone *)));
+	connect(player, SIGNAL(logDrawCards(Player *, int)), this, SLOT(logDrawCards(Player *, int)));
+/*
 	connect(game, SIGNAL(logJoin(Player *)), this, SLOT(logJoin(Player *)));
 	connect(game, SIGNAL(logLeave(Player *)), this, SLOT(logLeave(Player *)));
 	connect(game, SIGNAL(logGameClosed()), this, SLOT(logGameClosed()));
 	connect(game, SIGNAL(logJoinSpectator(QString)), this, SLOT(logJoinSpectator(QString)));
 	connect(game, SIGNAL(logLeaveSpectator(QString)), this, SLOT(logLeaveSpectator(QString)));
-	connect(game, SIGNAL(logReadyStart(Player *)), this, SLOT(logReadyStart(Player *)));
-	connect(game, SIGNAL(logGameStart()), this, SLOT(logGameStart()));
-	connect(game, SIGNAL(logSay(Player *, QString)), this, SLOT(logSay(Player *, QString)));
-	connect(game, SIGNAL(logShuffle(Player *)), this, SLOT(logShuffle(Player *)));
-	connect(game, SIGNAL(logRollDie(Player *, int, int)), this, SLOT(logRollDie(Player *, int, int)));
-	connect(game, SIGNAL(logDraw(Player *, int)), this, SLOT(logDraw(Player *, int)));
-	connect(game, SIGNAL(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)), this, SLOT(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)));
-	connect(game, SIGNAL(logCreateToken(Player *, QString)), this, SLOT(logCreateToken(Player *, QString)));
-	connect(game, SIGNAL(logCreateArrow(Player *, Player *, QString, Player *, QString)), this, SLOT(logCreateArrow(Player *, Player *, QString, Player *, QString)));
-	connect(game, SIGNAL(logSetCardCounters(Player *, QString, int, int)), this, SLOT(logSetCardCounters(Player *, QString, int, int)));
-	connect(game, SIGNAL(logSetTapped(Player *, QString, bool)), this, SLOT(logSetTapped(Player *, QString, bool)));
-	connect(game, SIGNAL(logSetCounter(Player *, QString, int, int)), this, SLOT(logSetCounter(Player *, QString, int, int)));
-	connect(game, SIGNAL(logSetDoesntUntap(Player *, QString, bool)), this, SLOT(logSetDoesntUntap(Player *, QString, bool)));
-	connect(game, SIGNAL(logDumpZone(Player *, CardZone *, int)), this, SLOT(logDumpZone(Player *, CardZone *, int)));
-	connect(game, SIGNAL(logStopDumpZone(Player *, CardZone *)), this, SLOT(logStopDumpZone(Player *, CardZone *)));
-	connect(game, SIGNAL(logSetActivePlayer(Player *)), this, SLOT(logSetActivePlayer(Player *)));
-	connect(game, SIGNAL(setActivePhase(int)), this, SLOT(logSetActivePhase(int)));
 	
 	//Alert Test
 	connect(game, SIGNAL(logSay(Player *, QString)), this, SLOT(msgAlert()));

cockatrice/src/messagelogwidget.h

@@ -22,19 +22,19 @@ public slots:
 	void logServerError(ResponseCode response);
 	void logProtocolVersionMismatch(int clientVersion, int serverVersion);
 	void logProtocolError();
-private slots:
-	void logPlayerListReceived(QStringList players);
+	void logGameJoined(int gameId);
 	void logJoin(Player *player);
 	void logLeave(Player *player);
 	void logGameClosed();
 	void logJoinSpectator(QString name);
 	void logLeaveSpectator(QString name);
+	void logDeckSelect(Player *player, int deckId);
 	void logReadyStart(Player *player);
 	void logGameStart();
 	void logSay(Player *player, QString message);
 	void logShuffle(Player *player);
 	void logRollDie(Player *player, int sides, int roll);
-	void logDraw(Player *player, int number);
+	void logDrawCards(Player *player, int number);
 	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
 	void logCreateToken(Player *player, QString cardName);
 	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);

cockatrice/src/phasestoolbar.cpp

-#include "phasestoolbar.h"
 #include <QAction>
 #include <QVBoxLayout>
 #include <QPainter>
 #include <QPen>
+#include "phasestoolbar.h"
+#include "protocol_items.h"
 
 PhaseButton::PhaseButton(const QIcon &icon, QAction *_doubleClickAction)
 	: QPushButton(icon, QString()), active(false), doubleClickAction(_doubleClickAction), activePixmap(50, 50), inactivePixmap(50, 50)
@@ -54,9 +55,9 @@ PhasesToolbar::PhasesToolbar(QWidget *parent)
 	: QFrame(parent)
 {
 	QAction *aUntapAll = new QAction(this);
-	connect(aUntapAll, SIGNAL(triggered()), this, SIGNAL(signalUntapAll()));
+	connect(aUntapAll, SIGNAL(triggered()), this, SLOT(actUntapAll()));
 	QAction *aDrawCard = new QAction(this);
-	connect(aDrawCard, SIGNAL(triggered()), this, SIGNAL(signalDrawCard()));
+	connect(aDrawCard, SIGNAL(triggered()), this, SLOT(actDrawCard()));
 	
 	PhaseButton *untapButton = new PhaseButton(QIcon(":/resources/icon_phase_untap.svg"), aUntapAll);
 	PhaseButton *upkeepButton = new PhaseButton(QIcon(":/resources/icon_phase_upkeep.svg"));
@@ -80,7 +81,7 @@ PhasesToolbar::PhasesToolbar(QWidget *parent)
 	QPushButton *nextTurnButton = new QPushButton(QIcon(":/resources/icon_nextturn.svg"), QString());
 	nextTurnButton->setIconSize(QSize(40, 40));
 	nextTurnButton->setFixedSize(50, 50);
-	connect(nextTurnButton, SIGNAL(clicked()), this, SIGNAL(signalNextTurn()));
+	connect(nextTurnButton, SIGNAL(clicked()), this, SLOT(actNextTurn()));
 		
 	QVBoxLayout *layout = new QVBoxLayout;
 	layout->setSpacing(0);
@@ -138,5 +139,20 @@ void PhasesToolbar::phaseButtonClicked()
 	PhaseButton *button = qobject_cast<PhaseButton *>(sender());
 	if (button->getActive())
 		return;
-	emit signalSetPhase(buttonList.indexOf(button));
+	emit sendGameCommand(new Command_SetActivePhase(-1, buttonList.indexOf(button)));
+}
+
+void PhasesToolbar::actNextTurn()
+{
+	emit sendGameCommand(new Command_NextTurn);
+}
+
+void PhasesToolbar::actUntapAll()
+{
+	emit sendGameCommand(new Command_SetCardAttr(-1, "table", -1, "tapped", "0"));
+}
+
+void PhasesToolbar::actDrawCard()
+{
+	emit sendGameCommand(new Command_DrawCards(-1, 1));
 }

cockatrice/src/phasestoolbar.h

@@ -6,6 +6,7 @@
 #include <QPushButton>
 
 class Player;
+class GameCommand;
 
 class PhaseButton : public QPushButton {
 	Q_OBJECT
@@ -34,15 +35,16 @@ private:
 public:
 	PhasesToolbar(QWidget *parent = 0);
 	void retranslateUi();
+	int phaseCount() const { return buttonList.size(); }
 public slots:
 	void setActivePhase(int phase);
 private slots:
 	void phaseButtonClicked();
+	void actNextTurn();
+	void actUntapAll();
+	void actDrawCard();
 signals:
-	void signalSetPhase(int phase);
-	void signalNextTurn();
-	void signalUntapAll();
-	void signalDrawCard();
+	void sendGameCommand(GameCommand *command);
 };
 
 #endif

cockatrice/src/pilezone.cpp

 #include <QtGui>
 #include "pilezone.h"
 #include "player.h"
-#include "game.h"
 #include "client.h"
 #include "carddragitem.h"
 #include "zoneviewzone.h"
@@ -94,6 +93,6 @@ void PileZone::mouseReleaseEvent(QGraphicsSceneMouseEvent */*event*/)
 void PileZone::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
 	if (!cards.isEmpty())
-		((Game *) player->parent())->hoverCardEvent(cards.at(0));
+		cards[0]->processHoverEvent();
 	QGraphicsItem::hoverEnterEvent(event);
 }

cockatrice/src/player.cpp

@@ -213,7 +213,7 @@ Player::~Player()
 
 void Player::updateBoundingRect()
 {
-	// XXX! PREPARE GEOMETRY CHANGE
+	prepareGeometryChange();
 	bRect = QRectF(0, 0, CARD_WIDTH + 5 + counterAreaWidth + hand->boundingRect().width() + table->boundingRect().width(), table->boundingRect().height());
 	emit sizeChanged();
 }
@@ -296,6 +296,22 @@ void Player::initSayMenu()
 	}
 }
 
+void Player::prepareForGame()
+{
+	if (local) {
+		sendGameCommand(new Command_CreateCounter(-1, "life", Qt::white, 25, 20));
+		sendGameCommand(new Command_CreateCounter(-1, "w", QColor(255, 255, 150), 20, 0));
+		sendGameCommand(new Command_CreateCounter(-1, "u", QColor(150, 150, 255), 20, 0));
+		sendGameCommand(new Command_CreateCounter(-1, "b", QColor(150, 150, 150), 20, 0));
+		sendGameCommand(new Command_CreateCounter(-1, "r", QColor(250, 150, 150), 20, 0));
+		sendGameCommand(new Command_CreateCounter(-1, "g", QColor(150, 255, 150), 20, 0));
+		sendGameCommand(new Command_CreateCounter(-1, "x", QColor(255, 255, 255), 20, 0));
+		sendGameCommand(new Command_CreateCounter(-1, "storm", QColor(255, 255, 255), 20, 0));
+		
+		mulliganCards = 7;
+	}
+}
+
 void Player::actViewLibrary()
 {
 	emit toggleZoneView(this, "deck", -1);
@@ -407,240 +423,212 @@ void Player::setCardAttrHelper(CardItem *card, const QString &aname, const QStri
 	}
 }
 
-/*void Player::gameEvent(const ServerEventData &event)
+void Player::eventDeckSelect(Event_DeckSelect *event)
 {
-	QStringList data = event.getEventData();
-	switch (event.getEventType()) {
-		case eventSetupZones: {
-			// XXX Life counter
-			int deck_cards = data[0].toInt();
-			int sb_cards = data[1].toInt();
-			// XXX Fehlerbehandlung
+	emit logDeckSelect(this, event->getDeckId());
+}
 
-			// Clean up existing zones first
-			QMapIterator<QString, CardZone *> zoneIterator(zones);
-			while (zoneIterator.hasNext()) {
-				zoneIterator.next();
-				if (ZoneViewZone *view = zoneIterator.value()->getView())
-					((ZoneViewWidget *) view->parentItem())->close();
-				zoneIterator.value()->clearContents();
-			}
+void Player::eventSay(Event_Say *event)
+{
+	emit logSay(this, event->getMessage());
+}
 
-			clearCounters();
-			clearArrows();
-
-			CardZone *deck = zones.value("deck");
-			for (; deck_cards; deck_cards--)
-				deck->addCard(new CardItem(db), false, -1);
-
-			CardZone *sb = zones.value("sb");
-			for (; sb_cards; sb_cards--)
-				sb->addCard(new CardItem(db), false, -1);
-
-			zoneIterator.toFront();
-			while (zoneIterator.hasNext())
-				zoneIterator.next().value()->reorganizeCards();
-
-			if (local) {
-				client->addCounter("life", Qt::white, 25, 20);
-				client->addCounter("w", QColor(255, 255, 150), 20, 0);
-				client->addCounter("u", QColor(150, 150, 255), 20, 0);
-				client->addCounter("b", QColor(150, 150, 150), 20, 0);
-				client->addCounter("r", QColor(250, 150, 150), 20, 0);
-				client->addCounter("g", QColor(150, 255, 150), 20, 0);
-				client->addCounter("x", QColor(255, 255, 255), 20, 0);
-				client->addCounter("storm", QColor(255, 255, 255), 20, 0);
-				
-				mulliganCards = 7;
-			}
+void Player::eventReadyStart(Event_ReadyStart * /*event*/)
+{
+	emit logReadyStart(this);
+}
 
-			break;
-		}
-		case eventDraw: {
-			CardZone *deck = zones.value("deck");
-			CardZone *hand = zones.value("hand");
-			if (!event.getPublic()) {
-				hand->addCard(deck->takeCard(0, data[0].toInt(), data[1]), true, -1);
-			} else {
-				int number = data[0].toInt();
-				for (; number; number--)
-					hand->addCard(deck->takeCard(0, -1, QString()), false, -1);
-				hand->reorganizeCards();
-			}
-			break;
-		}
-		case eventMoveCard: {
-			if (data.size() != 8)
-				break;
-			int cardId = data[0].toInt();
-			QString cardName = data[1];
-			CardZone *startZone = zones.value(data[2], 0);
-			if (!startZone) {
-				qDebug(QString("start zone invalid: %1").arg(data[2]).toLatin1());
-				break;
-			}
-			int position = data[3].toInt();
-			CardZone *targetZone = zones.value(data[4], 0);
-			if (!targetZone) {
-				qDebug(QString("target zone invalid: %1").arg(data[4]).toLatin1());
-				break;
-			}
+void Player::eventShuffle(Event_Shuffle * /*event*/)
+{
+	emit logShuffle(this);
+}
 
-			int x = data[5].toInt();
-			int y = data[6].toInt();
-			bool facedown = data[7].toInt();
-
-			int logPosition = position;
-			int logX = x;
-			if (position == -1)
-				position = 0;
-			if (x == -1)
-				x = 0;
-			CardItem *card = startZone->takeCard(position, cardId, cardName, startZone != targetZone);
-			if (!card) {
-				qDebug("moveCard: card not found");
-				break;
-			}
-			
-			card->deleteDragItem();
-
-			card->setFaceDown(facedown);
-
-			// 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.
-			emit logMoveCard(this, card->getName(), startZone, logPosition, targetZone, logX);
-
-			targetZone->addCard(card, true, x, y);
-
-			// Look at all arrows from and to the card.
-			// If the card was moved to another zone, delete the arrows, otherwise update them.
-			QMapIterator<int, Player *> playerIterator(static_cast<Game *>(parent())->getPlayers());
-			while (playerIterator.hasNext()) {
-				Player *p = playerIterator.next().value();
-
-				QList<int> arrowsToDelete;
-				QMapIterator<int, ArrowItem *> arrowIterator(p->getArrows());
-				while (arrowIterator.hasNext()) {
-					ArrowItem *arrow = arrowIterator.next().value();
-					if ((arrow->getStartItem() == card) || (arrow->getTargetItem() == card)) {
-						if (startZone == targetZone)
-							arrow->updatePath();
-						else
-							arrowsToDelete.append(arrow->getId());
-					}
-				}
-				for (int i = 0; i < arrowsToDelete.size(); ++i)
-					p->delArrow(arrowsToDelete[i]);
-			}
+void Player::eventRollDie(Event_RollDie *event)
+{
+	emit logRollDie(this, event->getSides(), event->getValue());
+}
 
-			break;
-		}
-		case eventCreateToken: {
-			// zone, cardid, cardname, powtough, x, y
-			if (data.size() != 6)
-				break;
-			CardZone *zone = zones.value(data[0], 0);
-			if (!zone)
-				break;
-			int cardid = data[1].toInt();
-			QString cardname = data[2];
-			QString powtough = data[3];
-			int x = data[4].toInt();
-			int y = data[5].toInt();
-
-			CardItem *card = new CardItem(db, cardname, cardid);
-
-			emit logCreateToken(this, card->getName());
-			zone->addCard(card, true, x, y);
-
-			break;
-		}
-		case eventSetCardAttr: {
-			if (data.size() != 4)
-				break;
-			CardZone *zone = zones.value(data[0], 0);
-			if (!zone)
-				break;
-			int cardId = data[1].toInt();
-			QString aname = data[2];
-			QString avalue = data[3];
-			// XXX Fehlerbehandlung
-
-			if (cardId == -1) {
-				const CardList &cards = zone->getCards();
-				for (int i = 0; i < cards.size(); i++)
-					setCardAttrHelper(cards.at(i), aname, avalue, true);
-				if (aname == "tapped")
-					emit logSetTapped(this, QString("-1"), avalue == "1");
-			} else {
-				CardItem *card = zone->getCard(cardId, "");
-				setCardAttrHelper(card, aname, avalue, false);
+void Player::eventCreateArrow(Event_CreateArrow *event)
+{
+	ArrowItem *arrow = addArrow(event->getArrow());
+	if (!arrow)
+		return;
+	emit logCreateArrow(this, arrow->getStartItem()->getOwner(), arrow->getStartItem()->getName(), arrow->getTargetItem()->getOwner(), arrow->getTargetItem()->getName());
+}
+
+void Player::eventDeleteArrow(Event_DeleteArrow *event)
+{
+	delArrow(event->getArrowId());
+}
+
+void Player::eventCreateToken(Event_CreateToken *event)
+{
+	CardZone *zone = zones.value(event->getZone(), 0);
+	if (!zone)
+		return;
+
+	CardItem *card = new CardItem(this, event->getCardName(), event->getCardId());
+
+	emit logCreateToken(this, card->getName());
+	zone->addCard(card, true, event->getX(), event->getY());
+
+}
+
+void Player::eventSetCardAttr(Event_SetCardAttr *event)
+{
+	CardZone *zone = zones.value(event->getZone(), 0);
+	if (!zone)
+		return;
+
+	if (event->getCardId() == -1) {
+		const CardList &cards = zone->getCards();
+		for (int i = 0; i < cards.size(); i++)
+			setCardAttrHelper(cards.at(i), event->getAttrName(), event->getAttrValue(), true);
+		if (event->getAttrName() == "tapped")
+			emit logSetTapped(this, QString("-1"), event->getAttrValue() == "1");
+	} else {
+		CardItem *card = zone->getCard(event->getCardId(), QString());
+		setCardAttrHelper(card, event->getAttrName(), event->getAttrValue(), false);
+	}
+}
+
+void Player::eventCreateCounter(Event_CreateCounter *event)
+{
+	addCounter(event->getCounter());
+}
+
+void Player::eventSetCounter(Event_SetCounter *event)
+{
+	Counter *c = counters.value(event->getCounterId(), 0);
+	if (!c)
+		return;
+	int oldValue = c->getValue();
+	c->setValue(event->getValue());
+	emit logSetCounter(this, c->getName(), event->getValue(), oldValue);
+}
+
+void Player::eventDelCounter(Event_DelCounter *event)
+{
+	delCounter(event->getCounterId());
+}
+
+void Player::eventDumpZone(Event_DumpZone *event)
+{
+	Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event->getZoneOwnerId(), 0);
+	if (!zoneOwner)
+		return;
+	CardZone *zone = zoneOwner->getZones().value(event->getZone(), 0);
+	if (!zone)
+		return;
+	emit logDumpZone(this, zone, event->getNumberCards());
+}
+
+void Player::eventStopDumpZone(Event_StopDumpZone *event)
+{
+	Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event->getZoneOwnerId(), 0);
+	if (!zoneOwner)
+		return;
+	CardZone *zone = zoneOwner->getZones().value(event->getZone(), 0);
+	if (!zone)
+		return;
+	emit logStopDumpZone(this, zone);
+}
+
+void Player::eventMoveCard(Event_MoveCard *event)
+{
+	CardZone *startZone = zones.value(event->getStartZone(), 0);
+	CardZone *targetZone = zones.value(event->getTargetZone(), 0);
+	if (!startZone || !targetZone)
+		return;
+	
+	int position = event->getPosition();
+	int x = event->getX();
+	int y = event->getY();
+
+	int logPosition = position;
+	int logX = x;
+	if (position == -1)
+		position = 0;
+	if (x == -1)
+		x = 0;
+	CardItem *card = startZone->takeCard(position, event->getCardId(), event->getCardName(), startZone != targetZone);
+	if (!card)
+		return;
+	
+	card->deleteDragItem();
+
+	card->setFaceDown(event->getFaceDown());
+
+	// 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.
+	emit logMoveCard(this, card->getName(), startZone, logPosition, targetZone, logX);
+
+	targetZone->addCard(card, true, x, y);
+
+	// Look at all arrows from and to the card.
+	// If the card was moved to another zone, delete the arrows, otherwise update them.
+	QMapIterator<int, Player *> playerIterator(static_cast<TabGame *>(parent())->getPlayers());
+	while (playerIterator.hasNext()) {
+		Player *p = playerIterator.next().value();
+
+		QList<int> arrowsToDelete;
+		QMapIterator<int, ArrowItem *> arrowIterator(p->getArrows());
+		while (arrowIterator.hasNext()) {
+			ArrowItem *arrow = arrowIterator.next().value();
+			if ((arrow->getStartItem() == card) || (arrow->getTargetItem() == card)) {
+				if (startZone == targetZone)
+					arrow->updatePath();
+				else
+					arrowsToDelete.append(arrow->getId());
 			}
-			break;
-		}
-		case eventAddCounter: {
-			if (data.size() != 5)
-				break;
-			int counterId = data[0].toInt();
-			QString counterName = data[1];
-			int colorValue = data[2].toInt();
-			int radius = data[3].toInt();
-			int value = data[4].toInt();
-			QColor color(colorValue / 65536, (colorValue % 65536) / 256, colorValue % 256);
-			addCounter(counterId, counterName, color, radius, value);
-			break;
 		}
-		case eventSetCounter: {
-			if (data.size() != 2)
-				break;
-			int counterId = data[0].toInt();
-			int value = data[1].toInt();
-			Counter *c = counters.value(counterId, 0);
-			if (!c)
-				break;
-			int oldValue = c->getValue();
-			c->setValue(value);
-			emit logSetCounter(this, c->getName(), value, oldValue);
-			break;
-		}
-		case eventCreateArrow: {
-			if (data.size() != 8)
-				break;
-			
-			const QMap<int, Player *> &playerList = static_cast<Game *>(parent())->getPlayers();
-			
-			Player *startPlayer = playerList.value(data[1].toInt(), 0);
-			Player *targetPlayer = playerList.value(data[4].toInt(), 0);
-			if (!startPlayer || !targetPlayer)
-				return;
-			
-			CardZone *startZone = startPlayer->getZones().value(data[2], 0);
-			CardZone *targetZone = targetPlayer->getZones().value(data[5], 0);
-			if (!startZone || !targetZone)
-				return;
-			
-			CardItem *startCard = startZone->getCard(data[3].toInt(), QString());
-			CardItem *targetCard = targetZone->getCard(data[6].toInt(), QString());
-			if (!startCard || !targetCard)
-				return;
+		for (int i = 0; i < arrowsToDelete.size(); ++i)
+			p->delArrow(arrowsToDelete[i]);
+	}
+}
+
+void Player::eventDrawCards(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)
+			hand->addCard(deck->takeCard(0, cardList[i]->getId(), cardList[i]->getName()), false, -1);
+	else
+		for (int i = 0; i < event->getNumberCards(); ++i)
+			hand->addCard(deck->takeCard(0, -1, QString()), false, -1);
+	hand->reorganizeCards();
+	deck->reorganizeCards();
 	
-			addArrow(data[0].toInt(), startCard, targetCard, client->numberToColor(data[7].toInt()));
-			emit logCreateArrow(this, startPlayer, startCard->getName(), targetPlayer, targetCard->getName());
-			
-			break;
+	emit logDrawCards(this, event->getNumberCards());
+}
+
+void Player::processGameEvent(GameEvent *event)
+{
+	switch (event->getItemId()) {
+		case ItemId_Event_DeckSelect: eventDeckSelect(qobject_cast<Event_DeckSelect *>(event)); break;
+		case ItemId_Event_Say: eventSay(qobject_cast<Event_Say *>(event)); break;
+		case ItemId_Event_ReadyStart: eventReadyStart(qobject_cast<Event_ReadyStart *>(event)); break;
+		case ItemId_Event_Shuffle: eventShuffle(qobject_cast<Event_Shuffle *>(event)); break;
+		case ItemId_Event_RollDie: eventRollDie(qobject_cast<Event_RollDie *>(event)); break;
+		case ItemId_Event_CreateArrow: eventCreateArrow(qobject_cast<Event_CreateArrow *>(event)); break;
+		case ItemId_Event_DeleteArrow: eventDeleteArrow(qobject_cast<Event_DeleteArrow *>(event)); break;
+		case ItemId_Event_CreateToken: eventCreateToken(qobject_cast<Event_CreateToken *>(event)); break;
+		case ItemId_Event_SetCardAttr: eventSetCardAttr(qobject_cast<Event_SetCardAttr *>(event)); break;
+		case ItemId_Event_CreateCounter: eventCreateCounter(qobject_cast<Event_CreateCounter *>(event)); break;
+		case ItemId_Event_SetCounter: eventSetCounter(qobject_cast<Event_SetCounter *>(event)); break;
+		case ItemId_Event_DelCounter: eventDelCounter(qobject_cast<Event_DelCounter *>(event)); break;
+		case ItemId_Event_DumpZone: eventDumpZone(qobject_cast<Event_DumpZone *>(event)); break;
+		case ItemId_Event_StopDumpZone: eventStopDumpZone(qobject_cast<Event_StopDumpZone *>(event)); break;
+		case ItemId_Event_MoveCard: eventMoveCard(qobject_cast<Event_MoveCard *>(event)); break;
+		case ItemId_Event_DrawCards: eventDrawCards(qobject_cast<Event_DrawCards *>(event)); break;
+		default: {
+			qDebug() << "unhandled game event";
 		}
-		case eventDeleteArrow: {
-			if (data.size() != 1)
-				break;
-			
-			delArrow(data[0].toInt());
-			break;
-		}
-		default:
-			qDebug("unhandled player event");
 	}
 }
-*/
+
 void Player::showCardMenu(const QPoint &p)
 {
 	emit sigShowCardMenu(p);
@@ -705,10 +693,10 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
 		const QList<ServerInfo_Card *> &cardList = zoneInfo->getCardList();
 		if (cardList.isEmpty()) {
 			for (int j = 0; j < zoneInfo->getCardCount(); ++j)
-				zone->addCard(new CardItem, false, -1);
+				zone->addCard(new CardItem(this), false, -1);
 		} else {
 			for (int j = 0; j < cardList.size(); ++j) {
-				CardItem *card = new CardItem;
+				CardItem *card = new CardItem(this);
 				card->processCardInfo(cardList[i]);
 				zone->addCard(card, false, cardList[i]->getX(), cardList[i]->getY());
 			}
@@ -718,28 +706,17 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
 
 	clearCounters();
 	for (int i = 0; i < info->getCounterList().size(); ++i) {
-		ServerInfo_Counter *counterInfo = info->getCounterList().at(i);
-		addCounter(counterInfo->getId(), counterInfo->getName(), counterInfo->getColor(), counterInfo->getRadius(), counterInfo->getCount());
+		addCounter(info->getCounterList().at(i));
 	}
 
 	clearArrows();
-	for (int i = 0; i < info->getArrowList().size(); ++i) {
-		ServerInfo_Arrow *arrowInfo = info->getArrowList().at(i);
-		const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
-		Player *startPlayer = playerList.value(arrowInfo->getStartPlayerId(), 0);
-		Player *targetPlayer = playerList.value(arrowInfo->getTargetPlayerId(), 0);
-		if (!startPlayer || !targetPlayer)
-			continue;
-		CardZone *startZone = startPlayer->getZones().value(arrowInfo->getStartZone(), 0);
-		CardZone *targetZone = targetPlayer->getZones().value(arrowInfo->getTargetZone(), 0);
-		if (!startZone || !targetZone)
-			continue;
-		CardItem *startCard = startZone->getCard(arrowInfo->getStartCardId(), QString());
-		CardItem *targetCard = targetZone->getCard(arrowInfo->getTargetCardId(), QString());
-		if (!startCard || !targetCard)
-			continue;
-		addArrow(arrowInfo->getId(), startCard, targetCard, arrowInfo->getColor());
-	}
+	for (int i = 0; i < info->getArrowList().size(); ++i)
+		addArrow(info->getArrowList().at(i));
+}
+
+void Player::addCard(CardItem *c)
+{
+	emit newCardAdded(c);
 }
 
 void Player::addZone(CardZone *z)
@@ -747,13 +724,19 @@ void Player::addZone(CardZone *z)
 	zones.insert(z->getName(), z);
 }
 
-void Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
+Counter *Player::addCounter(ServerInfo_Counter *counter)
+{
+	return addCounter(counter->getId(), counter->getName(), counter->getColor(), counter->getRadius(), counter->getCount());
+}
+
+Counter *Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
 {
 	Counter *c = new Counter(this, counterId, name, color, radius, value, this);
 	counters.insert(counterId, c);
 	if (countersMenu)
 		countersMenu->addMenu(c->getMenu());
 	rearrangeCounters();
+	return c;
 }
 
 void Player::delCounter(int counterId)
@@ -774,11 +757,33 @@ void Player::clearCounters()
 	counters.clear();
 }
 
-void Player::addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color)
+ArrowItem *Player::addArrow(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);
+	if (!startPlayer || !targetPlayer)
+		return 0;
+	
+	CardZone *startZone = startPlayer->getZones().value(arrow->getStartZone(), 0);
+	CardZone *targetZone = targetPlayer->getZones().value(arrow->getTargetZone(), 0);
+	if (!startZone || !targetZone)
+		return 0;
+	
+	CardItem *startCard = startZone->getCard(arrow->getStartCardId(), QString());
+	CardItem *targetCard = targetZone->getCard(arrow->getTargetCardId(), QString());
+	if (!startCard || !targetCard)
+		return 0;
+	
+	return addArrow(arrow->getId(), startCard, targetCard, arrow->getColor());
+}
+
+ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color)
 {
 	ArrowItem *arrow = new ArrowItem(this, arrowId, startCard, targetCard, color);
 	arrows.insert(arrowId, arrow);
 	scene()->addItem(arrow);
+	return arrow;
 }
 
 void Player::delArrow(int arrowId)

cockatrice/src/player.h

@@ -4,7 +4,6 @@
 #include <QInputDialog>
 #include <QPoint>
 #include <QMap>
-#include "client.h"
 #include "carditem.h"
 
 class Client;
@@ -19,24 +18,50 @@ class CardZone;
 class TableZone;
 class HandZone;
 class ServerInfo_Player;
+class ServerInfo_Arrow;
+class ServerInfo_Counter;
 class GameCommand;
+class GameEvent;
+class Event_DeckSelect;
+class Event_Say;
+class Event_ReadyStart;
+class Event_Shuffle;
+class Event_RollDie;
+class Event_CreateArrow;
+class Event_DeleteArrow;
+class Event_CreateToken;
+class Event_SetCardAttr;
+class Event_CreateCounter;
+class Event_SetCounter;
+class Event_DelCounter;
+class Event_DumpZone;
+class Event_StopDumpZone;
+class Event_MoveCard;
+class Event_DrawCards;
 
 class Player : public QObject, public QGraphicsItem {
 	Q_OBJECT
 signals:
-	void moveCard(int cardId, QString startZone, QString targetZone, int x, int y);
-	void hoverCard(QString name);
 	void closeZoneView(ZoneViewZone *zone);
 	void toggleZoneView(Player *player, QString zoneName, int number);
-	void sigShowCardMenu(QPoint p);
+	void sigShowCardMenu(QPoint p); // XXX
+	void newCardAdded(CardItem *card);
 	// Log events
-	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
+	void logDeckSelect(Player *player, int deckId);
+	void logSay(Player *player, QString message);
+	void logReadyStart(Player *player);
+	void logShuffle(Player *player);
+	void logRollDie(Player *player, int sides, int roll);
+	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
 	void logCreateToken(Player *player, QString cardName);
+	void logDrawCards(Player *player, int number);
+	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
 	void logSetCardCounters(Player *player, QString cardName, int value, int oldValue);
 	void logSetTapped(Player *player, QString cardName, bool tapped);
 	void logSetCounter(Player *player, QString counterName, int value, int oldValue);
-	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
 	void logSetDoesntUntap(Player *player, QString cardName, bool doesntUntap);
+	void logDumpZone(Player *player, CardZone *zone, int numberCards);
+	void logStopDumpZone(Player *player, CardZone *zone);
 	
 	void sizeChanged();
 public slots:
@@ -87,6 +112,23 @@ private:
 	void rearrangeCounters();
 	
 	void initSayMenu();
+	
+	void eventDeckSelect(Event_DeckSelect *event);
+	void eventSay(Event_Say *event);
+	void eventReadyStart(Event_ReadyStart *event);
+	void eventShuffle(Event_Shuffle *event);
+	void eventRollDie(Event_RollDie *event);
+	void eventCreateArrow(Event_CreateArrow *event);
+	void eventDeleteArrow(Event_DeleteArrow *event);
+	void eventCreateToken(Event_CreateToken *event);
+	void eventSetCardAttr(Event_SetCardAttr *event);
+	void eventCreateCounter(Event_CreateCounter *event);
+	void eventSetCounter(Event_SetCounter *event);
+	void eventDelCounter(Event_DelCounter *event);
+	void eventDumpZone(Event_DumpZone *event);
+	void eventStopDumpZone(Event_StopDumpZone *event);
+	void eventMoveCard(Event_MoveCard *event);
+	void eventDrawCards(Event_DrawCards *event);
 public:
 	static const int counterAreaWidth = 65;
 	
@@ -95,13 +137,16 @@ public:
 	QRectF boundingRect() const;
 	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 	
+	void addCard(CardItem *c);
 	void addZone(CardZone *z);
 
-	void addCounter(int counterId, const QString &name, QColor color, int radius, int value);
+	Counter *addCounter(ServerInfo_Counter *counter);
+	Counter *addCounter(int counterId, const QString &name, QColor color, int radius, int value);
 	void delCounter(int counterId);
 	void clearCounters();
 	
-	void addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color);
+	ArrowItem *addArrow(ServerInfo_Arrow *arrow);
+	ArrowItem *addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color);
 	void delArrow(int arrowId);
 	void clearArrows();
 
@@ -116,12 +161,13 @@ public:
 	const QMap<QString, CardZone *> &getZones() const { return zones; }
 	const QMap<int, ArrowItem *> &getArrows() const { return arrows; }
 	TableZone *getTable() const { return table; }
-//	void gameEvent(const ServerEventData &event);
 	void showCardMenu(const QPoint &p);
 	bool getActive() const { return active; }
 	void setActive(bool _active);
-
+	
+	void prepareForGame();
 	void processPlayerInfo(ServerInfo_Player *info);
+	void processGameEvent(GameEvent *event);
 	void sendGameCommand(GameCommand *command);
 };
 

cockatrice/src/playerlistwidget.cpp

+#include "playerlistwidget.h"
+#include "protocol_datastructures.h"
+
+PlayerListWidget::PlayerListWidget(QWidget *parent)
+	: QTreeWidget(parent)
+{
+	setColumnCount(1);
+	setRootIsDecorated(false);
+	retranslateUi();
+}
+
+void PlayerListWidget::retranslateUi()
+{
+	headerItem()->setText(0, tr("Player name"));
+}
+
+void PlayerListWidget::addPlayer(ServerInfo_Player *player)
+{
+	QTreeWidgetItem *newPlayer = new QTreeWidgetItem;
+	newPlayer->setText(0, player->getName());
+	addTopLevelItem(newPlayer);
+	players.insert(player->getPlayerId(), newPlayer);
+}
+
+void PlayerListWidget::removePlayer(int playerId)
+{
+	QTreeWidgetItem *player = players.value(playerId, 0);
+	if (!player)
+		return;
+	players.remove(playerId);
+	delete takeTopLevelItem(indexOfTopLevelItem(player));
+}
+
+void PlayerListWidget::setActivePlayer(int playerId)
+{
+	QMapIterator<int, QTreeWidgetItem *> i(players);
+	while (i.hasNext()) {
+		i.next();
+		QTreeWidgetItem *twi = i.value();
+		twi->setBackground(0, i.key() == playerId ? QColor(150, 255, 150) : Qt::white);
+	}
+}

cockatrice/src/playerlistwidget.h

+#ifndef PLAYERLISTWIDGET_H
+#define PLAYERLISTWIDGET_H
+
+#include <QTreeWidget>
+#include <QMap>
+
+class ServerInfo_Player;
+
+class PlayerListWidget : public QTreeWidget {
+	Q_OBJECT
+private:
+	QMap<int, QTreeWidgetItem *> players;
+public:
+	PlayerListWidget(QWidget *parent = 0);
+	void retranslateUi();
+	void addPlayer(ServerInfo_Player *player);
+	void removePlayer(int playerId);
+	void setActivePlayer(int playerId);
+};
+
+#endif

cockatrice/src/tab_game.cpp

 #include <QtGui>
 #include "tab_game.h"
 #include "cardinfowidget.h"
+#include "playerlistwidget.h"
 #include "messagelogwidget.h"
 #include "phasestoolbar.h"
 #include "gameview.h"
 #include "gamescene.h"
 #include "player.h"
-#include "game.h"
 #include "zoneviewzone.h"
 #include "zoneviewwidget.h"
 #include "zoneviewlayout.h"
@@ -15,10 +15,13 @@
 #include "deck_picturecacher.h"
 #include "protocol_items.h"
 #include "dlg_load_remote_deck.h"
+#include "client.h"
+#include "carditem.h"
+#include "arrowitem.h"
 #include "main.h"
 
 TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectator)
-	: client(_client), gameId(_gameId), localPlayerId(_localPlayerId), spectator(_spectator)
+	: client(_client), gameId(_gameId), localPlayerId(_localPlayerId), spectator(_spectator), started(false), currentPhase(-1)
 {
 	zoneLayout = new ZoneViewLayout;
 	scene = new GameScene(zoneLayout, this);
@@ -41,7 +44,8 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
 	deckViewContainer = new QWidget;
 	deckViewContainer->setLayout(deckViewLayout);
 
-	cardInfo = new CardInfoWidget(db);
+	cardInfo = new CardInfoWidget;
+	playerListWidget = new PlayerListWidget;
 	messageLog = new MessageLogWidget;
 	sayLabel = new QLabel;
 	sayEdit = new QLineEdit;
@@ -53,9 +57,11 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
 
 	phasesToolbar = new PhasesToolbar;
 	phasesToolbar->hide();
+	connect(phasesToolbar, SIGNAL(sendGameCommand(GameCommand *)), this, SLOT(sendGameCommand(GameCommand *)));
 	
 	QVBoxLayout *verticalLayout = new QVBoxLayout;
 	verticalLayout->addWidget(cardInfo);
+	verticalLayout->addWidget(playerListWidget);
 	verticalLayout->addWidget(messageLog);
 	verticalLayout->addLayout(hLayout);
 
@@ -75,36 +81,84 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
 	
 	connect(sayEdit, SIGNAL(returnPressed()), this, SLOT(actSay()));
 
-	connect(phasesToolbar, SIGNAL(signalSetPhase(int)), client, SLOT(setActivePhase(int)));
-	connect(phasesToolbar, SIGNAL(signalNextTurn()), client, SLOT(nextTurn()));
+	// Menu actions
+	aNextPhase = new QAction(this);
+	connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
+	aNextTurn = new QAction(this);
+	connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
+	aRemoveLocalArrows = new QAction(this);
+	connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
+	
+	gameMenu = new QMenu(this);
+	gameMenu->addAction(aNextPhase);
+	gameMenu->addAction(aNextTurn);
+	gameMenu->addSeparator();
+	gameMenu->addAction(aRemoveLocalArrows);
 	
-/*	game = new Game(client, scene, menuBar(), this);
-	connect(game, SIGNAL(hoverCard(QString)), cardInfo, SLOT(setCard(const QString &)));
-	connect(game, SIGNAL(playerAdded(Player *)), this, SLOT(playerAdded(Player *)));
-	connect(game, SIGNAL(playerRemoved(Player *)), scene, SLOT(removePlayer(Player *)));
-	connect(game, SIGNAL(setActivePhase(int)), phasesToolbar, SLOT(setActivePhase(int)));
-	connect(phasesToolbar, SIGNAL(signalDrawCard()), game, SLOT(activePlayerDrawCard()));
-	connect(phasesToolbar, SIGNAL(signalUntapAll()), game, SLOT(activePlayerUntapAll()));
-	messageLog->connectToGame(game);
-
-	game->queryGameState();
-*/
 	retranslateUi();
 	setLayout(mainLayout);
+	
+	messageLog->logGameJoined(gameId);
 }
 
 void TabGame::retranslateUi()
 {
+	gameMenu->setTitle(tr("&Game"));
+	aNextPhase->setText(tr("Next &phase"));
+	aNextPhase->setShortcut(tr("Ctrl+Space"));
+	aNextTurn->setText(tr("Next &turn"));
+	aNextTurn->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+Return")) << QKeySequence(tr("Ctrl+Enter")));
+	aRemoveLocalArrows->setText(tr("&Remove all local arrows"));
+	aRemoveLocalArrows->setShortcut(tr("Ctrl+R"));
+	
 	loadLocalButton->setText(tr("Load &local deck"));
 	loadRemoteButton->setText(tr("Load deck from &server"));
 	readyStartButton->setText(tr("&Start game"));
 	sayLabel->setText(tr("&Say:"));
 	cardInfo->retranslateUi();
-//	if (game)
-//		game->retranslateUi();
 	zoneLayout->retranslateUi();
 	aCloseMostRecentZoneView->setText(tr("Close most recent zone view"));
 	aCloseMostRecentZoneView->setShortcut(tr("Esc"));
+
+	QMapIterator<int, Player *> i(players);
+	while (i.hasNext())
+		i.next().value()->retranslateUi();
+}
+
+void TabGame::actSay()
+{
+	if (!sayEdit->text().isEmpty()) {
+		sendGameCommand(new Command_Say(-1, sayEdit->text()));
+		sayEdit->clear();
+	}
+}
+
+void TabGame::actNextPhase()
+{
+	int phase = currentPhase;
+	if (++phase >= phasesToolbar->phaseCount())
+		phase = 0;
+	sendGameCommand(new Command_SetActivePhase(-1, phase));
+}
+
+void TabGame::actNextTurn()
+{
+	sendGameCommand(new Command_NextTurn);
+}
+
+void TabGame::actRemoveLocalArrows()
+{
+	QMapIterator<int, Player *> playerIterator(players);
+	while (playerIterator.hasNext()) {
+		Player *player = playerIterator.next().value();
+		if (!player->getLocal())
+			continue;
+		QMapIterator<int, ArrowItem *> arrowIterator(player->getArrows());
+		while (arrowIterator.hasNext()) {
+			ArrowItem *a = arrowIterator.next().value();
+			sendGameCommand(new Command_DeleteArrow(-1, a->getId()));
+		}
+	}
 }
 
 Player *TabGame::addPlayer(int playerId, const QString &playerName)
@@ -112,6 +166,7 @@ Player *TabGame::addPlayer(int playerId, const QString &playerName)
 	Player *newPlayer = new Player(playerName, playerId, playerId == localPlayerId, client, this);
 	scene->addPlayer(newPlayer);
 
+	connect(newPlayer, SIGNAL(newCardAdded(CardItem *)), this, SLOT(newCardAdded(CardItem *)));
 	messageLog->connectToPlayer(newPlayer);
 
 	players.insert(playerId, newPlayer);
@@ -125,7 +180,19 @@ void TabGame::processGameEvent(GameEvent *event)
 	switch (event->getItemId()) {
 		case ItemId_Event_GameStart: eventGameStart(qobject_cast<Event_GameStart *>(event)); break;
 		case ItemId_Event_GameStateChanged: eventGameStateChanged(qobject_cast<Event_GameStateChanged *>(event)); break;
-		default: qDebug() << "unhandled game event";
+		case ItemId_Event_Join: eventJoin(qobject_cast<Event_Join *>(event)); break;
+		case ItemId_Event_Leave: eventLeave(qobject_cast<Event_Leave *>(event)); break;
+		case ItemId_Event_GameClosed: eventGameClosed(qobject_cast<Event_GameClosed *>(event)); break;
+		case ItemId_Event_SetActivePlayer: eventSetActivePlayer(qobject_cast<Event_SetActivePlayer *>(event)); break;
+		case ItemId_Event_SetActivePhase: eventSetActivePhase(qobject_cast<Event_SetActivePhase *>(event)); break;
+		default: {
+			Player *player = players.value(event->getPlayerId(), 0);
+			if (!player) {
+				qDebug() << "unhandled game event: invalid player id";
+				break;
+			}
+			player->processGameEvent(event);
+		}
 	}
 }
 
@@ -135,22 +202,83 @@ void TabGame::sendGameCommand(GameCommand *command)
 	client->sendCommand(command);
 }
 
+void TabGame::eventGameStart(Event_GameStart * /*event*/)
+{
+	currentPhase = -1;
+	
+	deckViewContainer->hide();
+	gameView->show();
+	phasesToolbar->show();
+	messageLog->logGameStart();
+	
+	QMapIterator<int, Player *> i(players);
+	while (i.hasNext())
+		i.next().value()->prepareForGame();
+}
+
 void TabGame::eventGameStateChanged(Event_GameStateChanged *event)
 {
 	const QList<ServerInfo_Player *> &plList = event->getPlayerList();
 	for (int i = 0; i < plList.size(); ++i) {
 		ServerInfo_Player *pl = plList[i];
 		Player *player = players.value(pl->getPlayerId(), 0);
-		if (!player)
+		if (!player) {
 			player = addPlayer(pl->getPlayerId(), pl->getName());
+			playerListWidget->addPlayer(pl);
+		}
 		player->processPlayerInfo(pl);
 	}
 }
 
-void TabGame::eventGameStart(Event_GameStart *event)
+void TabGame::eventJoin(Event_Join *event)
 {
-	deckViewContainer->hide();
-	gameView->show();
+	if (event->getSpectator()) {
+		spectatorList.append(event->getPlayerName());
+		messageLog->logJoinSpectator(event->getPlayerName());
+	} else {
+		Player *newPlayer = addPlayer(event->getPlayerId(), event->getPlayerName());
+		messageLog->logJoin(newPlayer);
+	}
+}
+
+void TabGame::eventLeave(Event_Leave *event)
+{
+	Player *player = players.value(event->getPlayerId(), 0);
+	if (!player)
+		return;
+	
+	messageLog->logLeave(player);
+}
+
+void TabGame::eventGameClosed(Event_GameClosed * /*event*/)
+{
+	started = false;
+	messageLog->logGameClosed();
+}
+
+void TabGame::eventSetActivePlayer(Event_SetActivePlayer *event)
+{
+	Player *player = players.value(event->getActivePlayerId(), 0);
+	if (!player)
+		return;
+	playerListWidget->setActivePlayer(event->getActivePlayerId());
+	QMapIterator<int, Player *> i(players);
+	while (i.hasNext()) {
+		i.next();
+		i.value()->setActive(i.value() == player);
+	}
+	messageLog->logSetActivePlayer(player);
+	currentPhase = -1;
+}
+
+void TabGame::eventSetActivePhase(Event_SetActivePhase *event)
+{
+	const int phase = event->getPhase();
+	if (currentPhase != phase) {
+		currentPhase = phase;
+		phasesToolbar->setActivePhase(phase);
+		messageLog->logSetActivePhase(phase);
+	}
 }
 
 void TabGame::loadLocalDeck()
@@ -202,3 +330,8 @@ void TabGame::readyStart()
 {
 	client->sendCommand(new Command_ReadyStart(gameId));
 }
+
+void TabGame::newCardAdded(CardItem *card)
+{
+	connect(card, SIGNAL(hovered(CardItem *)), cardInfo, SLOT(setCard(CardItem *)));
+}

cockatrice/src/tab_game.h

@@ -14,16 +14,25 @@ class MessageLogWidget;
 class QLabel;
 class QLineEdit;
 class QPushButton;
+class QMenu;
 class ZoneViewLayout;
 class ZoneViewWidget;
 class PhasesToolbar;
+class PlayerListWidget;
 class ProtocolResponse;
 class GameEvent;
 class GameCommand;
+class Event_GameStart;
 class Event_GameStateChanged;
+class Event_Join;
+class Event_Leave;
+class Event_GameClosed;
 class Event_GameStart;
+class Event_SetActivePlayer;
+class Event_SetActivePhase;
 class Player;
 class CardZone;
+class CardItem;
 
 class TabGame : public QWidget {
 	Q_OBJECT
@@ -39,6 +48,7 @@ private:
 
 	QPushButton *loadLocalButton, *loadRemoteButton, *readyStartButton;
 	CardInfoWidget *cardInfo;
+	PlayerListWidget *playerListWidget;
 	MessageLogWidget *messageLog;
 	QLabel *sayLabel;
 	QLineEdit *sayEdit;
@@ -48,51 +58,42 @@ private:
 	DeckView *deckView;
 	QWidget *deckViewContainer;
 	ZoneViewLayout *zoneLayout;
-	QAction *aCloseMostRecentZoneView;
+	QAction *aCloseMostRecentZoneView,
+		*aNextPhase, *aNextTurn, *aRemoveLocalArrows;
+	QMenu *gameMenu;
 
 	Player *addPlayer(int playerId, const QString &playerName);
 
-	void eventGameStateChanged(Event_GameStateChanged *event);
 	void eventGameStart(Event_GameStart *event);
+	void eventGameStateChanged(Event_GameStateChanged *event);
+	void eventJoin(Event_Join *event);
+	void eventLeave(Event_Leave *event);
+	void eventGameClosed(Event_GameClosed *event);
+	void eventSetActivePlayer(Event_SetActivePlayer *event);
+	void eventSetActivePhase(Event_SetActivePhase *event);
 signals:
+	// -- XXX --
 	void playerAdded(Player *player);
 	void playerRemoved(Player *player);
-
-	// Log events
-	void logPlayerListReceived(QStringList players);
-	void logJoin(Player *player);
-	void logLeave(Player *player);
-	void logGameClosed();
-	void logJoinSpectator(QString playerName);
-	void logLeaveSpectator(QString playerName);
-	void logReadyStart(Player *player);
-	void logGameStart();
-	void logSay(Player *player, QString text);
-	void logShuffle(Player *player);
-	void logRollDie(Player *player, int sides, int roll);
-	void logDraw(Player *player, int number);
-	void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
-	void logCreateToken(Player *player, QString cardName);
-	void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
-	void logSetCardCounters(Player *player, QString cardName, int value, int oldValue);
-	void logSetTapped(Player *player, QString cardName, bool tapped);
-	void logSetCounter(Player *player, QString counterName, int value, int oldValue);
-	void logSetDoesntUntap(Player *player, QString cardName, bool doesntUntap);
-	void logDumpZone(Player *player, CardZone *zone, int numberCards);
-	void logStopDumpZone(Player *player, CardZone *zone);
-	void logSetActivePlayer(Player *player);
-	void setActivePhase(int phase);
+	// -- XXX --
 private slots:
 	void loadLocalDeck();
 	void loadRemoteDeck();
 	void readyStart();
 	void deckSelectFinished(ProtocolResponse *r);
+	void newCardAdded(CardItem *card);
+	
+	void actRemoveLocalArrows();
+	void actSay();
+	void actNextPhase();
+	void actNextTurn();
 public:
 	TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectator);
 	void retranslateUi();
 	const QMap<int, Player *> &getPlayers() const { return players; }
 
 	void processGameEvent(GameEvent *event);
+public slots:
 	void sendGameCommand(GameCommand *command);
 };
 

cockatrice/src/tab_supervisor.cpp

@@ -125,6 +125,9 @@ void TabSupervisor::processChatEvent(ChatEvent *event)
 void TabSupervisor::processGameEvent(GameEvent *event)
 {
 	TabGame *tab = gameTabs.value(event->getGameId());
-	if (tab)
+	if (tab) {
+		qDebug() << "gameEvent gameId =" << event->getGameId();
 		tab->processGameEvent(event);
+	} else
+		qDebug() << "gameEvent: invalid gameId";
 }