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

@@ -1,12 +1,13 @@
-#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)
+CardInfoWidget::CardInfoWidget(QWidget *parent)
-	: QFrame(parent), db(_db), pixmapHeight(pixmapWidth), info(0)
+	: 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

@@ -1,17 +1,17 @@
 #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 = 160;
-	static const int pixmapWidth = 180;
 	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)
+CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, QGraphicsItem *parent)
-	: AbstractCardItem(_name, parent), id(_cardid), attacking(false), facedown(false), counters(0), doesntUntap(false), dragItem(NULL)
+	: 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

@@ -1,5 +1,4 @@
 #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 game #%1.").arg(gameId));
-	append(tr("You have joined the game. Player list:"));
-	for (int i = 0; i < players.size(); i++)
-		append(sanitizeHtml(players.at(i)));
-	append("---");
 }
 
 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 logGameJoined(int gameId);
-	void logPlayerListReceived(QStringList players);
 	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

@@ -1,8 +1,9 @@
-#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 sendGameCommand(GameCommand *command);
-	void signalNextTurn();
-	void signalUntapAll();
-	void signalDrawCard();
 };
 
 #endif

cockatrice/src/pilezone.cpp

@@ -1,7 +1,6 @@
 #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();
+	emit logDeckSelect(this, event->getDeckId());
-	switch (event.getEventType()) {
+}
-		case eventSetupZones: {
-			// XXX Life counter
-			int deck_cards = data[0].toInt();
-			int sb_cards = data[1].toInt();
-			// XXX Fehlerbehandlung
 
-			// Clean up existing zones first
+void Player::eventSay(Event_Say *event)
-			QMapIterator<QString, CardZone *> zoneIterator(zones);
+{
-			while (zoneIterator.hasNext()) {
+	emit logSay(this, event->getMessage());
-				zoneIterator.next();
+}
-				if (ZoneViewZone *view = zoneIterator.value()->getView())
-					((ZoneViewWidget *) view->parentItem())->close();
-				zoneIterator.value()->clearContents();
-			}
 
-			clearCounters();
+void Player::eventReadyStart(Event_ReadyStart * /*event*/)
-			clearArrows();
+{
+	emit logReadyStart(this);
+}
 
-			CardZone *deck = zones.value("deck");
+void Player::eventShuffle(Event_Shuffle * /*event*/)
-			for (; deck_cards; deck_cards--)
+{
-				deck->addCard(new CardItem(db), false, -1);
+	emit logShuffle(this);
+}
 
-			CardZone *sb = zones.value("sb");
+void Player::eventRollDie(Event_RollDie *event)
-			for (; sb_cards; sb_cards--)
+{
-				sb->addCard(new CardItem(db), false, -1);
+	emit logRollDie(this, event->getSides(), event->getValue());
+}
 
-			zoneIterator.toFront();
+void Player::eventCreateArrow(Event_CreateArrow *event)
-			while (zoneIterator.hasNext())
+{
-				zoneIterator.next().value()->reorganizeCards();
+	ArrowItem *arrow = addArrow(event->getArrow());
+	if (!arrow)
+		return;
+	emit logCreateArrow(this, arrow->getStartItem()->getOwner(), arrow->getStartItem()->getName(), arrow->getTargetItem()->getOwner(), arrow->getTargetItem()->getName());
+}
 
-			if (local) {
+void Player::eventDeleteArrow(Event_DeleteArrow *event)
-				client->addCounter("life", Qt::white, 25, 20);
+{
-				client->addCounter("w", QColor(255, 255, 150), 20, 0);
+	delArrow(event->getArrowId());
-				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::eventCreateToken(Event_CreateToken *event)
-			}
+{
+	CardZone *zone = zones.value(event->getZone(), 0);
+	if (!zone)
+		return;
 
-			break;
+	CardItem *card = new CardItem(this, event->getCardName(), event->getCardId());
-		}
-		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;
-			}
 
-			int x = data[5].toInt();
+	emit logCreateToken(this, card->getName());
-			int y = data[6].toInt();
+	zone->addCard(card, true, event->getX(), event->getY());
-			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();
+void Player::eventSetCardAttr(Event_SetCardAttr *event)
+{
+	CardZone *zone = zones.value(event->getZone(), 0);
+	if (!zone)
+		return;
 
-			card->setFaceDown(facedown);
+	if (event->getCardId() == -1) {
-
+		const CardList &cards = zone->getCards();
-			// The log event has to be sent before the card is added to the target zone
+		for (int i = 0; i < cards.size(); i++)
-			// because the addCard function can modify the card object.
+			setCardAttrHelper(cards.at(i), event->getAttrName(), event->getAttrValue(), true);
-			emit logMoveCard(this, card->getName(), startZone, logPosition, targetZone, logX);
+		if (event->getAttrName() == "tapped")
-
+			emit logSetTapped(this, QString("-1"), event->getAttrValue() == "1");
-			targetZone->addCard(card, true, x, y);
+	} else {
-
+		CardItem *card = zone->getCard(event->getCardId(), QString());
-			// Look at all arrows from and to the card.
+		setCardAttrHelper(card, event->getAttrName(), event->getAttrValue(), false);
-			// 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]);
-			}
-
-			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);
-			}
-			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;
-	
-			addArrow(data[0].toInt(), startCard, targetCard, client->numberToColor(data[7].toInt()));
-			emit logCreateArrow(this, startPlayer, startCard->getName(), targetPlayer, targetCard->getName());
-			
-			break;
-		}
-		case eventDeleteArrow: {
-			if (data.size() != 1)
-				break;
-			
-			delArrow(data[0].toInt());
-			break;
-		}
-		default:
-			qDebug("unhandled player event");
 	}
 }
