blah

cockatrice/src/carditem.cpp

@@ -74,14 +74,12 @@ void CardItem::resetState()
 
 void CardItem::processCardInfo(ServerInfo_Card *info)
 {
-	id = info->getId();
+	setId(info->getId());
-	name = info->getName();
+	setName(info->getName());
-	attacking = info->getAttacking();
+	setAttacking(info->getAttacking());
-	counters = info->getCounters();
+	setCounters(info->getCounters());
-	annotation = info->getAnnotation();
+	setAnnotation(info->getAnnotation());
-	tapped = info->getTapped();
+	setTapped(info->getTapped());
-
-	update();
 }
 
 CardDragItem *CardItem::createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown)

cockatrice/src/cardzone.cpp

@@ -82,6 +82,7 @@ void CardZone::mousePressEvent(QGraphicsSceneMouseEvent *event)
 
 void CardZone::addCard(CardItem *card, bool reorganize, int x, int y)
 {
+	dumpObjectInfo();
 	if (view)
 		if ((x <= view->getCards().size()) || (view->getNumberCards() == -1))
 			view->addCard(new CardItem(player, card->getName(), card->getId()), reorganize, x, y);
@@ -90,7 +91,6 @@ void CardZone::addCard(CardItem *card, bool reorganize, int x, int y)
 
 	if (reorganize) {
 		qDebug("------------ emitting");
-		dumpObjectInfo();
 		emit contentsChanged();
 		reorganizeCards();
 	}
@@ -111,6 +111,15 @@ CardItem *CardZone::getCard(int cardId, const QString &cardName)
 
 CardItem *CardZone::takeCard(int position, int cardId, const QString &cardName, bool /*canResize*/)
 {
+	if (position == -1) {
+		for (int i = 0; i < cards.size(); ++i)
+			if (cards[i]->getId() == cardId) {
+				position = i;
+				break;
+			}
+		if (position == -1)
+			return 0;
+	}
 	Q_ASSERT(position < cards.size());
 
 	CardItem *c = cards.takeAt(position);

cockatrice/src/client.cpp

@@ -32,7 +32,7 @@ Client::~Client()
 
 void Client::slotSocketError(QAbstractSocket::SocketError /*error*/)
 {
-	emit logSocketError(socket->errorString());
+	emit socketError(socket->errorString());
 	disconnectFromServer();
 }
 
@@ -48,7 +48,7 @@ void Client::loginResponse(ResponseCode response)
 		setStatus(StatusLoggedIn);
 	else {
 		emit serverError(response);
-		disconnectFromServer();
+		setStatus(StatusDisconnecting);
 	}
 }
 
@@ -82,10 +82,13 @@ void Client::readData()
 				connect(cmdLogin, SIGNAL(finished(ResponseCode)), this, SLOT(loginResponse(ResponseCode)));
 				sendCommand(cmdLogin);
 
-				topLevelItem->read(xmlReader);
+				if (topLevelItem)
+					topLevelItem->read(xmlReader);
 			}
 		}
 	}
+	if (status == StatusDisconnecting)
+		disconnectFromServer();
 }
 
 void Client::processProtocolItem(ProtocolItem *item)
@@ -96,10 +99,9 @@ void Client::processProtocolItem(ProtocolItem *item)
 		if (!cmd)
 			return;
 		
+		pendingCommands.remove(cmd->getCmdId());
 		cmd->processResponse(response);
 		delete response;
-		
-		pendingCommands.remove(cmd->getCmdId());
 		delete cmd;
 		
 		return;

cockatrice/src/client.h

@@ -24,6 +24,7 @@ class Event_GameJoined;
 
 enum ClientStatus {
 	StatusDisconnected,
+	StatusDisconnecting,
 	StatusConnecting,
 	StatusAwaitingWelcome,
 	StatusLoggingIn,
@@ -36,7 +37,7 @@ signals:
 	void statusChanged(ClientStatus _status);
 	void maxPingTime(int seconds, int maxSeconds);
 	void serverTimeout();
-	void logSocketError(const QString &errorString);
+	void socketError(const QString &errorString);
 	void serverError(ResponseCode resp);
 	void protocolVersionMismatch(int clientVersion, int serverVersion);
 	void protocolError();

cockatrice/src/dlg_connect.cpp

@@ -50,6 +50,7 @@ DlgConnect::DlgConnect(QWidget *parent)
 
 	setWindowTitle(tr("Connect to server"));
 	setFixedHeight(sizeHint().height());
+	setMinimumWidth(300);
 
 	connect(okButton, SIGNAL(clicked()), this, SLOT(actOk()));
 	connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));

cockatrice/src/player.cpp

@@ -546,14 +546,18 @@ void Player::eventMoveCard(Event_MoveCard *event)
 	if (!startZone || !targetZone)
 		return;
 	
+	qDebug("Player::eventMoveCard --- startZone");
+	startZone->dumpObjectInfo();
+	qDebug("Player::eventMoveCard --- targetZone");
+	targetZone->dumpObjectInfo();
+	qDebug("---");
+
 	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);
@@ -702,8 +706,8 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
 		} else {
 			for (int j = 0; j < cardList.size(); ++j) {
 				CardItem *card = new CardItem(this);
-				card->processCardInfo(cardList[i]);
+				card->processCardInfo(cardList[j]);
-				zone->addCard(card, false, cardList[i]->getX(), cardList[i]->getY());
+				zone->addCard(card, false, cardList[j]->getX(), cardList[j]->getY());
 			}
 		}
 		zone->reorganizeCards();

cockatrice/src/tab_chatchannel.cpp

@@ -22,11 +22,25 @@ TabChatChannel::TabChatChannel(Client *_client, const QString &_channelName)
 	hbox->addLayout(vbox);
 	hbox->addWidget(playerList);
 	
+	aLeaveChannel = new QAction(this);
+	connect(aLeaveChannel, SIGNAL(triggered()), this, SLOT(actLeaveChannel()));
+
+	tabMenu = new QMenu(this);
+	tabMenu->addAction(aLeaveChannel);
+
+	retranslateUi();
 	setLayout(hbox);
 }
 
