event handling

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 = 1035,
-ItemId_Event_Join = 1036,
-ItemId_Event_Leave = 1037,
-ItemId_Event_DeckSelect = 1038,
-ItemId_Event_GameClosed = 1039,
-ItemId_Event_ReadyStart = 1040,
-ItemId_Event_GameStart = 1041,
-ItemId_Event_Shuffle = 1042,
-ItemId_Event_RollDie = 1043,
-ItemId_Event_MoveCard = 1044,
-ItemId_Event_CreateToken = 1045,
-ItemId_Event_CreateArrow = 1046,
-ItemId_Event_DeleteArrow = 1047,
-ItemId_Event_SetCardAttr = 1048,
-ItemId_Event_AddCounter = 1049,
-ItemId_Event_SetCounter = 1050,
-ItemId_Event_DelCounter = 1051,
-ItemId_Event_SetActivePlayer = 1052,
-ItemId_Event_SetActivePhase = 1053,
-ItemId_Event_DumpZone = 1054,
-ItemId_Event_StopDumpZone = 1055,
-ItemId_Event_ServerMessage = 1056,
-ItemId_Event_GameJoined = 1057,
-ItemId_Event_ChatJoinChannel = 1058,
-ItemId_Event_ChatLeaveChannel = 1059,
-ItemId_Event_ChatSay = 1060,
-ItemId_Other = 1061
+ItemId_Event_Say = 1034,
+ItemId_Event_Join = 1035,
+ItemId_Event_Leave = 1036,
+ItemId_Event_DeckSelect = 1037,
+ItemId_Event_GameClosed = 1038,
+ItemId_Event_ReadyStart = 1039,
+ItemId_Event_GameStart = 1040,
+ItemId_Event_Shuffle = 1041,
+ItemId_Event_RollDie = 1042,
+ItemId_Event_MoveCard = 1043,
+ItemId_Event_CreateToken = 1044,
+ItemId_Event_DeleteArrow = 1045,
+ItemId_Event_SetCardAttr = 1046,
+ItemId_Event_SetCounter = 1047,
+ItemId_Event_DelCounter = 1048,
+ItemId_Event_SetActivePlayer = 1049,
+ItemId_Event_SetActivePhase = 1050,
+ItemId_Event_DumpZone = 1051,
+ItemId_Event_StopDumpZone = 1052,
+ItemId_Event_ServerMessage = 1053,
+ItemId_Event_GameJoined = 1054,
+ItemId_Event_ChatJoinChannel = 1055,
+ItemId_Event_ChatLeaveChannel = 1056,
+ItemId_Event_ChatSay = 1057,
+ItemId_Other = 1058
 };

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)
-	: GameCommand("add_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
+Command_CreateCounter::Command_CreateCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _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; }
-	int getItemId() const { return ItemId_Command_AddCounter; }
+	static ProtocolItem *newItem() { return new Command_CreateCounter; }
+	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()));
 	}
+	
+	player->sendProtocolItem(new Event_DrawCards(game->getGameId(), player->getPlayerId(), cardList.size(), cardList));
+	game->sendGameEvent(new Event_DrawCards(-1, player->getPlayerId(), cardList.size()), player);
 
-//	game->broadcastEvent(QString("draw|%1").arg(number), 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(
-		-1,
-		player->getPlayerId(),
+	game->sendGameEvent(new Event_CreateArrow(-1, player->getPlayerId(), new ServerInfo_Arrow(
 		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;