-*/
+
+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());
+			}
+		}
+		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();
+	
+	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";
+		}
+	}
+}
+
 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(info->getCounterList().at(i));
-		addCounter(counterInfo->getId(), counterInfo->getName(), counterInfo->getColor(), counterInfo->getRadius(), counterInfo->getCount());
 	}
 
 	clearArrows();
-	for (int i = 0; i < info->getArrowList().size(); ++i) {
+	for (int i = 0; i < info->getArrowList().size(); ++i)
-		ServerInfo_Arrow *arrowInfo = info->getArrowList().at(i);
+		addArrow(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);
+void Player::addCard(CardItem *c)
-		if (!startPlayer || !targetPlayer)
+{
-			continue;
+	emit newCardAdded(c);
-		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());
-	}
 }
 
 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

@@ -0,0 +1,42 @@
+#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

@@ -0,0 +1,21 @@
+#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

@@ -1,12 +1,12 @@
 #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)));
+	// Menu actions
-	connect(phasesToolbar, SIGNAL(signalNextTurn()), client, SLOT(nextTurn()));
+	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()));
 	
-/*	game = new Game(client, scene, menuBar(), this);
+	gameMenu = new QMenu(this);
-	connect(game, SIGNAL(hoverCard(QString)), cardInfo, SLOT(setCard(const QString &)));
+	gameMenu->addAction(aNextPhase);
-	connect(game, SIGNAL(playerAdded(Player *)), this, SLOT(playerAdded(Player *)));
+	gameMenu->addAction(aNextTurn);
-	connect(game, SIGNAL(playerRemoved(Player *)), scene, SLOT(removePlayer(Player *)));
+	gameMenu->addSeparator();
-	connect(game, SIGNAL(setActivePhase(int)), phasesToolbar, SLOT(setActivePhase(int)));
+	gameMenu->addAction(aRemoveLocalArrows);
-	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();
+	if (event->getSpectator()) {
-	gameView->show();
+		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_GameStateChanged;
 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);
-
+	// -- XXX --
-	// 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);
 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";
 }

cockatrice/src/window_deckeditor.cpp

@@ -47,7 +47,7 @@ WndDeckEditor::WndDeckEditor(QWidget *parent)
 	leftFrame->addLayout(searchLayout);
 	leftFrame->addWidget(databaseView);
 
-	cardInfo = new CardInfoWidget(db);
+	cardInfo = new CardInfoWidget;
 	cardInfo->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
 
 	QToolBar *verticalToolBar = new QToolBar;

cockatrice/src/window_main.cpp

@@ -143,16 +143,7 @@ void MainWindow::actExit()
 {
 	close();
 }
-/*
-void MainWindow::actSay()
-{
-	if (sayEdit->text().isEmpty())
-		return;
 
-	client->say(sayEdit->text());
-	sayEdit->clear();
-}
-*/
 void MainWindow::serverTimeout()
 {
 	QMessageBox::critical(this, tr("Error"), tr("Server timeout"));

cockatrice/src/zoneviewzone.cpp

@@ -35,7 +35,7 @@ void ZoneViewZone::initializeCards()
 		int number = numberCards == -1 ? c.size() : (numberCards < c.size() ? numberCards : c.size());
 		for (int i = 0; i < number; i++) {
 			CardItem *card = c.at(i);
-			addCard(new CardItem(card->getName(), card->getId(), this), false, i);
+			addCard(new CardItem(player, card->getName(), card->getId(), this), false, i);
 		}
 		emit contentsChanged();
 		reorganizeCards();
@@ -45,7 +45,7 @@ void ZoneViewZone::initializeCards()
 void ZoneViewZone::zoneDumpReceived(QList<ServerInfo_Card> cards)
 {
 	for (int i = 0; i < cards.size(); i++) {
-		CardItem *card = new CardItem(cards[i].getName(), i, this);
+		CardItem *card = new CardItem(player, cards[i].getName(), i, this);
 		addCard(card, false, i);
 	}
 	

common/protocol.cpp

@@ -77,6 +77,9 @@ void ProtocolItem::initializeHash()
 	itemNameHash.insert("generic_eventlist_games", Event_ListGames::newItem);
 	itemNameHash.insert("generic_eventlist_chat_channels", Event_ListChatChannels::newItem);
 	itemNameHash.insert("game_eventgame_state_changed", Event_GameStateChanged::newItem);
+	itemNameHash.insert("game_eventcreate_arrow", Event_CreateArrow::newItem);
+	itemNameHash.insert("game_eventcreate_counter", Event_CreateCounter::newItem);
+	itemNameHash.insert("game_eventdraw_cards", Event_DrawCards::newItem);
 	itemNameHash.insert("chat_eventchat_list_players", Event_ChatListPlayers::newItem);
 }
 
@@ -422,7 +425,7 @@ void Event_ListGames::writeElement(QXmlStreamWriter *xml)
 }
 
 Event_GameStateChanged::Event_GameStateChanged(int _gameId, const QList<ServerInfo_Player *> &_playerList)