+TabChatChannel::~TabChatChannel()
+{
+	emit channelClosing(this);
+}
+
 void TabChatChannel::retranslateUi()
 {
+	tabMenu->setTitle(tr("C&hat channel"));
+	aLeaveChannel->setText(tr("&Leave channel"));
 }
 
 void TabChatChannel::sendMessage()
@@ -38,6 +52,12 @@ void TabChatChannel::sendMessage()
 	sayEdit->clear();
 }
 
+void TabChatChannel::actLeaveChannel()
+{
+	client->sendCommand(new Command_ChatLeaveChannel(channelName));
+	deleteLater();
+}
+
 void TabChatChannel::processChatEvent(ChatEvent *event)
 {
 	switch (event->getItemId()) {

cockatrice/src/tab_chatchannel.h

@@ -22,8 +22,13 @@ private:
 	QListWidget *playerList;
 	QTextEdit *textEdit;
 	QLineEdit *sayEdit;
+
+	QAction *aLeaveChannel;
+signals:
+	void channelClosing(TabChatChannel *tab);
 private slots:
 	void sendMessage();
+	void actLeaveChannel();
 	
 	void processListPlayersEvent(Event_ChatListPlayers *event);
 	void processJoinChannelEvent(Event_ChatJoinChannel *event);
@@ -31,8 +36,10 @@ private slots:
 	void processSayEvent(Event_ChatSay *event);
 public:
 	TabChatChannel(Client *_client, const QString &_channelName);
+	~TabChatChannel();
 	void retranslateUi();
 	void processChatEvent(ChatEvent *event);
+	QString getChannelName() const { return channelName; }
 };
 
-#endif
+#endif

cockatrice/src/tab_game.cpp

@@ -88,6 +88,8 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
 	connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
 	aRemoveLocalArrows = new QAction(this);
 	connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
+	aLeaveGame = new QAction(this);
+	connect(aLeaveGame, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
 	
 	tabMenu = new QMenu(this);
 	playersSeparator = tabMenu->addSeparator();
@@ -95,6 +97,8 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
 	tabMenu->addAction(aNextTurn);
 	tabMenu->addSeparator();
 	tabMenu->addAction(aRemoveLocalArrows);
+	tabMenu->addSeparator();
+	tabMenu->addAction(aLeaveGame);
 	
 	retranslateUi();
 	setLayout(mainLayout);
@@ -102,6 +106,11 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
 	messageLog->logGameJoined(gameId);
 }
 
+TabGame::~TabGame()
+{
+	emit gameClosing(this);
+}
+
 void TabGame::retranslateUi()
 {
 	tabMenu->setTitle(tr("&Game"));
@@ -111,6 +120,7 @@ void TabGame::retranslateUi()
 	aNextTurn->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+Return")) << QKeySequence(tr("Ctrl+Enter")));
 	aRemoveLocalArrows->setText(tr("&Remove all local arrows"));
 	aRemoveLocalArrows->setShortcut(tr("Ctrl+R"));
+	aLeaveGame->setText(tr("&Leave game"));
 	
 	loadLocalButton->setText(tr("Load &local deck"));
 	loadRemoteButton->setText(tr("Load deck from &server"));
@@ -126,6 +136,15 @@ void TabGame::retranslateUi()
 		i.next().value()->retranslateUi();
 }
 
+void TabGame::actLeaveGame()
+{
+	if (QMessageBox::question(this, tr("Leave game"), tr("Are you sure you want to leave this game?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes)
+		return;
+
+	sendGameCommand(new Command_LeaveGame);
+	deleteLater();
+}
+
 void TabGame::actSay()
 {
 	if (!sayEdit->text().isEmpty()) {
@@ -175,7 +194,6 @@ Player *TabGame::addPlayer(int playerId, const QString &playerName)
 	tabMenu->insertMenu(playersSeparator, newPlayer->getPlayerMenu());
 	
 	players.insert(playerId, newPlayer);
-	emit playerAdded(newPlayer);
 
 	return newPlayer;
 }
@@ -207,15 +225,21 @@ void TabGame::sendGameCommand(GameCommand *command)
 	client->sendCommand(command);
 }
 
-void TabGame::eventGameStart(Event_GameStart * /*event*/)
+void TabGame::startGame()
 {
 	currentPhase = -1;
-	
+
+	started = true;
 	deckViewContainer->hide();
 	gameView->show();
 	phasesToolbar->show();
+}
+
+void TabGame::eventGameStart(Event_GameStart * /*event*/)
+{
+	startGame();
 	messageLog->logGameStart();
-	
+
 	QMapIterator<int, Player *> i(players);
 	while (i.hasNext())
 		i.next().value()->prepareForGame();
@@ -233,26 +257,35 @@ void TabGame::eventGameStateChanged(Event_GameStateChanged *event)
 		}
 		player->processPlayerInfo(pl);
 	}
+	if (event->getGameStarted() && !started) {
+		startGame();
+		setActivePlayer(event->getActivePlayer());
+		setActivePhase(event->getActivePhase());
+	}
 }
 
 void TabGame::eventJoin(Event_Join *event)
 {
-	if (event->getSpectator()) {
+	ServerInfo_Player *playerInfo = event->getPlayer();
-		spectatorList.append(event->getPlayerName());
+	if (playerInfo->getSpectator()) {
-		messageLog->logJoinSpectator(event->getPlayerName());
+		spectatorList.append(playerInfo->getName());
+		messageLog->logJoinSpectator(playerInfo->getName());
 	} else {
-		Player *newPlayer = addPlayer(event->getPlayerId(), event->getPlayerName());
+		Player *newPlayer = addPlayer(playerInfo->getPlayerId(), playerInfo->getName());
 		messageLog->logJoin(newPlayer);
+		playerListWidget->addPlayer(playerInfo);
 	}
 }
 
 void TabGame::eventLeave(Event_Leave *event)
 {
-	Player *player = players.value(event->getPlayerId(), 0);
+	int playerId = event->getPlayerId();
+	Player *player = players.value(playerId, 0);
 	if (!player)
 		return;
 	
 	messageLog->logLeave(player);
+	playerListWidget->removePlayer(playerId);
 }
 
 void TabGame::eventGameClosed(Event_GameClosed * /*event*/)
@@ -261,29 +294,43 @@ void TabGame::eventGameClosed(Event_GameClosed * /*event*/)
 	messageLog->logGameClosed();
 }
 
-void TabGame::eventSetActivePlayer(Event_SetActivePlayer *event)
+Player *TabGame::setActivePlayer(int id)
 {
-	Player *player = players.value(event->getActivePlayerId(), 0);
+	Player *player = players.value(id, 0);
 	if (!player)
-		return;
+		return 0;
-	playerListWidget->setActivePlayer(event->getActivePlayerId());
+	playerListWidget->setActivePlayer(id);
 	QMapIterator<int, Player *> i(players);
 	while (i.hasNext()) {
 		i.next();
 		i.value()->setActive(i.value() == player);
 	}
-	messageLog->logSetActivePlayer(player);
 	currentPhase = -1;
+	return player;
+}
+
+void TabGame::eventSetActivePlayer(Event_SetActivePlayer *event)
+{
+	Player *player = setActivePlayer(event->getActivePlayerId());
+	if (!player)
+		return;
+	messageLog->logSetActivePlayer(player);
+}
+
+void TabGame::setActivePhase(int phase)
+{
+	if (currentPhase != phase) {
+		currentPhase = phase;
+		phasesToolbar->setActivePhase(phase);
+	}
 }
 
 void TabGame::eventSetActivePhase(Event_SetActivePhase *event)
 {
-	const int phase = event->getPhase();
+	int phase = event->getPhase();
-	if (currentPhase != phase) {
+	if (currentPhase != phase)
-		currentPhase = phase;
-		phasesToolbar->setActivePhase(phase);
 		messageLog->logSetActivePhase(phase);
-	}
+	setActivePhase(phase);
 }
 
 void TabGame::loadLocalDeck()

cockatrice/src/tab_game.h

@@ -61,22 +61,22 @@ private:
 	QAction *playersSeparator;
 	QMenu *playersMenu;
 	QAction *aCloseMostRecentZoneView,
-		*aNextPhase, *aNextTurn, *aRemoveLocalArrows;
+		*aLeaveGame, *aNextPhase, *aNextTurn, *aRemoveLocalArrows;
 
 	Player *addPlayer(int playerId, const QString &playerName);
 
+	void startGame();
 	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);
+	Player *setActivePlayer(int id);
 	void eventSetActivePlayer(Event_SetActivePlayer *event);
+	void setActivePhase(int phase);
 	void eventSetActivePhase(Event_SetActivePhase *event);
 signals:
-	// -- XXX --
+	void gameClosing(TabGame *tab);
-	void playerAdded(Player *player);
-	void playerRemoved(Player *player);
-	// -- XXX --
 private slots:
 	void loadLocalDeck();
 	void loadRemoteDeck();
@@ -84,14 +84,17 @@ private slots:
 	void deckSelectFinished(ProtocolResponse *r);
 	void newCardAdded(CardItem *card);
 	
+	void actLeaveGame();
 	void actRemoveLocalArrows();
 	void actSay();
 	void actNextPhase();
 	void actNextTurn();
 public:
 	TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectator);