-	: GameEvent("game_state_changed", _gameId, -1), currentItem(0), readFinished(false), playerList(_playerList)
+	: GameEvent("game_state_changed", _gameId, -1), currentItem(0), playerList(_playerList)
 {
 }
 
@@ -456,3 +459,115 @@ void Event_GameStateChanged::writeElement(QXmlStreamWriter *xml)
 	for (int i = 0; i < playerList.size(); ++i)
 		playerList[i]->writeElement(xml);
 }
+
+Event_CreateArrow::Event_CreateArrow(int _gameId, int _playerId, ServerInfo_Arrow *_arrow)
+	: GameEvent("create_arrow", _gameId, _playerId), arrow(_arrow), readFinished(false)
+{
+}
+
+Event_CreateArrow::~Event_CreateArrow()
+{
+	delete arrow;
+}
+
+bool Event_CreateArrow::readElement(QXmlStreamReader *xml)
+{
+	if (readFinished)
+		return false;
+	
+	if (!arrow) {
+		if (xml->isStartElement() && (xml->name() == "arrow"))
+			arrow = new ServerInfo_Arrow;
+		else
+			return false;
+	}
+	
+	if (arrow->readElement(xml))
+		readFinished = true;
+	return true;
+}
+
+void Event_CreateArrow::writeElement(QXmlStreamWriter *xml)
+{
+	if (arrow)
+		arrow->writeElement(xml);
+}
+
+Event_CreateCounter::Event_CreateCounter(int _gameId, int _playerId, ServerInfo_Counter *_counter)
+	: GameEvent("create_counter", _gameId, _playerId), counter(_counter), readFinished(false)
+{
+}
+
+Event_CreateCounter::~Event_CreateCounter()
+{
+	delete counter;
+}
+
+bool Event_CreateCounter::readElement(QXmlStreamReader *xml)
+{
+	if (readFinished)
+		return false;
+	
+	if (!counter) {
+		if (xml->isStartElement() && (xml->name() == "counter"))
+			counter = new ServerInfo_Counter;
+		else
+			return false;
+	}
+	
+	if (counter->readElement(xml))
+		readFinished = true;
+	return true;
+}
+
+void Event_CreateCounter::writeElement(QXmlStreamWriter *xml)
+{
+	if (counter)
+		counter->writeElement(xml);
+}
+
+Event_DrawCards::Event_DrawCards(int _gameId, int _playerId, int _numberCards, const QList<ServerInfo_Card *> &_cardList)
+	: GameEvent("draw_cards", _gameId, _playerId), currentItem(0), numberCards(_numberCards), cardList(_cardList)
+{
+	setParameter("number_cards", numberCards);
+}
+
+Event_DrawCards::~Event_DrawCards()
+{
+	for (int i = 0; i < cardList.size(); ++i)
+		delete cardList[i];
+}
+
+void Event_DrawCards::extractParameters()
+{
+	GameEvent::extractParameters();
+	bool ok;
+	numberCards = parameters["number_cards"].toInt(&ok);
+	if (!ok)
+		numberCards = -1;
+}
+
+bool Event_DrawCards::readElement(QXmlStreamReader *xml)
+{
+	if (currentItem) {
+		if (currentItem->readElement(xml))
+			currentItem = 0;
+		return true;
+	}
+	if (xml->isStartElement() && (xml->name() == "card")) {
+		ServerInfo_Card *card = new ServerInfo_Card;
+		cardList.append(card);
+		currentItem = card;
+	} else
+		return false;
+	if (currentItem)
+		if (currentItem->readElement(xml))
+			currentItem = 0;
+	return true;
+}
+
+void Event_DrawCards::writeElement(QXmlStreamWriter *xml)
+{
+	for (int i = 0; i < cardList.size(); ++i)
+		cardList[i]->writeElement(xml);
+}

common/protocol.h

@@ -23,6 +23,9 @@ enum ItemId {
 	ItemId_Event_ChatListPlayers = ItemId_Other + 201,
 	ItemId_Event_ListGames = ItemId_Other + 202,
 	ItemId_Event_GameStateChanged = ItemId_Other + 203,
+	ItemId_Event_CreateArrow = ItemId_Other + 204,
+	ItemId_Event_CreateCounter = ItemId_Other + 205,
+	ItemId_Event_DrawCards = ItemId_Other + 206,
 	ItemId_Response_DeckList = ItemId_Other + 300,
 	ItemId_Response_DeckDownload = ItemId_Other + 301,
 	ItemId_Response_DeckUpload = ItemId_Other + 302
@@ -341,7 +344,6 @@ class Event_GameStateChanged : public GameEvent {
 	Q_OBJECT
 private:
 	SerializableItem *currentItem;
-	bool readFinished;
 	QList<ServerInfo_Player *> playerList;
 public:
 	Event_GameStateChanged(int _gameId = -1, const QList<ServerInfo_Player *> &_playerList = QList<ServerInfo_Player *>());
@@ -354,4 +356,55 @@ public:
 	void writeElement(QXmlStreamWriter *xml);
 };
 
+class Event_CreateArrow : public GameEvent {
+	Q_OBJECT
+private:
+	ServerInfo_Arrow *arrow;
+	bool readFinished;
+protected:
+	bool readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	Event_CreateArrow(int _gameId = -1, int _playerId = -1, ServerInfo_Arrow *_arrow = 0);
+	~Event_CreateArrow();
+	int getItemId() const { return ItemId_Event_CreateArrow; }
+	static ProtocolItem *newItem() { return new Event_CreateArrow; }
+	ServerInfo_Arrow *getArrow() const { return arrow; }
+};
+
+class Event_CreateCounter : public GameEvent {
+	Q_OBJECT
+private:
+	ServerInfo_Counter *counter;
+	bool readFinished;
+protected:
+	bool readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	Event_CreateCounter(int _gameId = -1, int _playerId = -1, ServerInfo_Counter *_counter = 0);
+	~Event_CreateCounter();
+	int getItemId() const { return ItemId_Event_CreateCounter; }
+	static ProtocolItem *newItem() { return new Event_CreateCounter; }
+	ServerInfo_Counter *getCounter() const { return counter; }
+};
+
+class Event_DrawCards : public GameEvent {
+	Q_OBJECT
+private:
+	SerializableItem *currentItem;
+	int numberCards;
+	QList<ServerInfo_Card *> cardList;
+protected:
+	void extractParameters();
+	bool readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	Event_DrawCards(int _gameId = -1, int _playerId = -1, int numberCards = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>());
+	~Event_DrawCards();
+	int getItemId() const { return ItemId_Event_DrawCards; }
+	static ProtocolItem *newItem() { return new Event_DrawCards; }
+	int getNumberCards() const { return numberCards; }
+	const QList<ServerInfo_Card *> &getCardList() const { return cardList; }
+};
+
 #endif

common/protocol_item_ids.h

@@ -25,39 +25,36 @@ ItemId_Command_DeleteArrow = 1023,
 ItemId_Command_SetCardAttr = 1024,
 ItemId_Command_ReadyStart = 1025,
 ItemId_Command_IncCounter = 1026,
-ItemId_Command_AddCounter = 1027,
+ItemId_Command_CreateCounter = 1027,
 ItemId_Command_SetCounter = 1028,
 ItemId_Command_DelCounter = 1029,
 ItemId_Command_NextTurn = 1030,
 ItemId_Command_SetActivePhase = 1031,
 ItemId_Command_DumpZone = 1032,
 ItemId_Command_StopDumpZone = 1033,
-ItemId_Command_DumpAll = 1034,
+ItemId_Event_Say = 1034,
-ItemId_Event_Say = 1035,
+ItemId_Event_Join = 1035,
-ItemId_Event_Join = 1036,
+ItemId_Event_Leave = 1036,
-ItemId_Event_Leave = 1037,
+ItemId_Event_DeckSelect = 1037,
-ItemId_Event_DeckSelect = 1038,
+ItemId_Event_GameClosed = 1038,
-ItemId_Event_GameClosed = 1039,
+ItemId_Event_ReadyStart = 1039,
-ItemId_Event_ReadyStart = 1040,
+ItemId_Event_GameStart = 1040,
-ItemId_Event_GameStart = 1041,
+ItemId_Event_Shuffle = 1041,
-ItemId_Event_Shuffle = 1042,
+ItemId_Event_RollDie = 1042,
-ItemId_Event_RollDie = 1043,
+ItemId_Event_MoveCard = 1043,
-ItemId_Event_MoveCard = 1044,
+ItemId_Event_CreateToken = 1044,
-ItemId_Event_CreateToken = 1045,
+ItemId_Event_DeleteArrow = 1045,
-ItemId_Event_CreateArrow = 1046,
+ItemId_Event_SetCardAttr = 1046,
-ItemId_Event_DeleteArrow = 1047,
+ItemId_Event_SetCounter = 1047,
-ItemId_Event_SetCardAttr = 1048,
+ItemId_Event_DelCounter = 1048,
-ItemId_Event_AddCounter = 1049,
+ItemId_Event_SetActivePlayer = 1049,
-ItemId_Event_SetCounter = 1050,
+ItemId_Event_SetActivePhase = 1050,
-ItemId_Event_DelCounter = 1051,
+ItemId_Event_DumpZone = 1051,
-ItemId_Event_SetActivePlayer = 1052,
+ItemId_Event_StopDumpZone = 1052,
-ItemId_Event_SetActivePhase = 1053,
+ItemId_Event_ServerMessage = 1053,
-ItemId_Event_DumpZone = 1054,
+ItemId_Event_GameJoined = 1054,
-ItemId_Event_StopDumpZone = 1055,
+ItemId_Event_ChatJoinChannel = 1055,
-ItemId_Event_ServerMessage = 1056,
+ItemId_Event_ChatLeaveChannel = 1056,
-ItemId_Event_GameJoined = 1057,
+ItemId_Event_ChatSay = 1057,
-ItemId_Event_ChatJoinChannel = 1058,
+ItemId_Other = 1058
-ItemId_Event_ChatLeaveChannel = 1059,
-ItemId_Event_ChatSay = 1060,
-ItemId_Other = 1061
 };