+	~TabGame();
 	void retranslateUi();
 	const QMap<int, Player *> &getPlayers() const { return players; }
+	int getGameId() const { return gameId; }
 
 	void processGameEvent(GameEvent *event);
 public slots:

cockatrice/src/tab_supervisor.cpp

@@ -103,19 +103,37 @@ void TabSupervisor::updatePingTime(int value, int max)
 void TabSupervisor::gameJoined(Event_GameJoined *event)
 {
 	TabGame *tab = new TabGame(client, event->getGameId(), event->getPlayerId(), event->getSpectator());
+	connect(tab, SIGNAL(gameClosing(TabGame *)), this, SLOT(gameLeft(TabGame *)));
 	addTab(tab, tr("Game %1").arg(event->getGameId()));
 	gameTabs.insert(event->getGameId(), tab);
 	setCurrentWidget(tab);
 }
 
+void TabSupervisor::gameLeft(TabGame *tab)
+{
+	emit setMenu(0);
+
+	gameTabs.remove(tab->getGameId());
+	removeTab(indexOf(tab));
+}
+
 void TabSupervisor::addChatChannelTab(const QString &channelName)
 {
 	TabChatChannel *tab = new TabChatChannel(client, channelName);
+	connect(tab, SIGNAL(channelClosing(TabChatChannel *)), this, SLOT(chatChannelLeft(TabChatChannel *)));
 	addTab(tab, channelName);
 	chatChannelTabs.insert(channelName, tab);
 	setCurrentWidget(tab);
 }
 
+void TabSupervisor::chatChannelLeft(TabChatChannel *tab)
+{
+	emit setMenu(0);
+
+	chatChannelTabs.remove(tab->getChannelName());
+	removeTab(indexOf(tab));
+}
+
 void TabSupervisor::processChatEvent(ChatEvent *event)
 {
 	TabChatChannel *tab = chatChannelTabs.value(event->getChannel(), 0);

cockatrice/src/tab_supervisor.h

@@ -33,9 +33,11 @@ private slots:
 	void updateMenu(int index);
 	void updatePingTime(int value, int max);
 	void gameJoined(Event_GameJoined *event);
+	void gameLeft(TabGame *tab);
 	void addChatChannelTab(const QString &channelName);
+	void chatChannelLeft(TabChatChannel *tab);
 	void processChatEvent(ChatEvent *event);
 	void processGameEvent(GameEvent *event);
 };
 
-#endif
+#endif

cockatrice/src/window_main.cpp

@@ -25,6 +25,8 @@
 #include "window_deckeditor.h"
 #include "tab_supervisor.h"
 