common/protocol_items.cpp

@@ -265,15 +265,15 @@ void Command_IncCounter::extractParameters()
 	counterId = parameters["counter_id"].toInt();
 	delta = parameters["delta"].toInt();
 }
-Command_AddCounter::Command_AddCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
+Command_CreateCounter::Command_CreateCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
-	: GameCommand("add_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
+	: GameCommand("create_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
 {
 	setParameter("counter_name", counterName);
 	setParameter("color", color);
 	setParameter("radius", radius);
 	setParameter("value", value);
 }
-void Command_AddCounter::extractParameters()
+void Command_CreateCounter::extractParameters()
 {
 	GameCommand::extractParameters();
 	counterName = parameters["counter_name"];
@@ -343,10 +343,6 @@ void Command_StopDumpZone::extractParameters()
 	playerId = parameters["player_id"].toInt();
 	zoneName = parameters["zone_name"];
 }
-Command_DumpAll::Command_DumpAll(int _gameId)
-	: GameCommand("dump_all", _gameId)
-{
-}
 Event_Say::Event_Say(int _gameId, int _playerId, const QString &_message)
 	: GameEvent("say", _gameId, _playerId), message(_message)
 {
@@ -455,30 +451,6 @@ void Event_CreateToken::extractParameters()
 	x = parameters["x"].toInt();
 	y = parameters["y"].toInt();
 }
-Event_CreateArrow::Event_CreateArrow(int _gameId, int _playerId, int _arrowId, int _startPlayerId, const QString &_startZone, int _startCardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId, const QColor &_color)
-	: GameEvent("create_arrow", _gameId, _playerId), arrowId(_arrowId), startPlayerId(_startPlayerId), startZone(_startZone), startCardId(_startCardId), targetPlayerId(_targetPlayerId), targetZone(_targetZone), targetCardId(_targetCardId), color(_color)
-{
-	setParameter("arrow_id", arrowId);
-	setParameter("start_player_id", startPlayerId);
-	setParameter("start_zone", startZone);
-	setParameter("start_card_id", startCardId);
-	setParameter("target_player_id", targetPlayerId);
-	setParameter("target_zone", targetZone);
-	setParameter("target_card_id", targetCardId);
-	setParameter("color", color);
-}
-void Event_CreateArrow::extractParameters()
-{
-	GameEvent::extractParameters();
-	arrowId = parameters["arrow_id"].toInt();
-	startPlayerId = parameters["start_player_id"].toInt();
-	startZone = parameters["start_zone"];
-	startCardId = parameters["start_card_id"].toInt();
-	targetPlayerId = parameters["target_player_id"].toInt();
-	targetZone = parameters["target_zone"];
-	targetCardId = parameters["target_card_id"].toInt();
-	color = ColorConverter::colorFromInt(parameters["color"].toInt());
-}
 Event_DeleteArrow::Event_DeleteArrow(int _gameId, int _playerId, int _arrowId)
 	: GameEvent("delete_arrow", _gameId, _playerId), arrowId(_arrowId)
 {
@@ -505,24 +477,6 @@ void Event_SetCardAttr::extractParameters()
 	attrName = parameters["attr_name"];
 	attrValue = parameters["attr_value"];
 }
-Event_AddCounter::Event_AddCounter(int _gameId, int _playerId, int _counterId, const QString &_counterName, const QColor &_color, int _radius, int _value)
-	: GameEvent("add_counter", _gameId, _playerId), counterId(_counterId), counterName(_counterName), color(_color), radius(_radius), value(_value)
-{
-	setParameter("counter_id", counterId);
-	setParameter("counter_name", counterName);
-	setParameter("color", color);
-	setParameter("radius", radius);
-	setParameter("value", value);
-}
-void Event_AddCounter::extractParameters()
-{
-	GameEvent::extractParameters();
-	counterId = parameters["counter_id"].toInt();
-	counterName = parameters["counter_name"];
-	color = ColorConverter::colorFromInt(parameters["color"].toInt());
-	radius = parameters["radius"].toInt();
-	value = parameters["value"].toInt();
-}
 Event_SetCounter::Event_SetCounter(int _gameId, int _playerId, int _counterId, int _value)
 	: GameEvent("set_counter", _gameId, _playerId), counterId(_counterId), value(_value)
 {
@@ -675,14 +629,13 @@ void ProtocolItem::initializeHashAuto()
 	itemNameHash.insert("cmdset_card_attr", Command_SetCardAttr::newItem);
 	itemNameHash.insert("cmdready_start", Command_ReadyStart::newItem);
 	itemNameHash.insert("cmdinc_counter", Command_IncCounter::newItem);
-	itemNameHash.insert("cmdadd_counter", Command_AddCounter::newItem);
+	itemNameHash.insert("cmdcreate_counter", Command_CreateCounter::newItem);
 	itemNameHash.insert("cmdset_counter", Command_SetCounter::newItem);
 	itemNameHash.insert("cmddel_counter", Command_DelCounter::newItem);
 	itemNameHash.insert("cmdnext_turn", Command_NextTurn::newItem);
 	itemNameHash.insert("cmdset_active_phase", Command_SetActivePhase::newItem);
 	itemNameHash.insert("cmddump_zone", Command_DumpZone::newItem);
 	itemNameHash.insert("cmdstop_dump_zone", Command_StopDumpZone::newItem);
-	itemNameHash.insert("cmddump_all", Command_DumpAll::newItem);
 	itemNameHash.insert("game_eventsay", Event_Say::newItem);
 	itemNameHash.insert("game_eventjoin", Event_Join::newItem);
 	itemNameHash.insert("game_eventleave", Event_Leave::newItem);
@@ -694,10 +647,8 @@ void ProtocolItem::initializeHashAuto()
 	itemNameHash.insert("game_eventroll_die", Event_RollDie::newItem);
 	itemNameHash.insert("game_eventmove_card", Event_MoveCard::newItem);
 	itemNameHash.insert("game_eventcreate_token", Event_CreateToken::newItem);
-	itemNameHash.insert("game_eventcreate_arrow", Event_CreateArrow::newItem);
 	itemNameHash.insert("game_eventdelete_arrow", Event_DeleteArrow::newItem);
 	itemNameHash.insert("game_eventset_card_attr", Event_SetCardAttr::newItem);
-	itemNameHash.insert("game_eventadd_counter", Event_AddCounter::newItem);
 	itemNameHash.insert("game_eventset_counter", Event_SetCounter::newItem);
 	itemNameHash.insert("game_eventdel_counter", Event_DelCounter::newItem);
 	itemNameHash.insert("game_eventset_active_player", Event_SetActivePlayer::newItem);

common/protocol_items.dat

@@ -24,14 +24,13 @@
 2:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
 2:ready_start
 2:inc_counter:i,counter_id:i,delta
-2:add_counter:s,counter_name:c,color:i,radius:i,value
+2:create_counter:s,counter_name:c,color:i,radius:i,value
 2:set_counter:i,counter_id:i,value
 2:del_counter:i,counter_id
 2:next_turn
 2:set_active_phase:i,phase
 2:dump_zone:i,player_id:s,zone_name:i,number_cards
 2:stop_dump_zone:i,player_id:s,zone_name
-2:dump_all
 3:say:s,message
 3:join:s,player_name:b,spectator
 3:leave
@@ -43,10 +42,8 @@
 3:roll_die:i,sides:i,value
 3:move_card:i,card_id:s,card_name:s,start_zone:i,position:s,target_zone:i,x:i,y:b,face_down
 3:create_token:s,zone:i,card_id:s,card_name:s,pt:i,x:i,y
-3:create_arrow:i,arrow_id:i,start_player_id:s,start_zone:i,start_card_id:i,target_player_id:s,target_zone:i,target_card_id:c,color
 3:delete_arrow:i,arrow_id
 3:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
-3:add_counter:i,counter_id:s,counter_name:c,color:i,radius:i,value
 3:set_counter:i,counter_id:i,value
 3:del_counter:i,counter_id
 3:set_active_player:i,active_player_id

common/protocol_items.h

@@ -335,7 +335,7 @@ public:
 protected:
 	void extractParameters();
 };
-class Command_AddCounter : public GameCommand {
+class Command_CreateCounter : public GameCommand {
 	Q_OBJECT
 private:
 	QString counterName;
@@ -343,13 +343,13 @@ private:
 	int radius;
 	int value;
 public:
-	Command_AddCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
+	Command_CreateCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
 	QString getCounterName() const { return counterName; }
 	QColor getColor() const { return color; }
 	int getRadius() const { return radius; }
 	int getValue() const { return value; }
-	static ProtocolItem *newItem() { return new Command_AddCounter; }
+	static ProtocolItem *newItem() { return new Command_CreateCounter; }
-	int getItemId() const { return ItemId_Command_AddCounter; }
+	int getItemId() const { return ItemId_Command_CreateCounter; }
 protected:
 	void extractParameters();
 };
@@ -429,14 +429,6 @@ public:
 protected:
 	void extractParameters();
 };
-class Command_DumpAll : public GameCommand {
-	Q_OBJECT
-private:
-public:
-	Command_DumpAll(int _gameId = -1);
-	static ProtocolItem *newItem() { return new Command_DumpAll; }
-	int getItemId() const { return ItemId_Command_DumpAll; }
-};
 class Event_Say : public GameEvent {
 	Q_OBJECT
 private:
@@ -577,32 +569,6 @@ public:
 protected:
 	void extractParameters();
 };
-class Event_CreateArrow : public GameEvent {
-	Q_OBJECT
-private:
-	int arrowId;
-	int startPlayerId;
-	QString startZone;
-	int startCardId;
-	int targetPlayerId;
-	QString targetZone;
-	int targetCardId;
-	QColor color;
-public:
-	Event_CreateArrow(int _gameId = -1, int _playerId = -1, int _arrowId = -1, int _startPlayerId = -1, const QString &_startZone = QString(), int _startCardId = -1, int _targetPlayerId = -1, const QString &_targetZone = QString(), int _targetCardId = -1, const QColor &_color = QColor());
-	int getArrowId() const { return arrowId; }
-	int getStartPlayerId() const { return startPlayerId; }
-	QString getStartZone() const { return startZone; }
-	int getStartCardId() const { return startCardId; }
-	int getTargetPlayerId() const { return targetPlayerId; }
-	QString getTargetZone() const { return targetZone; }
-	int getTargetCardId() const { return targetCardId; }
-	QColor getColor() const { return color; }
-	static ProtocolItem *newItem() { return new Event_CreateArrow; }
-	int getItemId() const { return ItemId_Event_CreateArrow; }
-protected:
-	void extractParameters();
-};
 class Event_DeleteArrow : public GameEvent {
 	Q_OBJECT
 private:
@@ -633,26 +599,6 @@ public:
 protected:
 	void extractParameters();
 };
-class Event_AddCounter : public GameEvent {
-	Q_OBJECT
-private:
-	int counterId;
-	QString counterName;
-	QColor color;
-	int radius;
-	int value;
-public:
-	Event_AddCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
-	int getCounterId() const { return counterId; }
-	QString getCounterName() const { return counterName; }
-	QColor getColor() const { return color; }
-	int getRadius() const { return radius; }
-	int getValue() const { return value; }
-	static ProtocolItem *newItem() { return new Event_AddCounter; }
-	int getItemId() const { return ItemId_Event_AddCounter; }
-protected:
-	void extractParameters();
-};
 class Event_SetCounter : public GameEvent {
 	Q_OBJECT
 private:

common/server_game.cpp

@@ -219,13 +219,14 @@ QList<ServerInfo_Player *> Server_Game::getGameState(Server_Player *playerWhosAs
 	return result;
 }
 
-void Server_Game::sendGameEvent(GameEvent *event)
+void Server_Game::sendGameEvent(GameEvent *event, Server_Player *exclude)
 {
 	event->setGameId(gameId);
 	QList<Server_Player *> receivers = QList<Server_Player *>() << players.values() << spectators;
 	
 	for (int i = 0; i < receivers.size(); ++i)
-		receivers[i]->sendProtocolItem(event, false);
+		if (receivers[i] != exclude)
+			receivers[i]->sendProtocolItem(event, false);
 
 	delete event;
 }

common/server_game.h

@@ -66,7 +66,7 @@ public:
 	void setActivePhase(int _activePhase);
 
 	QList<ServerInfo_Player *> getGameState(Server_Player *playerWhosAsking) const;
-	void sendGameEvent(GameEvent *event);
+	void sendGameEvent(GameEvent *event, Server_Player *exclude = 0);
 };
 
 #endif

common/server_protocolhandler.cpp

@@ -80,14 +80,13 @@ void Server_ProtocolHandler::processCommand(Command *command)
 			case ItemId_Command_SetCardAttr: response = cmdSetCardAttr(qobject_cast<Command_SetCardAttr *>(command), game, player); break;
 			case ItemId_Command_ReadyStart: response = cmdReadyStart(qobject_cast<Command_ReadyStart *>(command), game, player); break;
 			case ItemId_Command_IncCounter: response = cmdIncCounter(qobject_cast<Command_IncCounter *>(command), game, player); break;
-			case ItemId_Command_AddCounter: response = cmdAddCounter(qobject_cast<Command_AddCounter *>(command), game, player); break;
+			case ItemId_Command_CreateCounter: response = cmdCreateCounter(qobject_cast<Command_CreateCounter *>(command), game, player); break;
 			case ItemId_Command_SetCounter: response = cmdSetCounter(qobject_cast<Command_SetCounter *>(command), game, player); break;
 			case ItemId_Command_DelCounter: response = cmdDelCounter(qobject_cast<Command_DelCounter *>(command), game, player); break;
 			case ItemId_Command_NextTurn: response = cmdNextTurn(qobject_cast<Command_NextTurn *>(command), game, player); break;
 			case ItemId_Command_SetActivePhase: response = cmdSetActivePhase(qobject_cast<Command_SetActivePhase *>(command), game, player); break;
 			case ItemId_Command_DumpZone: response = cmdDumpZone(qobject_cast<Command_DumpZone *>(command), game, player); break;
 			case ItemId_Command_StopDumpZone: response = cmdStopDumpZone(qobject_cast<Command_StopDumpZone *>(command), game, player); break;
-			case ItemId_Command_DumpAll: response = cmdDumpAll(qobject_cast<Command_DumpAll *>(command), game, player); break;
 		}
 	} else {
 		qDebug() << "received generic Command";
@@ -297,13 +296,16 @@ ResponseCode Server_ProtocolHandler::cmdDrawCards(Command_DrawCards *cmd, Server
 	if (deck->cards.size() < number)
 		number = deck->cards.size();
 
+	QList<ServerInfo_Card *> cardList;
 	for (int i = 0; i < number; ++i) {
 		Server_Card *card = deck->cards.takeFirst();
 		hand->cards.append(card);
-//		player->privateEvent(QString("draw|%1|%2").arg(card->getId()).arg(card->getName()));
+		cardList.append(new ServerInfo_Card(card->getId(), card->getName()));
 	}
 	
-//	game->broadcastEvent(QString("draw|%1").arg(number), player);
+	player->sendProtocolItem(new Event_DrawCards(game->getGameId(), player->getPlayerId(), cardList.size(), cardList));
+	game->sendGameEvent(new Event_DrawCards(-1, player->getPlayerId(), cardList.size()), player);
+
 	return RespOk;
 }
 
@@ -365,9 +367,9 @@ ResponseCode Server_ProtocolHandler::cmdMoveCard(Command_MoveCard *cmd, Server_G
 		x = -1;
 	
 	if ((startzone->getType() == PublicZone) || (targetzone->getType() == PublicZone))
-		game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), card->getId(), publicCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown));
+		game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), card->getId(), publicCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown), player);
 	else
-		game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getName(), x, y, false));
+		game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getName(), x, y, false), player);
 
 	// If the card was moved to another zone, delete all arrows from and to the card
 	if (startzone != targetzone) {
@@ -425,9 +427,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
 
 	Server_Arrow *arrow = new Server_Arrow(player->newArrowId(), startCard, targetCard, cmd->getColor());
 	player->addArrow(arrow);
-	game->sendGameEvent(new Event_CreateArrow(
+	game->sendGameEvent(new Event_CreateArrow(-1, player->getPlayerId(), new ServerInfo_Arrow(
-		-1,
-		player->getPlayerId(),
 		arrow->getId(),
 		startPlayer->getPlayerId(),
 		startZone->getName(),
@@ -436,7 +436,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
 		targetZone->getName(),
 		targetCard->getId(),
 		cmd->getColor()
-	));
+	)));
 	return RespOk;
 }
 
@@ -496,11 +496,11 @@ ResponseCode Server_ProtocolHandler::cmdIncCounter(Command_IncCounter *cmd, Serv
 	return RespOk;
 }
 
-ResponseCode Server_ProtocolHandler::cmdAddCounter(Command_AddCounter *cmd, Server_Game *game, Server_Player *player)
+ResponseCode Server_ProtocolHandler::cmdCreateCounter(Command_CreateCounter *cmd, Server_Game *game, Server_Player *player)
 {
 	Server_Counter *c = new Server_Counter(player->newCounterId(), cmd->getCounterName(), cmd->getColor(), cmd->getRadius(), cmd->getValue());
 	player->addCounter(c);
-	game->sendGameEvent(new Event_AddCounter(-1, player->getPlayerId(), c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount()));
+	game->sendGameEvent(new Event_CreateCounter(-1, player->getPlayerId(), new ServerInfo_Counter(c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount())));
 	
 	return RespOk;
 }