+const QString MainWindow::appName = "Cockatrice";
+
 void MainWindow::updateTabMenu(QMenu *menu)
 {
 	if (tabMenu)
@@ -36,60 +38,24 @@ void MainWindow::updateTabMenu(QMenu *menu)
 
 void MainWindow::statusChanged(ClientStatus _status)
 {
+	setClientStatusTitle();
 	switch (_status) {
 		case StatusConnecting:
-			emit logConnecting(client->peerName());
 			break;
 		case StatusDisconnected:
 			tabSupervisor->stop();
-//			if (game) {
-//				zoneLayout->clear();
-//				delete game;
-//				game = 0;
-//			}
 			aConnect->setEnabled(true);
 			aDisconnect->setEnabled(false);
-//			aRestartGame->setEnabled(false);
-//			aLeaveGame->setEnabled(false);
-//			phasesToolbar->setActivePhase(-1);
-//			phasesToolbar->hide();
-			emit logDisconnected();
 			break;
 		case StatusLoggingIn:
-			emit logConnected();
 			aConnect->setEnabled(false);
 			aDisconnect->setEnabled(true);
 			break;
 		case StatusLoggedIn: {
 			tabSupervisor->start(client);
-	
-/*			if (game) {
-				zoneLayout->clear();
-				delete game;
-				game = 0;
-			}
-			aRestartGame->setEnabled(false);
-			aLeaveGame->setEnabled(false);
-			phasesToolbar->setActivePhase(-1);
-			phasesToolbar->hide();
-			
-			view->hide();
-			gameSelector->enableGameList();
-			chatWidget->enableChat();
-*/			break;
-		}
-//		case StatusPlaying: {
-/*			chatWidget->disableChat();
-			
-			aRestartGame->setEnabled(true);
-			aLeaveGame->setEnabled(true);
-		
-			
-			phasesToolbar->show();
-			view->show();
 			break;
 		}
-*/		default:
+		default:
 			break;
 	}
 }
@@ -107,18 +73,7 @@ void MainWindow::actDisconnect()
 {
 	client->disconnectFromServer();
 }
-/*
-void MainWindow::actRestartGame()
-{
-	zoneLayout->clear();
-	game->restartGameDialog();
-}
 
-void MainWindow::actLeaveGame()
-{
-	client->leaveGame();
-}
-*/
 void MainWindow::actDeckEditor()
 {
 	WndDeckEditor *deckEditor = new WndDeckEditor(this);
@@ -149,15 +104,40 @@ void MainWindow::serverTimeout()
 	QMessageBox::critical(this, tr("Error"), tr("Server timeout"));
 }
 
+void MainWindow::serverError(ResponseCode r)
+{
+	switch (r) {
+		case RespWrongPassword: QMessageBox::critical(this, tr("Error"), tr("Invalid login data.")); break;
+		default: ;
+	}
+}
+
+void MainWindow::socketError(const QString &errorStr)
+{
+	QMessageBox::critical(this, tr("Error"), tr("Socket error: %1").arg(errorStr));
+}
+
+void MainWindow::protocolVersionMismatch(int localVersion, int remoteVersion)
+{
+	QMessageBox::critical(this, tr("Error"), tr("Protocol version mismatch. Local version: %1, remote version: %2.").arg(localVersion).arg(remoteVersion));
+}
+
+void MainWindow::setClientStatusTitle()
+{
+	switch (client->getStatus()) {
+		case StatusConnecting: setWindowTitle(appName + " - " + tr("Connecting to %1...").arg(client->peerName())); break;
+		case StatusDisconnected: setWindowTitle(appName + " - " + tr("Disconnected")); break;
+		case StatusLoggedIn: setWindowTitle(appName + " - " + tr("Logged in at %1").arg(client->peerName())); break;
+		default: setWindowTitle(appName);
+	}
+}
+
 void MainWindow::retranslateUi()
 {
-	setWindowTitle(tr("Cockatrice"));
+	setClientStatusTitle();
 	
 	aConnect->setText(tr("&Connect..."));
 	aDisconnect->setText(tr("&Disconnect"));
-//	aRestartGame->setText(tr("&Restart game..."));
-//	aRestartGame->setShortcut(tr("F2"));
-//	aLeaveGame->setText(tr("&Leave game"));
 	aDeckEditor->setText(tr("&Deck editor"));
 	aFullScreen->setText(tr("&Full screen"));
 	aFullScreen->setShortcut(tr("Ctrl+F"));
@@ -174,13 +154,7 @@ void MainWindow::createActions()
 	aDisconnect = new QAction(this);
 	aDisconnect->setEnabled(false);
 	connect(aDisconnect, SIGNAL(triggered()), this, SLOT(actDisconnect()));
-/*	aRestartGame = new QAction(this);
+	aDeckEditor = new QAction(this);
-	aRestartGame->setEnabled(false);
-	connect(aRestartGame, SIGNAL(triggered()), this, SLOT(actRestartGame()));
-	aLeaveGame = new QAction(this);
-	aLeaveGame->setEnabled(false);
-	connect(aLeaveGame, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
-*/	aDeckEditor = new QAction(this);
 	connect(aDeckEditor, SIGNAL(triggered()), this, SLOT(actDeckEditor()));
 	aFullScreen = new QAction(this);
 	aFullScreen->setCheckable(true);
@@ -212,22 +186,16 @@ MainWindow::MainWindow(QWidget *parent)
 	QPixmapCache::setCacheLimit(200000);
 
 	client = new Client(this);
+	connect(client, SIGNAL(serverError(ResponseCode)), this, SLOT(serverError(ResponseCode)));
+	connect(client, SIGNAL(socketError(const QString &)), this, SLOT(socketError(const QString &)));
+	connect(client, SIGNAL(serverTimeout()), this, SLOT(serverTimeout()));
+	connect(client, SIGNAL(statusChanged(ClientStatus)), this, SLOT(statusChanged(ClientStatus)));
+	connect(client, SIGNAL(protocolVersionMismatch(int, int)), this, SLOT(protocolVersionMismatch(int, int)));
+
 	tabSupervisor = new TabSupervisor;
 	connect(tabSupervisor, SIGNAL(setMenu(QMenu *)), this, SLOT(updateTabMenu(QMenu *)));
 	
 	setCentralWidget(tabSupervisor);
-/*
-	
-	connect(this, SIGNAL(logConnecting(QString)), messageLog, SLOT(logConnecting(QString)));
-	connect(this, SIGNAL(logConnected()), messageLog, SLOT(logConnected()));
-	connect(this, SIGNAL(logDisconnected()), messageLog, SLOT(logDisconnected()));
-	connect(client, SIGNAL(logSocketError(const QString &)), messageLog, SLOT(logSocketError(const QString &)));
-	connect(client, SIGNAL(serverError(ResponseCode)), messageLog, SLOT(logServerError(ResponseCode)));
-	connect(client, SIGNAL(protocolVersionMismatch(int, int)), messageLog, SLOT(logProtocolVersionMismatch(int, int)));
-	connect(client, SIGNAL(protocolError()), messageLog, SLOT(logProtocolError()));
-*/
-	connect(client, SIGNAL(serverTimeout()), this, SLOT(serverTimeout()));
-	connect(client, SIGNAL(statusChanged(ClientStatus)), this, SLOT(statusChanged(ClientStatus)));
 
 	createActions();
 	createMenus();

cockatrice/src/window_main.h

@@ -22,6 +22,7 @@
 
 #include <QMainWindow>
 #include "client.h"
+#include "protocol_datastructures.h"
 
 class TabSupervisor;
 
@@ -31,6 +32,9 @@ private slots:
 	void updateTabMenu(QMenu *menu);
 	void statusChanged(ClientStatus _status);
 	void serverTimeout();
+	void serverError(ResponseCode r);
+	void socketError(const QString &errorStr);
+	void protocolVersionMismatch(int localVersion, int remoteVersion);
 
 	void actConnect();
 	void actDisconnect();
@@ -38,11 +42,9 @@ private slots:
 	void actFullScreen(bool checked);
 	void actSettings();
 	void actExit();
-signals:
-	void logConnecting(QString hostname);
-	void logConnected();
-	void logDisconnected();
 private:
+	static const QString appName;
+	void setClientStatusTitle();
 	void retranslateUi();
 	void createActions();
 	void createMenus();

cockatrice/src/zoneviewwidget.cpp

@@ -80,8 +80,8 @@ void ZoneViewWidget::resizeToZoneContents()
 	int cardCount = zone->getCards().size();
 	const QRectF &playersRect = static_cast<GameScene *>(scene())->getPlayersRect();
 	int h = 0;
-	if (cardCount * CARD_HEIGHT / 5 < playersRect.height() * 1.5)
+	if (cardCount * CARD_HEIGHT / 3 < playersRect.height() * 1.5)
-		h = cardCount * CARD_HEIGHT / 5;
+		h = cardCount * CARD_HEIGHT / 3;
 	else
 		h = playersRect.height() * 1.5;
 	qDebug(QString("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx resizing to %1").arg(h).toLatin1());

common/protocol.cpp

@@ -37,6 +37,7 @@ void ProtocolItem::initializeHash()
 	
 	registerSerializableItem("generic_eventlist_games", Event_ListGames::newItem);
 	registerSerializableItem("generic_eventlist_chat_channels", Event_ListChatChannels::newItem);
+	registerSerializableItem("game_eventjoin", Event_Join::newItem);
 	registerSerializableItem("game_eventgame_state_changed", Event_GameStateChanged::newItem);
 	registerSerializableItem("game_eventcreate_arrows", Event_CreateArrows::newItem);
 	registerSerializableItem("game_eventcreate_counters", Event_CreateCounters::newItem);
@@ -214,9 +215,20 @@ Event_ListGames::Event_ListGames(const QList<ServerInfo_Game *> &_gameList)
 		itemList.append(_gameList[i]);
 }
 
-Event_GameStateChanged::Event_GameStateChanged(int _gameId, const QList<ServerInfo_Player *> &_playerList)
+Event_Join::Event_Join(int _gameId, ServerInfo_Player *player)
+	: GameEvent("join", _gameId, -1)
+{
+	if (!player)
+		player = new ServerInfo_Player;
+	insertItem(player);
+}
+
+Event_GameStateChanged::Event_GameStateChanged(int _gameId, bool _gameStarted, int _activePlayer, int _activePhase, const QList<ServerInfo_Player *> &_playerList)
 	: GameEvent("game_state_changed", _gameId, -1)
 {
+	insertItem(new SerializableItem_Bool("game_started", _gameStarted));
+	insertItem(new SerializableItem_Int("active_player", _activePlayer));
+	insertItem(new SerializableItem_Int("active_phase", _activePhase));
 	for (int i = 0; i < _playerList.size(); ++i)
 		itemList.append(_playerList[i]);
 }

common/protocol.h

@@ -26,6 +26,7 @@ enum ItemId {
 	ItemId_Event_CreateArrows = ItemId_Other + 204,
 	ItemId_Event_CreateCounters = ItemId_Other + 205,
 	ItemId_Event_DrawCards = ItemId_Other + 206,
+	ItemId_Event_Join = ItemId_Other + 207,
 	ItemId_Response_DeckList = ItemId_Other + 300,
 	ItemId_Response_DeckDownload = ItemId_Other + 301,
 	ItemId_Response_DeckUpload = ItemId_Other + 302,
@@ -236,13 +237,25 @@ public:
 	QList<ServerInfo_Game *> getGameList() const { return typecastItemList<ServerInfo_Game *>(); }
 };
 
+class Event_Join : public GameEvent {
+	Q_OBJECT
+public:
+	Event_Join(int _gameId = -1, ServerInfo_Player * player = 0);
+	static SerializableItem *newItem() { return new Event_Join; }
+	int getItemId() const { return ItemId_Event_Join; }
+	ServerInfo_Player *getPlayer() const { return static_cast<ServerInfo_Player *>(itemMap.value("player")); }
+};
+
 class Event_GameStateChanged : public GameEvent {
 	Q_OBJECT
 public:
-	Event_GameStateChanged(int _gameId = -1, const QList<ServerInfo_Player *> &_playerList = QList<ServerInfo_Player *>());
+	Event_GameStateChanged(int _gameId = -1, bool _gameStarted = false, int _activePlayer = -1, int _activePhase = -1, const QList<ServerInfo_Player *> &_playerList = QList<ServerInfo_Player *>());
 	static SerializableItem *newItem() { return new Event_GameStateChanged; }
 	int getItemId() const { return ItemId_Event_GameStateChanged; }
 	QList<ServerInfo_Player *> getPlayerList() const { return typecastItemList<ServerInfo_Player *>(); }
+	bool getGameStarted() const { return static_cast<SerializableItem_Bool *>(itemMap.value("game_started"))->getData(); }
+	int getActivePlayer() const { return static_cast<SerializableItem_Int *>(itemMap.value("active_player"))->getData(); }
+	int getActivePhase() const { return static_cast<SerializableItem_Int *>(itemMap.value("active_phase"))->getData(); }
 };
 
 class Event_CreateArrows : public GameEvent {

common/protocol_datastructures.cpp

@@ -1,4 +1,5 @@
 #include "protocol_datastructures.h"
+#include "decklist.h"
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
@@ -107,11 +108,16 @@ ServerInfo_Arrow::ServerInfo_Arrow(int _id, int _startPlayerId, const QString &_
 	insertItem(new SerializableItem_Color("color", _color));
 }
 
-ServerInfo_Player::ServerInfo_Player(int _playerId, const QString &_name, const QList<ServerInfo_Zone *> &_zoneList, const QList<ServerInfo_Counter *> &_counterList, const QList<ServerInfo_Arrow *> &_arrowList)
+ServerInfo_Player::ServerInfo_Player(int _playerId, const QString &_name, bool _spectator, DeckList *_deck, const QList<ServerInfo_Zone *> &_zoneList, const QList<ServerInfo_Counter *> &_counterList, const QList<ServerInfo_Arrow *> &_arrowList)
 	: SerializableItem_Map("player"), zoneList(_zoneList), counterList(_counterList), arrowList(_arrowList)
 {
 	insertItem(new SerializableItem_Int("player_id", _playerId));
 	insertItem(new SerializableItem_String("name", _name));
+	insertItem(new SerializableItem_Bool("spectator", _spectator));
+	if (!_deck)
+		insertItem(new DeckList);
+	else
+		insertItem(new DeckList(_deck));
 	
 	for (int i = 0; i < _zoneList.size(); ++i)
 		itemList.append(_zoneList[i]);
@@ -136,6 +142,11 @@ void ServerInfo_Player::extractData()
 	}
 }
 
+DeckList *ServerInfo_Player::getDeck() const
+{
+	return static_cast<DeckList *>(itemMap.value("cockatrice_deck"));
+}
+
 DeckList_TreeItem::DeckList_TreeItem(const QString &_itemType, const QString &_name, int _id)
 	: SerializableItem_Map(_itemType)
 {

common/protocol_datastructures.h

@@ -6,6 +6,8 @@
 #include <QDateTime>
 #include "serializable_item.h"
 
+class DeckList;
+
 enum ResponseCode { RespNothing, RespOk, RespInvalidCommand, RespInvalidData, RespNameNotFound, RespLoginNeeded, RespContextError, RespWrongPassword, RespSpectatorsNotAllowed };
 
 // PrivateZone: Contents of the zone are always visible to the owner,
@@ -110,10 +112,12 @@ private:
 protected:
 	void extractData();
 public:
-	ServerInfo_Player(int _playerId = -1, const QString &_name = QString(), const QList<ServerInfo_Zone *> &_zoneList = QList<ServerInfo_Zone *>(), const QList<ServerInfo_Counter *> &_counterList = QList<ServerInfo_Counter *>(), const QList<ServerInfo_Arrow *> &_arrowList = QList<ServerInfo_Arrow *>());
+	ServerInfo_Player(int _playerId = -1, const QString &_name = QString(), bool _spectator = false, DeckList *_deck = 0, const QList<ServerInfo_Zone *> &_zoneList = QList<ServerInfo_Zone *>(), const QList<ServerInfo_Counter *> &_counterList = QList<ServerInfo_Counter *>(), const QList<ServerInfo_Arrow *> &_arrowList = QList<ServerInfo_Arrow *>());
 	static SerializableItem *newItem() { return new ServerInfo_Player; }
 	int getPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_id"))->getData(); }
 	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
+	bool getSpectator() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectator"))->getData(); }
+	DeckList *getDeck() const;
 	const QList<ServerInfo_Zone *> &getZoneList() const { return zoneList; }
 	const QList<ServerInfo_Counter *> &getCounterList() const { return counterList; }
 	const QList<ServerInfo_Arrow *> &getArrowList() const { return arrowList; }

common/protocol_item_ids.h

@@ -33,28 +33,27 @@ ItemId_Command_SetActivePhase = 1031,
 ItemId_Command_DumpZone = 1032,
 ItemId_Command_StopDumpZone = 1033,
 ItemId_Event_Say = 1034,
-ItemId_Event_Join = 1035,
+ItemId_Event_Leave = 1035,
-ItemId_Event_Leave = 1036,
+ItemId_Event_DeckSelect = 1036,
-ItemId_Event_DeckSelect = 1037,
+ItemId_Event_GameClosed = 1037,
-ItemId_Event_GameClosed = 1038,
+ItemId_Event_ReadyStart = 1038,
-ItemId_Event_ReadyStart = 1039,
+ItemId_Event_GameStart = 1039,
-ItemId_Event_GameStart = 1040,
+ItemId_Event_Shuffle = 1040,
-ItemId_Event_Shuffle = 1041,
+ItemId_Event_RollDie = 1041,
-ItemId_Event_RollDie = 1042,
+ItemId_Event_MoveCard = 1042,
-ItemId_Event_MoveCard = 1043,
+ItemId_Event_CreateToken = 1043,
-ItemId_Event_CreateToken = 1044,
+ItemId_Event_DeleteArrow = 1044,
-ItemId_Event_DeleteArrow = 1045,
+ItemId_Event_SetCardAttr = 1045,
-ItemId_Event_SetCardAttr = 1046,
+ItemId_Event_SetCounter = 1046,
-ItemId_Event_SetCounter = 1047,
+ItemId_Event_DelCounter = 1047,
-ItemId_Event_DelCounter = 1048,
+ItemId_Event_SetActivePlayer = 1048,
-ItemId_Event_SetActivePlayer = 1049,
+ItemId_Event_SetActivePhase = 1049,
-ItemId_Event_SetActivePhase = 1050,
+ItemId_Event_DumpZone = 1050,
-ItemId_Event_DumpZone = 1051,
+ItemId_Event_StopDumpZone = 1051,
-ItemId_Event_StopDumpZone = 1052,
+ItemId_Event_ServerMessage = 1052,
-ItemId_Event_ServerMessage = 1053,
+ItemId_Event_GameJoined = 1053,
-ItemId_Event_GameJoined = 1054,
+ItemId_Event_ChatJoinChannel = 1054,
-ItemId_Event_ChatJoinChannel = 1055,
+ItemId_Event_ChatLeaveChannel = 1055,
-ItemId_Event_ChatLeaveChannel = 1056,
+ItemId_Event_ChatSay = 1056,
-ItemId_Event_ChatSay = 1057,
+ItemId_Other = 1057
-ItemId_Other = 1058
 };

common/protocol_items.cpp

@@ -195,12 +195,6 @@ Event_Say::Event_Say(int _gameId, int _playerId, const QString &_message)
 {
 	insertItem(new SerializableItem_String("message", _message));
 }
-Event_Join::Event_Join(int _gameId, int _playerId, const QString &_playerName, bool _spectator)
-	: GameEvent("join", _gameId, _playerId)
-{
-	insertItem(new SerializableItem_String("player_name", _playerName));
-	insertItem(new SerializableItem_Bool("spectator", _spectator));
-}
 Event_Leave::Event_Leave(int _gameId, int _playerId)
 	: GameEvent("leave", _gameId, _playerId)
 {
@@ -365,7 +359,6 @@ void ProtocolItem::initializeHashAuto()
 	itemNameHash.insert("cmddump_zone", Command_DumpZone::newItem);
 	itemNameHash.insert("cmdstop_dump_zone", Command_StopDumpZone::newItem);
 	itemNameHash.insert("game_eventsay", Event_Say::newItem);
-	itemNameHash.insert("game_eventjoin", Event_Join::newItem);
 	itemNameHash.insert("game_eventleave", Event_Leave::newItem);
 	itemNameHash.insert("game_eventdeck_select", Event_DeckSelect::newItem);
 	itemNameHash.insert("game_eventgame_closed", Event_GameClosed::newItem);

common/protocol_items.dat

@@ -32,7 +32,6 @@
 2:dump_zone:i,player_id:s,zone_name:i,number_cards
 2:stop_dump_zone:i,player_id:s,zone_name
 3:say:s,message
-3:join:s,player_name:b,spectator
 3:leave
 3:deck_select:i,deck_id
 3:game_closed

common/protocol_items.h

@@ -299,15 +299,6 @@ public:
 	static SerializableItem *newItem() { return new Event_Say; }
 	int getItemId() const { return ItemId_Event_Say; }
 };
-class Event_Join : public GameEvent {
-	Q_OBJECT
-public:
-	Event_Join(int _gameId = -1, int _playerId = -1, const QString &_playerName = QString(), bool _spectator = false);
-	QString getPlayerName() const { return static_cast<SerializableItem_String *>(itemMap.value("player_name"))->getData(); };
-	bool getSpectator() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectator"))->getData(); };
-	static SerializableItem *newItem() { return new Event_Join; }
-	int getItemId() const { return ItemId_Event_Join; }
-};
 class Event_Leave : public GameEvent {
 	Q_OBJECT
 public:

common/serializable_item.cpp

@@ -56,16 +56,12 @@ void SerializableItem_Map::readElement(QXmlStreamReader *xml)
 	else if (xml->isStartElement()) {
 		QString childName = xml->name().toString();
 		QString childSubType = xml->attributes().value("type").toString();
-		qDebug() << "Map: started new item, name=" << childName << "subtype=" << childSubType;
 		currentItem = itemMap.value(childName);
 		if (!currentItem) {
-			qDebug() << "Item not found in map";
 			currentItem = getNewItem(childName + childSubType);
 			itemList.append(currentItem);
-			if (!currentItem) {
+			if (!currentItem)
-				qDebug() << "Item still not found";
 				currentItem = new SerializableItem_Invalid(childName);
-			}
 		}
 		if (currentItem->read(xml))
 			currentItem = 0;

common/server.cpp

@@ -22,7 +22,7 @@
 #include "server_counter.h"
 #include "server_chatchannel.h"
 #include "server_protocolhandler.h"
-
+#include <QDebug>
 Server::Server(QObject *parent)
 	: QObject(parent), nextGameId(0)
 {
@@ -54,6 +54,22 @@ void Server::removeClient(Server_ProtocolHandler *client)
 	qDebug(QString("Server::removeClient: %1 clients left").arg(clients.size()).toLatin1());
 }
 
+void Server::closeOldSession(const QString &playerName)
+{
+	qDebug() << "closing old";
+	Server_ProtocolHandler *session = 0;
+	for (int i = 0; i < clients.size(); ++i)
+		if (clients[i]->getPlayerName() == playerName) {
+			session = clients[i];
+			break;
+		}
+	if (session) {
+		qDebug() << "found";
+		removeClient(session);
+		delete session;
+	}
+}
+
 Server_Game *Server::getGame(int gameId) const
 {
 	return games.value(gameId);

common/server.h

@@ -28,6 +28,7 @@ public:
 	
 	void addClient(Server_ProtocolHandler *player);
 	void removeClient(Server_ProtocolHandler *player);
+	void closeOldSession(const QString &playerName);
 	virtual QString getLoginMessage() const = 0;
 	Server_Game *createGame(const QString &description, const QString &password, int maxPlayers, bool spectatorsAllowed, Server_ProtocolHandler *creator);
 private:

common/server_game.cpp

@@ -59,10 +59,12 @@ void Server_Game::startGameIfReady()
 	playerIterator.toFront();
 	while (playerIterator.hasNext())
 		playerIterator.next().value()->setupZones();
+
+	gameStarted = true;
 	playerIterator.toFront();
 	while (playerIterator.hasNext()) {
 		Server_Player *player = playerIterator.next().value();
-		player->sendProtocolItem(new Event_GameStateChanged(gameId, getGameState(player)));
+		player->sendProtocolItem(new Event_GameStateChanged(gameId, gameStarted, 0, 0, getGameState(player)));
 	}
 	
 /*	QSqlQuery query;
@@ -81,7 +83,6 @@ void Server_Game::startGameIfReady()
 		query.exec();
 	}
 */	
-	gameStarted = true;
 	sendGameEvent(new Event_GameStart);
 	setActivePlayer(0);
 }
@@ -115,7 +116,7 @@ Server_Player *Server_Game::addPlayer(Server_ProtocolHandler *handler, bool spec
 		playerId = -1;
 	
 	Server_Player *newPlayer = new Server_Player(this, playerId, handler->getPlayerName(), spectator, handler);
-	sendGameEvent(new Event_Join(-1, playerId, handler->getPlayerName(), spectator));
+	sendGameEvent(new Event_Join(-1, new ServerInfo_Player(playerId, handler->getPlayerName(), spectator)));
 	
 	if (spectator)
 		spectators << newPlayer;
@@ -214,7 +215,7 @@ QList<ServerInfo_Player *> Server_Game::getGameState(Server_Player *playerWhosAs
 			zoneList.append(new ServerInfo_Zone(zone->getName(), zone->getType(), zone->hasCoords(), zone->cards.size(), cardList));
 		}
 
-		result.append(new ServerInfo_Player(player->getPlayerId(), player->getPlayerName(), zoneList, counterList, arrowList));
+		result.append(new ServerInfo_Player(player->getPlayerId(), player->getPlayerName(), player->getSpectator(), player->getDeck(), zoneList, counterList, arrowList));
 	}
 	return result;
 }

common/server_protocolhandler.cpp

@@ -22,8 +22,12 @@ Server_ProtocolHandler::~Server_ProtocolHandler()
 	// The socket has to be removed from the server's list before it is removed from the game's list
 	// so it will not receive the game update event.
 	server->removeClient(this);
-//	if (game)
+
-//		game->removePlayer(this);
+	QMapIterator<int, QPair<Server_Game *, Server_Player *> > gameIterator(games);
+	while (gameIterator.hasNext()) {
+		Server_Player *p = gameIterator.next().value().second;
+		p->setProtocolHandler(0);
+	}
 
 	QMapIterator<QString, Server_ChatChannel *> chatChannelIterator(chatChannels);
 	while (chatChannelIterator.hasNext())
@@ -135,12 +139,29 @@ ResponseCode Server_ProtocolHandler::cmdPing(Command_Ping * /*cmd*/)
 
 ResponseCode Server_ProtocolHandler::cmdLogin(Command_Login *cmd)
 {
-	authState = server->checkUserPassword(cmd->getUsername(), cmd->getPassword());
+	QString userName = cmd->getUsername();
+	authState = server->checkUserPassword(userName, cmd->getPassword());
 	if (authState == PasswordWrong)
 		return RespWrongPassword;
-	playerName = cmd->getUsername();
+	if (authState == PasswordRight)
-	
+		server->closeOldSession(userName);
+
+	playerName = userName;
 	enqueueProtocolItem(new Event_ServerMessage(server->getLoginMessage()));
+
+	// This might not scale very well. Use an extra QMap if it becomes a problem.
+	const QList<Server_Game *> &serverGames = server->getGames();
+	for (int i = 0; i < serverGames.size(); ++i) {
+		const QList<Server_Player *> &gamePlayers = serverGames[i]->getPlayers();
+		for (int j = 0; j < gamePlayers.size(); ++j)
+			if (gamePlayers[j]->getPlayerName() == playerName) {
+				gamePlayers[j]->setProtocolHandler(this);
+				games.insert(serverGames[i]->getGameId(), QPair<Server_Game *, Server_Player *>(serverGames[i], gamePlayers[j]));
+				enqueueProtocolItem(new Event_GameJoined(serverGames[i]->getGameId(), gamePlayers[j]->getPlayerId(), gamePlayers[j]->getSpectator()));
+				enqueueProtocolItem(new Event_GameStateChanged(serverGames[i]->getGameId(), serverGames[i]->getGameStarted(), serverGames[i]->getActivePlayer(), serverGames[i]->getActivePhase(), serverGames[i]->getGameState(gamePlayers[j])));
+			}
+	}
+
 	return RespOk;
 }
 
@@ -222,7 +243,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateGame(Command_CreateGame *cmd)
 	games.insert(game->getGameId(), QPair<Server_Game *, Server_Player *>(game, creator));
 	
 	enqueueProtocolItem(new Event_GameJoined(game->getGameId(), creator->getPlayerId(), false));
-	enqueueProtocolItem(new Event_GameStateChanged(game->getGameId(), game->getGameState(creator)));
+	enqueueProtocolItem(new Event_GameStateChanged(game->getGameId(), game->getGameStarted(), game->getActivePlayer(), game->getActivePhase(), game->getGameState(creator)));
 	return RespOk;
 }
 
@@ -237,7 +258,7 @@ ResponseCode Server_ProtocolHandler::cmdJoinGame(Command_JoinGame *cmd)
 		Server_Player *player = g->addPlayer(this, cmd->getSpectator());
 		games.insert(cmd->getGameId(), QPair<Server_Game *, Server_Player *>(g, player));
 		enqueueProtocolItem(new Event_GameJoined(cmd->getGameId(), player->getPlayerId(), cmd->getSpectator()));
-		enqueueProtocolItem(new Event_GameStateChanged(cmd->getGameId(), g->getGameState(player)));
+		enqueueProtocolItem(new Event_GameStateChanged(cmd->getGameId(), g->getGameStarted(), g->getActivePlayer(), g->getActivePhase(), g->getGameState(player)));
 	}
 	return result;
 }
@@ -357,7 +378,10 @@ ResponseCode Server_ProtocolHandler::cmdMoveCard(Command_MoveCard *cmd, Server_G
 		privateCardId = -1;
 		privateCardName = QString();
 	}
-	player->sendProtocolItem(new Event_MoveCard(game->getGameId(), player->getPlayerId(), privateCardId, privateCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown));
+	int privatePosition = -1;
+	if (startzone->getType() == HiddenZone)
+		privatePosition = position;
+	player->sendProtocolItem(new Event_MoveCard(game->getGameId(), player->getPlayerId(), privateCardId, privateCardName, startzone->getName(), privatePosition, targetzone->getName(), x, y, facedown));
 
 	// Other players do not get to see the start and/or target position of the card if the respective
 	// part of the zone is being looked at. The information is not needed anyway because in hidden zones,

servatrice/src/serversocketinterface.cpp

@@ -21,6 +21,7 @@
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 #include <QtSql>
+#include <QDebug>
 #include "serversocketinterface.h"
 #include "servatrice.h"
 #include "protocol.h"
@@ -68,7 +69,9 @@ void ServerSocketInterface::processProtocolItem(ProtocolItem *item)
 
 void ServerSocketInterface::readClient()
 {
-	xmlReader->addData(socket->readAll());
+	QByteArray data = socket->readAll();
+	qDebug() << data;
+	xmlReader->addData(data);
 	
 	if (topLevelItem)
 		topLevelItem->read(xmlReader);