@@ -575,8 +575,3 @@ ResponseCode Server_ProtocolHandler::cmdStopDumpZone(Command_StopDumpZone *cmd,
 	}
 	return RespOk;
 }
-
-ResponseCode Server_ProtocolHandler::cmdDumpAll(Command_DumpAll *cmd, Server_Game *game, Server_Player *player)
-{
-	return RespOk;
-}

common/server_protocolhandler.h

@@ -57,14 +57,13 @@ private:
 	ResponseCode cmdSetCardAttr(Command_SetCardAttr *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdReadyStart(Command_ReadyStart *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdIncCounter(Command_IncCounter *cmd, Server_Game *game, Server_Player *player);
-	ResponseCode cmdAddCounter(Command_AddCounter *cmd, Server_Game *game, Server_Player *player);
+	ResponseCode cmdCreateCounter(Command_CreateCounter *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdSetCounter(Command_SetCounter *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdDelCounter(Command_DelCounter *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdNextTurn(Command_NextTurn *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdSetActivePhase(Command_SetActivePhase *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdDumpZone(Command_DumpZone *cmd, Server_Game *game, Server_Player *player);
 	ResponseCode cmdStopDumpZone(Command_StopDumpZone *cmd, Server_Game *game, Server_Player *player);
-	ResponseCode cmdDumpAll(Command_DumpAll *cmd, Server_Game *game, Server_Player *player);
 public:
 	Server_ProtocolHandler(Server *_server, QObject *parent = 0);
 	~Server_ProtocolHandler();

servatrice/src/serversocketinterface.cpp

@@ -152,8 +152,9 @@ bool ServerSocketInterface::deckListHelper(DeckList_Directory *folder)
 			return false;
 	}
 	
-	query.prepare("select id, name, upload_time from decklist_files where id_folder = :id_folder");
+	query.prepare("select id, name, upload_time from decklist_files where id_folder = :id_folder and user = :user");
 	query.bindValue(":id_folder", folder->getId());
+	query.bindValue(":user", playerName);
 	if (!servatrice->execSqlQuery(query))
 		return false;