new protocol code

cockatrice/src/carddatabase.cpp

@@ -56,8 +56,8 @@ void SetList::sortByKey()
 	qSort(begin(), end(), CompareFunctor());
 }
 
-CardInfo::CardInfo(CardDatabase *_db, const QString &_name, const QString &_manacost, const QString &_cardtype, const QString &_powtough, const QString &_text, const QStringList &_colors, int _tableRow, const SetList &_sets, const QString &_picURL)
-	: db(_db), name(_name), sets(_sets), manacost(_manacost), cardtype(_cardtype), powtough(_powtough), text(_text), colors(_colors), picURL(_picURL), tableRow(_tableRow), pixmap(NULL)
+CardInfo::CardInfo(CardDatabase *_db, const QString &_name, const QString &_manacost, const QString &_cardtype, const QString &_powtough, const QString &_text, const QStringList &_colors, bool _cipt, int _tableRow, const SetList &_sets, const QString &_picURL)
+	: db(_db), name(_name), sets(_sets), manacost(_manacost), cardtype(_cardtype), powtough(_powtough), text(_text), colors(_colors), picURL(_picURL), cipt(_cipt), tableRow(_tableRow), pixmap(NULL)
 {
 	for (int i = 0; i < sets.size(); i++)
 		sets[i]->append(this);
@@ -220,6 +220,8 @@ QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardInfo *info)
 	xml.writeTextElement("tablerow", QString::number(info->getTableRow()));
 	xml.writeTextElement("text", info->getText());
 	xml.writeTextElement("picURL", info->getPicURL());
+	if (info->getCipt())
+		xml.writeTextElement("cipt", "1");
 	xml.writeEndElement(); // card
 
 	return xml;
@@ -383,6 +385,7 @@ void CardDatabase::loadCardsFromXml(QXmlStreamReader &xml)
 			QStringList colors;
 			SetList sets;
 			int tableRow = 0;
+			bool cipt = false;
 			while (!xml.atEnd()) {
 				if (xml.readNext() == QXmlStreamReader::EndElement)
 					break;
@@ -404,8 +407,10 @@ void CardDatabase::loadCardsFromXml(QXmlStreamReader &xml)
 					tableRow = xml.readElementText().toInt();
 				else if (xml.name() == "picURL")
 					picURL = xml.readElementText();
+				else if (xml.name() == "cipt")
+					cipt = (xml.readElementText() == "1");
 			}
-			cardHash.insert(name, new CardInfo(this, name, manacost, type, pt, text, colors, tableRow, sets, picURL));
+			cardHash.insert(name, new CardInfo(this, name, manacost, type, pt, text, colors, cipt, tableRow, sets, picURL));
 		}
 	}
 }

cockatrice/src/carddatabase.h

@@ -46,6 +46,7 @@ private:
 	QString text;
 	QStringList colors;
 	QString picURL;
+	bool cipt;
 	int tableRow;
 	QPixmap *pixmap;
 	QMap<int, QPixmap *> scaledPixmapCache;
@@ -57,6 +58,7 @@ public:
 		const QString &_powtough = QString(),
 		const QString &_text = QString(),
 		const QStringList &_colors = QStringList(),
+		bool cipt = false,
 		int _tableRow = 0,
 		const SetList &_sets = SetList(),
 		const QString &_picURL = QString());
@@ -67,6 +69,7 @@ public:
 	const QString &getCardType() const { return cardtype; }
 	const QString &getPowTough() const { return powtough; }
 	const QString &getText() const { return text; }
+	bool getCipt() const { return cipt; }
 	void setText(const QString &_text) { text = _text; }
 	const QStringList &getColors() const { return colors; }
 	const QString &getPicURL() const { return picURL; }

cockatrice/src/cardzone.cpp

@@ -142,12 +142,6 @@ CardItem *CardZone::takeCard(int position, int cardId, const QString &cardName,
 	return c;
 }
 
-void CardZone::setCardAttr(int cardId, const QString &aname, const QString &avalue)
-{
-	if (hasCardAttr)
-		player->sendGameCommand(new Command_SetCardAttr(-1, name, cardId, aname, avalue));
-}
-
 void CardZone::moveAllToZone()
 {
 	QList<QVariant> data = static_cast<QAction *>(sender())->data().toList();

cockatrice/src/cardzone.h

@@ -52,7 +52,6 @@ public:
 	CardItem *getCard(int cardId, const QString &cardName);
 	// takeCard() finds a card by position and removes it from the zone and from all of its views.
 	virtual CardItem *takeCard(int position, int cardId, const QString &cardName, bool canResize = true);
-	void setCardAttr(int cardId, const QString &aname, const QString &avalue);
 	ZoneViewZone *getView() const { return view; }
 	void setView(ZoneViewZone *_view) { view = _view; }
 	virtual void reorganizeCards() = 0;

cockatrice/src/client.cpp

@@ -90,14 +90,14 @@ void Client::processProtocolItem(ProtocolItem *item)
 {
 	ProtocolResponse *response = qobject_cast<ProtocolResponse *>(item);
 	if (response) {
-		Command *cmd = pendingCommands.value(response->getCmdId(), 0);
-		if (!cmd)
+		CommandContainer *cmdCont = pendingCommands.value(response->getCmdId(), 0);
+		if (!cmdCont)
 			return;
 		
-		pendingCommands.remove(cmd->getCmdId());
-		cmd->processResponse(response);
+		pendingCommands.remove(cmdCont->getCmdId());
+		cmdCont->processResponse(response);
 		delete response;
-		delete cmd;
+		delete cmdCont;
 		
 		return;
 	}
@@ -114,10 +114,10 @@ void Client::processProtocolItem(ProtocolItem *item)
 		return;
 	}
 
-	GameEvent *gameEvent = qobject_cast<GameEvent *>(item);
-	if (gameEvent) {
-		emit gameEventReceived(gameEvent);
-		delete gameEvent;
+	GameEventContainer *gameEventContainer = qobject_cast<GameEventContainer *>(item);
+	if (gameEventContainer) {
+		emit gameEventContainerReceived(gameEventContainer);
+		delete gameEventContainer;
 		return;
 	}
 
@@ -139,8 +139,13 @@ void Client::setStatus(const ClientStatus _status)
 
 void Client::sendCommand(Command *cmd)
 {
-	cmd->write(xmlWriter);
-	pendingCommands.insert(cmd->getCmdId(), cmd);
+	sendCommandContainer(new CommandContainer(QList<Command *>() << cmd));
+}
+
+void Client::sendCommandContainer(CommandContainer *cont)
+{
+	cont->write(xmlWriter);
+	pendingCommands.insert(cont->getCmdId(), cont);
 }
 
 void Client::connectToServer(const QString &hostname, unsigned int port, const QString &_userName, const QString &_password)
@@ -162,7 +167,7 @@ void Client::disconnectFromServer()
 	
 	timer->stop();
 
-	QList<Command *> pc = pendingCommands.values();
+	QList<CommandContainer *> pc = pendingCommands.values();
 	for (int i = 0; i < pc.size(); i++)
 		delete pc[i];
 	pendingCommands.clear();
@@ -174,7 +179,7 @@ void Client::disconnectFromServer()
 void Client::ping()
 {
 	int maxTime = 0;
-	QMapIterator<int, Command *> i(pendingCommands);
+	QMapIterator<int, CommandContainer *> i(pendingCommands);
 	while (i.hasNext()) {
 		int time = i.next().value()->tick();
 		if (time > maxTime)

cockatrice/src/client.h

@@ -9,14 +9,16 @@
 
 class QTimer;
 class Command;
+class CommandContainer;
 class QXmlStreamReader;
 class QXmlStreamWriter;
 
 class ProtocolItem;
 class ProtocolResponse;
 class TopLevelProtocolItem;
+class CommandContainer;
 class ChatEvent;
-class GameEvent;
+class GameEventContainer;
 class Event_ListGames;
 class Event_ServerMessage;
 class Event_ListChatChannels;
@@ -45,7 +47,7 @@ signals:
 	// Chat events
 	void chatEventReceived(ChatEvent *event);
 	// Game events
-	void gameEventReceived(GameEvent *event);
+	void gameEventContainerReceived(GameEventContainer *event);
 	// Generic events
 	void listGamesEventReceived(Event_ListGames *event);
 	void serverMessageEventReceived(Event_ServerMessage *event);
@@ -63,7 +65,7 @@ private:
 	static const int maxTimeout = 10;
 	
 	QTimer *timer;
-	QMap<int, Command *> pendingCommands;
+	QMap<int, CommandContainer *> pendingCommands;
 	QTcpSocket *socket;
 	QXmlStreamReader *xmlReader;
 	QXmlStreamWriter *xmlWriter;
@@ -80,6 +82,7 @@ public:
 	void connectToServer(const QString &hostname, unsigned int port, const QString &_userName, const QString &_password);
 	void disconnectFromServer();
 	void sendCommand(Command *cmd);
+	void sendCommandContainer(CommandContainer *cont);
 };
 
 #endif

cockatrice/src/player.cpp

@@ -908,6 +908,11 @@ void Player::sendGameCommand(GameCommand *command)
 	static_cast<TabGame *>(parent())->sendGameCommand(command);
 }
 
+void Player::sendCommandContainer(CommandContainer *cont)
+{
+	static_cast<TabGame *>(parent())->sendCommandContainer(cont);
+}
+
 void Player::cardMenuAction()
 {
 	// Determine the appropriate handler function.

cockatrice/src/player.h

@@ -20,6 +20,7 @@ class HandZone;
 class ServerInfo_Player;
 class ServerInfo_Arrow;
 class ServerInfo_Counter;
+class CommandContainer;
 class GameCommand;
 class GameEvent;
 class Event_DeckSelect;
@@ -190,6 +191,7 @@ public:
 	void processPlayerInfo(ServerInfo_Player *info);
 	void processGameEvent(GameEvent *event);
 	void sendGameCommand(GameCommand *command);
+	void sendCommandContainer(CommandContainer *cont);
 };
 
 #endif

cockatrice/src/tab_game.cpp

@@ -226,8 +226,12 @@ Player *TabGame::addPlayer(int playerId, const QString &playerName)
 	return newPlayer;
 }
 
-void TabGame::processGameEvent(GameEvent *event)
+void TabGame::processGameEventContainer(GameEventContainer *cont)
 {
+	const QList<GameEvent *> &eventList = cont->getEventList();
+	for (int i = 0; i < eventList.size(); ++i) {
+		GameEvent *event = eventList[i];
+		
 		switch (event->getItemId()) {
 			case ItemId_Event_GameStateChanged: eventGameStateChanged(qobject_cast<Event_GameStateChanged *>(event)); break;
 			case ItemId_Event_Join: eventJoin(qobject_cast<Event_Join *>(event)); break;
@@ -247,6 +251,7 @@ void TabGame::processGameEvent(GameEvent *event)
 				emit userEvent();
 			}
 		}
+	}
 }
 
 void TabGame::sendGameCommand(GameCommand *command)
@@ -255,6 +260,17 @@ void TabGame::sendGameCommand(GameCommand *command)
 	client->sendCommand(command);
 }
 
+void TabGame::sendCommandContainer(CommandContainer *cont)
+{
+	const QList<Command *> &cmdList = cont->getCommandList();
+	for (int i = 0; i < cmdList.size(); ++i) {
+		GameCommand *cmd = qobject_cast<GameCommand *>(cmdList[i]);
+		if (cmd)
+			cmd->setGameId(gameId);
+	}
+	client->sendCommandContainer(cont);
+}
+
 void TabGame::startGame()
 {
 	currentPhase = -1;

cockatrice/src/tab_game.h

@@ -20,8 +20,9 @@ class ZoneViewWidget;
 class PhasesToolbar;
 class PlayerListWidget;
 class ProtocolResponse;
-class GameEvent;
+class GameEventContainer;
 class GameCommand;
+class CommandContainer;
 class Event_GameStateChanged;
 class Event_Join;
 class Event_Leave;
@@ -103,9 +104,10 @@ public:
 	int getGameId() const { return gameId; }
 	QString getTabText() const { return tr("Game %1: %2").arg(gameId).arg(gameDescription); }
 
-	void processGameEvent(GameEvent *event);
+	void processGameEventContainer(GameEventContainer *cont);
 public slots:
 	void sendGameCommand(GameCommand *command);
+	void sendCommandContainer(CommandContainer *cont);
 };
 
 #endif

cockatrice/src/tab_supervisor.cpp

@@ -52,7 +52,7 @@ void TabSupervisor::start(Client *_client)
 {
 	client = _client;
 	connect(client, SIGNAL(chatEventReceived(ChatEvent *)), this, SLOT(processChatEvent(ChatEvent *)));
-	connect(client, SIGNAL(gameEventReceived(GameEvent *)), this, SLOT(processGameEvent(GameEvent *)));
+	connect(client, SIGNAL(gameEventContainerReceived(GameEventContainer *)), this, SLOT(processGameEventContainer(GameEventContainer *)));
 	connect(client, SIGNAL(gameJoinedEventReceived(Event_GameJoined *)), this, SLOT(gameJoined(Event_GameJoined *)));
 	connect(client, SIGNAL(maxPingTime(int, int)), this, SLOT(updatePingTime(int, int)));
 
@@ -152,12 +152,12 @@ void TabSupervisor::processChatEvent(ChatEvent *event)
 		tab->processChatEvent(event);
 }
 
-void TabSupervisor::processGameEvent(GameEvent *event)
+void TabSupervisor::processGameEventContainer(GameEventContainer *cont)
 {
-	TabGame *tab = gameTabs.value(event->getGameId());
+	TabGame *tab = gameTabs.value(cont->getGameId());
 	if (tab) {
-		qDebug() << "gameEvent gameId =" << event->getGameId();
-		tab->processGameEvent(event);
+		qDebug() << "gameEvent gameId =" << cont->getGameId();
+		tab->processGameEventContainer(cont);
 	} else
 		qDebug() << "gameEvent: invalid gameId";
 }

cockatrice/src/tab_supervisor.h

@@ -12,7 +12,7 @@ class TabChatChannel;
 class TabGame;
 class TabDeckStorage;
 class ChatEvent;
-class GameEvent;
+class GameEventContainer;
 class Event_GameJoined;
 
 class TabSupervisor : public QTabWidget {
@@ -42,7 +42,7 @@ private slots:
 	void chatChannelLeft(TabChatChannel *tab);
 	void tabUserEvent();
 	void processChatEvent(ChatEvent *event);
-	void processGameEvent(GameEvent *event);
+	void processGameEventContainer(GameEventContainer *cont);
 };
 
 #endif

cockatrice/src/tablezone.cpp

@@ -85,11 +85,13 @@ void TableZone::toggleTapped()
 			tapAll = true;
 			break;
 		}
+	QList<Command *> cmdList;
 	for (int i = 0; i < selectedItems.size(); i++) {
 		CardItem *temp = qgraphicsitem_cast<CardItem *>(selectedItems[i]);
 		if (temp->getTapped() != tapAll)
-			setCardAttr(temp->getId(), "tapped", tapAll ? "1" : "0");
+			cmdList.append(new Command_SetCardAttr(-1, name, temp->getId(), "tapped", tapAll ? "1" : "0"));
 	}
+	player->sendCommandContainer(new CommandContainer(cmdList));
 }
 
 CardItem *TableZone::takeCard(int position, int cardId, const QString &cardName, bool canResize)

common/protocol.cpp

@@ -26,6 +26,9 @@ void ProtocolItem::initializeHash()
 	registerSerializableItem("file", DeckList_File::newItem);
 	registerSerializableItem("directory", DeckList_Directory::newItem);
 	
+	registerSerializableItem("containercmd", CommandContainer::newItem);
+	registerSerializableItem("containergame_event", GameEventContainer::newItem);
+	
 	registerSerializableItem("cmddeck_upload", Command_DeckUpload::newItem);
 	registerSerializableItem("cmddeck_select", Command_DeckSelect::newItem);
 	
@@ -83,20 +86,51 @@ void TopLevelProtocolItem::writeElement(QXmlStreamWriter * /*xml*/)
 {
 }
 
-int Command::lastCmdId = 0;
+int CommandContainer::lastCmdId = 0;
+
+Command::Command(const QString &_itemName)
+	: ProtocolItem("cmd", _itemName)
+{
+}
+
+void Command::processResponse(ProtocolResponse *response)
+{
+	emit finished(response);
+	emit finished(response->getResponseCode());
+}
 
-Command::Command(const QString &_itemName, int _cmdId)
-	: ProtocolItem("cmd", _itemName), ticks(0)
+CommandContainer::CommandContainer(const QList<Command *> &_commandList, int _cmdId)
+	: ProtocolItem("container", "cmd"), ticks(0), resp(0), gameEventQueue(0)
 {
 	if (_cmdId == -1)
 		_cmdId = lastCmdId++;
 	insertItem(new SerializableItem_Int("cmd_id", _cmdId));
+	
+	for (int i = 0; i < _commandList.size(); ++i)
+		itemList.append(_commandList[i]);
 }
 
-void Command::processResponse(ProtocolResponse *response)
+void CommandContainer::processResponse(ProtocolResponse *response)
 {
 	emit finished(response);
 	emit finished(response->getResponseCode());
+	
+	const QList<Command *> &cmdList = getCommandList();
+	for (int i = 0; i < cmdList.size(); ++i)
+		cmdList[i]->processResponse(response);
+}
+
+void CommandContainer::setResponse(ProtocolResponse *_resp)
+{
+	delete resp;
+	resp = _resp;
+}
+
+void CommandContainer::enqueueGameEvent(GameEvent *event, int gameId)
+{
+	if (!gameEventQueue)
+		gameEventQueue = new GameEventContainer(QList<GameEvent *>(), gameId);
+	gameEventQueue->appendItem(event);
 }
 
 Command_DeckUpload::Command_DeckUpload(DeckList *_deck, const QString &_path)
@@ -187,10 +221,9 @@ Response_DumpZone::Response_DumpZone(int _cmdId, ResponseCode _responseCode, Ser
 	insertItem(_zone);
 }
 
-GameEvent::GameEvent(const QString &_eventName, int _gameId, int _playerId)
+GameEvent::GameEvent(const QString &_eventName, int _playerId)
 	: ProtocolItem("game_event", _eventName)
 {
-	insertItem(new SerializableItem_Int("game_id", _gameId));
 	insertItem(new SerializableItem_Int("player_id", _playerId));
 }
 
@@ -221,16 +254,30 @@ Event_ListGames::Event_ListGames(const QList<ServerInfo_Game *> &_gameList)
 		itemList.append(_gameList[i]);
 }
 
-Event_Join::Event_Join(int _gameId, ServerInfo_Player *player)
-	: GameEvent("join", _gameId, -1)
+Event_Join::Event_Join(ServerInfo_Player *player)
+	: GameEvent("join", -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)
+GameEventContainer::GameEventContainer(const QList<GameEvent *> &_eventList, int _gameId)
+	: ProtocolItem("container", "game_event")
+{
+	insertItem(new SerializableItem_Int("game_id", _gameId));
+	
+	for (int i = 0; i < _eventList.size(); ++i)
+		itemList.append(_eventList[i]);
+}
+
+GameEventContainer *GameEventContainer::makeNew(GameEvent *event, int _gameId)
+{
+	return new GameEventContainer(QList<GameEvent *>() << event, _gameId);
+}
+
+Event_GameStateChanged::Event_GameStateChanged(bool _gameStarted, int _activePlayer, int _activePhase, const QList<ServerInfo_Player *> &_playerList)
+	: GameEvent("game_state_changed", -1)
 {
 	insertItem(new SerializableItem_Bool("game_started", _gameStarted));
 	insertItem(new SerializableItem_Int("active_player", _activePlayer));
@@ -239,29 +286,29 @@ Event_GameStateChanged::Event_GameStateChanged(int _gameId, bool _gameStarted, i
 		itemList.append(_playerList[i]);
 }
 
-Event_Ping::Event_Ping(int _gameId, const QList<ServerInfo_PlayerPing *> &_pingList)
-	: GameEvent("ping", _gameId, -1)
+Event_Ping::Event_Ping(const QList<ServerInfo_PlayerPing *> &_pingList)
+	: GameEvent("ping", -1)
 {
 	for (int i = 0; i < _pingList.size(); ++i)
 		itemList.append(_pingList[i]);
 }
 
-Event_CreateArrows::Event_CreateArrows(int _gameId, int _playerId, const QList<ServerInfo_Arrow *> &_arrowList)
-	: GameEvent("create_arrows", _gameId, _playerId)
+Event_CreateArrows::Event_CreateArrows(int _playerId, const QList<ServerInfo_Arrow *> &_arrowList)
+	: GameEvent("create_arrows", _playerId)
 {
 	for (int i = 0; i < _arrowList.size(); ++i)
 		itemList.append(_arrowList[i]);
 }
 
-Event_CreateCounters::Event_CreateCounters(int _gameId, int _playerId, const QList<ServerInfo_Counter *> &_counterList)
-	: GameEvent("create_counters", _gameId, _playerId)
+Event_CreateCounters::Event_CreateCounters(int _playerId, const QList<ServerInfo_Counter *> &_counterList)
+	: GameEvent("create_counters", _playerId)
 {
 	for (int i = 0; i < _counterList.size(); ++i)
 		itemList.append(_counterList[i]);
 }
 
-Event_DrawCards::Event_DrawCards(int _gameId, int _playerId, int _numberCards, const QList<ServerInfo_Card *> &_cardList)
-	: GameEvent("draw_cards", _gameId, _playerId)
+Event_DrawCards::Event_DrawCards(int _playerId, int _numberCards, const QList<ServerInfo_Card *> &_cardList)
+	: GameEvent("draw_cards", _playerId)
 {
 	insertItem(new SerializableItem_Int("number_cards", _numberCards));
 	for (int i = 0; i < _cardList.size(); ++i)

common/protocol.h

@@ -15,8 +15,12 @@ class QXmlStreamAttributes;
 
 class ProtocolResponse;
 class DeckList;
+class GameEvent;
+class GameEventContainer;
 
 enum ItemId {
+	ItemId_CommandContainer = ItemId_Other + 50,
+	ItemId_GameEventContainer = ItemId_Other + 51,
 	ItemId_Command_DeckUpload = ItemId_Other + 100,
 	ItemId_Command_DeckSelect = ItemId_Other + 101,
 	ItemId_Event_ListChatChannels = ItemId_Other + 200,
@@ -40,7 +44,7 @@ class ProtocolItem : public SerializableItem_Map {
 private:
 	static void initializeHashAuto();
 public:
-	static const int protocolVersion = 5;
+	static const int protocolVersion = 6;
 	static void initializeHash();
 	virtual int getItemId() const = 0;
 	ProtocolItem(const QString &_itemType, const QString &_itemSubType);
@@ -74,17 +78,43 @@ class Command : public ProtocolItem {
 signals:
 	void finished(ProtocolResponse *response);
 	void finished(ResponseCode response);
+private:
+	QVariant extraData;
+public:
+	Command(const QString &_itemName = QString());
+	void setExtraData(const QVariant &_extraData) { extraData = _extraData; }
+	QVariant getExtraData() const { return extraData; }
+	void processResponse(ProtocolResponse *response);
+};
+
+class CommandContainer : public ProtocolItem {
+	Q_OBJECT
+signals:
+	void finished(ProtocolResponse *response);
+	void finished(ResponseCode response);
 private:
 	int ticks;
 	static int lastCmdId;
-	QVariant extraData;
+	
+	// These are only for processing inside the server.
+	ProtocolResponse *resp;
+	QList<ProtocolItem *> itemQueue;
+	GameEventContainer *gameEventQueue;
 public:
-	Command(const QString &_itemName = QString(), int _cmdId = -1);
+	CommandContainer(const QList<Command *> &_commandList = QList<Command *>(), int _cmdId = -1);
+	static SerializableItem *newItem() { return new CommandContainer; }
+	int getItemId() const { return ItemId_CommandContainer; }
 	int getCmdId() const { return static_cast<SerializableItem_Int *>(itemMap.value("cmd_id"))->getData(); }
 	int tick() { return ++ticks; }
 	void processResponse(ProtocolResponse *response);
-	void setExtraData(const QVariant &_extraData) { extraData = _extraData; }
-	QVariant getExtraData() const { return extraData; }
+	QList<Command *> getCommandList() const { return typecastItemList<Command *>(); }
+	
+	ProtocolResponse *getResponse() const { return resp; }
+	void setResponse(ProtocolResponse *_resp);
+	const QList<ProtocolItem *> &getItemQueue() const { return itemQueue; }
+	void enqueueItem(ProtocolItem *item) { itemQueue.append(item); }
+	GameEventContainer *getGameEventQueue() const { return gameEventQueue; }
+	void enqueueGameEvent(GameEvent *event, int gameId);
 };
 
 class ChatCommand : public Command {
@@ -197,9 +227,20 @@ public:
 class GameEvent : public ProtocolItem {
 	Q_OBJECT
 public:
-	GameEvent(const QString &_eventName, int _gameId, int _playerId);
-	int getGameId() const { return static_cast<SerializableItem_Int *>(itemMap.value("game_id"))->getData(); }
+	GameEvent(const QString &_eventName, int _playerId);
 	int getPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_id"))->getData(); }
+};
+
+class GameEventContainer : public ProtocolItem {
+	Q_OBJECT
+public:
+	GameEventContainer(const QList<GameEvent *> &_eventList = QList<GameEvent *>(), int _gameId = -1);
+	static SerializableItem *newItem() { return new GameEventContainer; }
+	int getItemId() const { return ItemId_GameEventContainer; }
+	QList<GameEvent *> getEventList() const { return typecastItemList<GameEvent *>(); }
+	static GameEventContainer *makeNew(GameEvent *event, int _gameId);
+
+	int getGameId() const { return static_cast<SerializableItem_Int *>(itemMap.value("game_id"))->getData(); }
 	void setGameId(int _gameId) { static_cast<SerializableItem_Int *>(itemMap.value("game_id"))->setData(_gameId); }
 };
 
@@ -240,7 +281,7 @@ public:
 class Event_Join : public GameEvent {
 	Q_OBJECT
 public:
-	Event_Join(int _gameId = -1, ServerInfo_Player * player = 0);
+	Event_Join(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")); }
@@ -249,7 +290,7 @@ public:
 class Event_GameStateChanged : public GameEvent {
 	Q_OBJECT
 public:
-	Event_GameStateChanged(int _gameId = -1, bool _gameStarted = false, int _activePlayer = -1, int _activePhase = -1, const QList<ServerInfo_Player *> &_playerList = QList<ServerInfo_Player *>());
+	Event_GameStateChanged(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 *>(); }
@@ -261,7 +302,7 @@ public:
 class Event_Ping : public GameEvent {
 	Q_OBJECT
 public:
-	Event_Ping(int _gameId = -1, const QList<ServerInfo_PlayerPing *> &_pingList = QList<ServerInfo_PlayerPing *>());
+	Event_Ping(const QList<ServerInfo_PlayerPing *> &_pingList = QList<ServerInfo_PlayerPing *>());
 	static SerializableItem *newItem() { return new Event_Ping; }
 	int getItemId() const { return ItemId_Event_Ping; }
 	QList<ServerInfo_PlayerPing *> getPingList() const { return typecastItemList<ServerInfo_PlayerPing *>(); }
@@ -270,7 +311,7 @@ public:
 class Event_CreateArrows : public GameEvent {
 	Q_OBJECT
 public:
-	Event_CreateArrows(int _gameId = -1, int _playerId = -1, const QList<ServerInfo_Arrow *> &_arrowList = QList<ServerInfo_Arrow *>());
+	Event_CreateArrows(int _playerId = -1, const QList<ServerInfo_Arrow *> &_arrowList = QList<ServerInfo_Arrow *>());
 	int getItemId() const { return ItemId_Event_CreateArrows; }
 	static SerializableItem *newItem() { return new Event_CreateArrows; }
 	QList<ServerInfo_Arrow *> getArrowList() const { return typecastItemList<ServerInfo_Arrow *>(); }
@@ -279,7 +320,7 @@ public:
 class Event_CreateCounters : public GameEvent {
 	Q_OBJECT
 public:
-	Event_CreateCounters(int _gameId = -1, int _playerId = -1, const QList<ServerInfo_Counter *> &_counterList = QList<ServerInfo_Counter *>());
+	Event_CreateCounters(int _playerId = -1, const QList<ServerInfo_Counter *> &_counterList = QList<ServerInfo_Counter *>());
 	int getItemId() const { return ItemId_Event_CreateCounters; }
 	static SerializableItem *newItem() { return new Event_CreateCounters; }
 	QList<ServerInfo_Counter *> getCounterList() const { return typecastItemList<ServerInfo_Counter *>(); }
@@ -288,7 +329,7 @@ public:
 class Event_DrawCards : public GameEvent {
 	Q_OBJECT
 public:
-	Event_DrawCards(int _gameId = -1, int _playerId = -1, int numberCards = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>());
+	Event_DrawCards(int _playerId = -1, int numberCards = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>());
 	int getItemId() const { return ItemId_Event_DrawCards; }
 	static SerializableItem *newItem() { return new Event_DrawCards; }
 	int getNumberCards() const { return static_cast<SerializableItem_Int *>(itemMap.value("number_cards"))->getData(); }

common/protocol_items.cpp

@@ -198,44 +198,44 @@ Command_StopDumpZone::Command_StopDumpZone(int _gameId, int _playerId, const QSt
 	insertItem(new SerializableItem_Int("player_id", _playerId));
 	insertItem(new SerializableItem_String("zone_name", _zoneName));
 }
-Event_Say::Event_Say(int _gameId, int _playerId, const QString &_message)
-	: GameEvent("say", _gameId, _playerId)
+Event_Say::Event_Say(int _playerId, const QString &_message)
+	: GameEvent("say", _playerId)
 {
 	insertItem(new SerializableItem_String("message", _message));
 }
-Event_Leave::Event_Leave(int _gameId, int _playerId)
-	: GameEvent("leave", _gameId, _playerId)
+Event_Leave::Event_Leave(int _playerId)
+	: GameEvent("leave", _playerId)
 {
 }
-Event_DeckSelect::Event_DeckSelect(int _gameId, int _playerId, int _deckId)
-	: GameEvent("deck_select", _gameId, _playerId)
+Event_DeckSelect::Event_DeckSelect(int _playerId, int _deckId)
+	: GameEvent("deck_select", _playerId)
 {
 	insertItem(new SerializableItem_Int("deck_id", _deckId));
 }
-Event_GameClosed::Event_GameClosed(int _gameId, int _playerId)
-	: GameEvent("game_closed", _gameId, _playerId)
+Event_GameClosed::Event_GameClosed(int _playerId)
+	: GameEvent("game_closed", _playerId)
 {
 }
-Event_ReadyStart::Event_ReadyStart(int _gameId, int _playerId)
-	: GameEvent("ready_start", _gameId, _playerId)
+Event_ReadyStart::Event_ReadyStart(int _playerId)
+	: GameEvent("ready_start", _playerId)
 {
 }
-Event_Concede::Event_Concede(int _gameId, int _playerId)
-	: GameEvent("concede", _gameId, _playerId)
+Event_Concede::Event_Concede(int _playerId)
+	: GameEvent("concede", _playerId)
 {
 }
-Event_Shuffle::Event_Shuffle(int _gameId, int _playerId)
-	: GameEvent("shuffle", _gameId, _playerId)
+Event_Shuffle::Event_Shuffle(int _playerId)
+	: GameEvent("shuffle", _playerId)
 {
 }
-Event_RollDie::Event_RollDie(int _gameId, int _playerId, int _sides, int _value)
-	: GameEvent("roll_die", _gameId, _playerId)
+Event_RollDie::Event_RollDie(int _playerId, int _sides, int _value)
+	: GameEvent("roll_die", _playerId)
 {
 	insertItem(new SerializableItem_Int("sides", _sides));
 	insertItem(new SerializableItem_Int("value", _value));
 }
-Event_MoveCard::Event_MoveCard(int _gameId, int _playerId, int _cardId, const QString &_cardName, const QString &_startZone, int _position, const QString &_targetZone, int _x, int _y, int _newCardId, bool _faceDown)
-	: GameEvent("move_card", _gameId, _playerId)
+Event_MoveCard::Event_MoveCard(int _playerId, int _cardId, const QString &_cardName, const QString &_startZone, int _position, const QString &_targetZone, int _x, int _y, int _newCardId, bool _faceDown)
+	: GameEvent("move_card", _playerId)
 {
 	insertItem(new SerializableItem_Int("card_id", _cardId));
 	insertItem(new SerializableItem_String("card_name", _cardName));
@@ -247,8 +247,8 @@ Event_MoveCard::Event_MoveCard(int _gameId, int _playerId, int _cardId, const QS
 	insertItem(new SerializableItem_Int("new_card_id", _newCardId));
 	insertItem(new SerializableItem_Bool("face_down", _faceDown));
 }
-Event_CreateToken::Event_CreateToken(int _gameId, int _playerId, const QString &_zone, int _cardId, const QString &_cardName, const QString &_pt, int _x, int _y)
-	: GameEvent("create_token", _gameId, _playerId)
+Event_CreateToken::Event_CreateToken(int _playerId, const QString &_zone, int _cardId, const QString &_cardName, const QString &_pt, int _x, int _y)
+	: GameEvent("create_token", _playerId)
 {
 	insertItem(new SerializableItem_String("zone", _zone));
 	insertItem(new SerializableItem_Int("card_id", _cardId));
@@ -257,49 +257,49 @@ Event_CreateToken::Event_CreateToken(int _gameId, int _playerId, const QString &
 	insertItem(new SerializableItem_Int("x", _x));
 	insertItem(new SerializableItem_Int("y", _y));
 }
-Event_DeleteArrow::Event_DeleteArrow(int _gameId, int _playerId, int _arrowId)
-	: GameEvent("delete_arrow", _gameId, _playerId)
+Event_DeleteArrow::Event_DeleteArrow(int _playerId, int _arrowId)
+	: GameEvent("delete_arrow", _playerId)
 {
 	insertItem(new SerializableItem_Int("arrow_id", _arrowId));
 }
-Event_SetCardAttr::Event_SetCardAttr(int _gameId, int _playerId, const QString &_zone, int _cardId, const QString &_attrName, const QString &_attrValue)
-	: GameEvent("set_card_attr", _gameId, _playerId)
+Event_SetCardAttr::Event_SetCardAttr(int _playerId, const QString &_zone, int _cardId, const QString &_attrName, const QString &_attrValue)
+	: GameEvent("set_card_attr", _playerId)
 {
 	insertItem(new SerializableItem_String("zone", _zone));
 	insertItem(new SerializableItem_Int("card_id", _cardId));
 	insertItem(new SerializableItem_String("attr_name", _attrName));
 	insertItem(new SerializableItem_String("attr_value", _attrValue));
 }
-Event_SetCounter::Event_SetCounter(int _gameId, int _playerId, int _counterId, int _value)
-	: GameEvent("set_counter", _gameId, _playerId)
+Event_SetCounter::Event_SetCounter(int _playerId, int _counterId, int _value)
+	: GameEvent("set_counter", _playerId)
 {
 	insertItem(new SerializableItem_Int("counter_id", _counterId));
 	insertItem(new SerializableItem_Int("value", _value));
 }
-Event_DelCounter::Event_DelCounter(int _gameId, int _playerId, int _counterId)
-	: GameEvent("del_counter", _gameId, _playerId)
+Event_DelCounter::Event_DelCounter(int _playerId, int _counterId)
+	: GameEvent("del_counter", _playerId)
 {
 	insertItem(new SerializableItem_Int("counter_id", _counterId));
 }
-Event_SetActivePlayer::Event_SetActivePlayer(int _gameId, int _playerId, int _activePlayerId)
-	: GameEvent("set_active_player", _gameId, _playerId)
+Event_SetActivePlayer::Event_SetActivePlayer(int _playerId, int _activePlayerId)
+	: GameEvent("set_active_player", _playerId)
 {
 	insertItem(new SerializableItem_Int("active_player_id", _activePlayerId));
 }
-Event_SetActivePhase::Event_SetActivePhase(int _gameId, int _playerId, int _phase)
-	: GameEvent("set_active_phase", _gameId, _playerId)
+Event_SetActivePhase::Event_SetActivePhase(int _playerId, int _phase)
+	: GameEvent("set_active_phase", _playerId)
 {
 	insertItem(new SerializableItem_Int("phase", _phase));
 }
-Event_DumpZone::Event_DumpZone(int _gameId, int _playerId, int _zoneOwnerId, const QString &_zone, int _numberCards)
-	: GameEvent("dump_zone", _gameId, _playerId)
+Event_DumpZone::Event_DumpZone(int _playerId, int _zoneOwnerId, const QString &_zone, int _numberCards)
+	: GameEvent("dump_zone", _playerId)
 {
 	insertItem(new SerializableItem_Int("zone_owner_id", _zoneOwnerId));
 	insertItem(new SerializableItem_String("zone", _zone));
 	insertItem(new SerializableItem_Int("number_cards", _numberCards));
 }
-Event_StopDumpZone::Event_StopDumpZone(int _gameId, int _playerId, int _zoneOwnerId, const QString &_zone)
-	: GameEvent("stop_dump_zone", _gameId, _playerId)
+Event_StopDumpZone::Event_StopDumpZone(int _playerId, int _zoneOwnerId, const QString &_zone)
+	: GameEvent("stop_dump_zone", _playerId)
 {
 	insertItem(new SerializableItem_Int("zone_owner_id", _zoneOwnerId));
 	insertItem(new SerializableItem_String("zone", _zone));

common/protocol_items.h

@@ -308,7 +308,7 @@ public:
 class Event_Say : public GameEvent {
 	Q_OBJECT
 public:
-	Event_Say(int _gameId = -1, int _playerId = -1, const QString &_message = QString());
+	Event_Say(int _playerId = -1, const QString &_message = QString());
 	QString getMessage() const { return static_cast<SerializableItem_String *>(itemMap.value("message"))->getData(); };
 	static SerializableItem *newItem() { return new Event_Say; }
 	int getItemId() const { return ItemId_Event_Say; }
@@ -316,14 +316,14 @@ public:
 class Event_Leave : public GameEvent {
 	Q_OBJECT
 public:
-	Event_Leave(int _gameId = -1, int _playerId = -1);
+	Event_Leave(int _playerId = -1);
 	static SerializableItem *newItem() { return new Event_Leave; }
 	int getItemId() const { return ItemId_Event_Leave; }
 };
 class Event_DeckSelect : public GameEvent {
 	Q_OBJECT
 public:
-	Event_DeckSelect(int _gameId = -1, int _playerId = -1, int _deckId = -1);
+	Event_DeckSelect(int _playerId = -1, int _deckId = -1);
 	int getDeckId() const { return static_cast<SerializableItem_Int *>(itemMap.value("deck_id"))->getData(); };
 	static SerializableItem *newItem() { return new Event_DeckSelect; }
 	int getItemId() const { return ItemId_Event_DeckSelect; }
@@ -331,35 +331,35 @@ public:
 class Event_GameClosed : public GameEvent {
 	Q_OBJECT
 public:
-	Event_GameClosed(int _gameId = -1, int _playerId = -1);
+	Event_GameClosed(int _playerId = -1);
 	static SerializableItem *newItem() { return new Event_GameClosed; }
 	int getItemId() const { return ItemId_Event_GameClosed; }
 };
 class Event_ReadyStart : public GameEvent {
 	Q_OBJECT
 public:
-	Event_ReadyStart(int _gameId = -1, int _playerId = -1);
+	Event_ReadyStart(int _playerId = -1);
 	static SerializableItem *newItem() { return new Event_ReadyStart; }
 	int getItemId() const { return ItemId_Event_ReadyStart; }
 };
 class Event_Concede : public GameEvent {
 	Q_OBJECT
 public:
-	Event_Concede(int _gameId = -1, int _playerId = -1);
+	Event_Concede(int _playerId = -1);
 	static SerializableItem *newItem() { return new Event_Concede; }
 	int getItemId() const { return ItemId_Event_Concede; }
 };
 class Event_Shuffle : public GameEvent {
 	Q_OBJECT
 public:
-	Event_Shuffle(int _gameId = -1, int _playerId = -1);
+	Event_Shuffle(int _playerId = -1);
 	static SerializableItem *newItem() { return new Event_Shuffle; }
 	int getItemId() const { return ItemId_Event_Shuffle; }
 };
 class Event_RollDie : public GameEvent {
 	Q_OBJECT
 public:
-	Event_RollDie(int _gameId = -1, int _playerId = -1, int _sides = -1, int _value = -1);
+	Event_RollDie(int _playerId = -1, int _sides = -1, int _value = -1);
 	int getSides() const { return static_cast<SerializableItem_Int *>(itemMap.value("sides"))->getData(); };
 	int getValue() const { return static_cast<SerializableItem_Int *>(itemMap.value("value"))->getData(); };
 	static SerializableItem *newItem() { return new Event_RollDie; }
@@ -368,7 +368,7 @@ public:
 class Event_MoveCard : public GameEvent {
 	Q_OBJECT
 public:
-	Event_MoveCard(int _gameId = -1, int _playerId = -1, int _cardId = -1, const QString &_cardName = QString(), const QString &_startZone = QString(), int _position = -1, const QString &_targetZone = QString(), int _x = -1, int _y = -1, int _newCardId = -1, bool _faceDown = false);
+	Event_MoveCard(int _playerId = -1, int _cardId = -1, const QString &_cardName = QString(), const QString &_startZone = QString(), int _position = -1, const QString &_targetZone = QString(), int _x = -1, int _y = -1, int _newCardId = -1, bool _faceDown = false);
 	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
 	QString getCardName() const { return static_cast<SerializableItem_String *>(itemMap.value("card_name"))->getData(); };
 	QString getStartZone() const { return static_cast<SerializableItem_String *>(itemMap.value("start_zone"))->getData(); };
@@ -384,7 +384,7 @@ public:
 class Event_CreateToken : public GameEvent {
 	Q_OBJECT
 public:
-	Event_CreateToken(int _gameId = -1, int _playerId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_cardName = QString(), const QString &_pt = QString(), int _x = -1, int _y = -1);
+	Event_CreateToken(int _playerId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_cardName = QString(), const QString &_pt = QString(), int _x = -1, int _y = -1);
 	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
 	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
 	QString getCardName() const { return static_cast<SerializableItem_String *>(itemMap.value("card_name"))->getData(); };
@@ -397,7 +397,7 @@ public:
 class Event_DeleteArrow : public GameEvent {
 	Q_OBJECT
 public:
-	Event_DeleteArrow(int _gameId = -1, int _playerId = -1, int _arrowId = -1);
+	Event_DeleteArrow(int _playerId = -1, int _arrowId = -1);
 	int getArrowId() const { return static_cast<SerializableItem_Int *>(itemMap.value("arrow_id"))->getData(); };
 	static SerializableItem *newItem() { return new Event_DeleteArrow; }
 	int getItemId() const { return ItemId_Event_DeleteArrow; }
@@ -405,7 +405,7 @@ public:
 class Event_SetCardAttr : public GameEvent {
 	Q_OBJECT
 public:
-	Event_SetCardAttr(int _gameId = -1, int _playerId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_attrName = QString(), const QString &_attrValue = QString());
+	Event_SetCardAttr(int _playerId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_attrName = QString(), const QString &_attrValue = QString());
 	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
 	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
 	QString getAttrName() const { return static_cast<SerializableItem_String *>(itemMap.value("attr_name"))->getData(); };
@@ -416,7 +416,7 @@ public:
 class Event_SetCounter : public GameEvent {
 	Q_OBJECT
 public:
-	Event_SetCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1, int _value = -1);
+	Event_SetCounter(int _playerId = -1, int _counterId = -1, int _value = -1);
 	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
 	int getValue() const { return static_cast<SerializableItem_Int *>(itemMap.value("value"))->getData(); };
 	static SerializableItem *newItem() { return new Event_SetCounter; }
@@ -425,7 +425,7 @@ public:
 class Event_DelCounter : public GameEvent {
 	Q_OBJECT
 public:
-	Event_DelCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1);
+	Event_DelCounter(int _playerId = -1, int _counterId = -1);
 	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
 	static SerializableItem *newItem() { return new Event_DelCounter; }
 	int getItemId() const { return ItemId_Event_DelCounter; }
@@ -433,7 +433,7 @@ public:
 class Event_SetActivePlayer : public GameEvent {
 	Q_OBJECT
 public:
-	Event_SetActivePlayer(int _gameId = -1, int _playerId = -1, int _activePlayerId = -1);
+	Event_SetActivePlayer(int _playerId = -1, int _activePlayerId = -1);
 	int getActivePlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("active_player_id"))->getData(); };
 	static SerializableItem *newItem() { return new Event_SetActivePlayer; }
 	int getItemId() const { return ItemId_Event_SetActivePlayer; }
@@ -441,7 +441,7 @@ public:
 class Event_SetActivePhase : public GameEvent {
 	Q_OBJECT
 public:
-	Event_SetActivePhase(int _gameId = -1, int _playerId = -1, int _phase = -1);
+	Event_SetActivePhase(int _playerId = -1, int _phase = -1);
 	int getPhase() const { return static_cast<SerializableItem_Int *>(itemMap.value("phase"))->getData(); };
 	static SerializableItem *newItem() { return new Event_SetActivePhase; }
 	int getItemId() const { return ItemId_Event_SetActivePhase; }
@@ -449,7 +449,7 @@ public:
 class Event_DumpZone : public GameEvent {
 	Q_OBJECT
 public:
-	Event_DumpZone(int _gameId = -1, int _playerId = -1, int _zoneOwnerId = -1, const QString &_zone = QString(), int _numberCards = -1);
+	Event_DumpZone(int _playerId = -1, int _zoneOwnerId = -1, const QString &_zone = QString(), int _numberCards = -1);
 	int getZoneOwnerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("zone_owner_id"))->getData(); };
 	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
 	int getNumberCards() const { return static_cast<SerializableItem_Int *>(itemMap.value("number_cards"))->getData(); };
@@ -459,7 +459,7 @@ public:
 class Event_StopDumpZone : public GameEvent {
 	Q_OBJECT
 public:
-	Event_StopDumpZone(int _gameId = -1, int _playerId = -1, int _zoneOwnerId = -1, const QString &_zone = QString());
+	Event_StopDumpZone(int _playerId = -1, int _zoneOwnerId = -1, const QString &_zone = QString());
 	int getZoneOwnerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("zone_owner_id"))->getData(); };
 	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
 	static SerializableItem *newItem() { return new Event_StopDumpZone; }

common/protocol_mc.pl

@@ -49,9 +49,9 @@ while (<file>) {
 		$type = 'game_event';
 		$namePrefix = 'Event';
 		$baseClass = 'GameEvent';
-		$parentConstructorCall = "$baseClass(\"$name1\", _gameId, _playerId)";
-		$constructorParamsH = "int _gameId = -1, int _playerId = -1";
-		$constructorParamsCpp = "int _gameId, int _playerId";
+		$parentConstructorCall = "$baseClass(\"$name1\", _playerId)";
+		$constructorParamsH = "int _playerId = -1";
+		$constructorParamsCpp = "int _playerId";
 	} elsif ($type == 4) {
 		$type = 'generic_event';
 		$namePrefix = 'Event';

common/server_game.cpp

@@ -66,7 +66,7 @@ void Server_Game::pingClockTimeout()
 			pingTime = -1;
 		pingList.append(new ServerInfo_PlayerPing(player->getPlayerId(), pingTime));
 	}
-	sendGameEvent(new Event_Ping(-1, pingList));
+	sendGameEvent(new Event_Ping(pingList));
 	
 	const int maxTime = static_cast<Server *>(parent())->getMaxGameInactivityTime();
 	if (allPlayersInactive) {
@@ -119,7 +119,7 @@ void Server_Game::startGameIfReady()
 		Server_Player *player = playerIterator.next().value();
 		player->setConceded(false);
 		player->setReadyStart(false);
-		player->sendProtocolItem(new Event_GameStateChanged(gameId, gameStarted, 0, 0, getGameState(player)));
+		sendGameEventToPlayer(player, new Event_GameStateChanged(gameStarted, 0, 0, getGameState(player)));
 	}
 	
 /*	QSqlQuery query;
@@ -157,7 +157,7 @@ void Server_Game::stopGameIfFinished()
 	playerIterator.toFront();
 	while (playerIterator.hasNext()) {
 		Server_Player *player = playerIterator.next().value();
-		player->sendProtocolItem(new Event_GameStateChanged(gameId, gameStarted, -1, -1, getGameState(player)));
+		sendGameEventToPlayer(player, new Event_GameStateChanged(gameStarted, -1, -1, getGameState(player)));
 	}
 }
 
@@ -180,7 +180,7 @@ Server_Player *Server_Game::addPlayer(Server_ProtocolHandler *handler, bool spec
 	int playerId = keyList.isEmpty() ? 0 : (keyList.last() + 1);
 	
 	Server_Player *newPlayer = new Server_Player(this, playerId, handler->getPlayerName(), spectator, handler);
-	sendGameEvent(new Event_Join(-1, new ServerInfo_Player(playerId, handler->getPlayerName(), spectator)));
+	sendGameEvent(new Event_Join(new ServerInfo_Player(playerId, handler->getPlayerName(), spectator)));
 	players.insert(playerId, newPlayer);
 
 	if (broadcastUpdate)
@@ -192,7 +192,7 @@ Server_Player *Server_Game::addPlayer(Server_ProtocolHandler *handler, bool spec
 void Server_Game::removePlayer(Server_Player *player)
 {
 	players.remove(player->getPlayerId());
-	sendGameEvent(new Event_Leave(-1, player->getPlayerId()));
+	sendGameEvent(new Event_Leave(player->getPlayerId()));
 	delete player;
 	
 	if (!getPlayerCount())
@@ -205,7 +205,7 @@ void Server_Game::removePlayer(Server_Player *player)
 void Server_Game::setActivePlayer(int _activePlayer)
 {
 	activePlayer = _activePlayer;
-	sendGameEvent(new Event_SetActivePlayer(-1, -1, activePlayer));
+	sendGameEvent(new Event_SetActivePlayer(-1, activePlayer));
 	setActivePhase(0);
 }
 
@@ -217,13 +217,13 @@ void Server_Game::setActivePhase(int _activePhase)
 		QList<Server_Arrow *> toDelete = player->getArrows().values();
 		for (int i = 0; i < toDelete.size(); ++i) {
 			Server_Arrow *a = toDelete[i];
-			sendGameEvent(new Event_DeleteArrow(-1, player->getPlayerId(), a->getId()));
+			sendGameEvent(new Event_DeleteArrow(player->getPlayerId(), a->getId()));
 			player->deleteArrow(a->getId());
 		}
 	}
 	
 	activePhase = _activePhase;
-	sendGameEvent(new Event_SetActivePhase(-1, -1, activePhase));
+	sendGameEvent(new Event_SetActivePhase(-1, activePhase));
 }
 
 QList<ServerInfo_Player *> Server_Game::getGameState(Server_Player *playerWhosAsking) const
@@ -282,13 +282,23 @@ QList<ServerInfo_Player *> Server_Game::getGameState(Server_Player *playerWhosAs
 
 void Server_Game::sendGameEvent(GameEvent *event, Server_Player *exclude)
 {
-	event->setGameId(gameId);
+	sendGameEventContainer(new GameEventContainer(QList<GameEvent *>() << event), exclude);
+}
+
+void Server_Game::sendGameEventContainer(GameEventContainer *cont, Server_Player *exclude)
+{
+	cont->setGameId(gameId);
 	QMapIterator<int, Server_Player *> playerIterator(players);
 	while (playerIterator.hasNext()) {
 		Server_Player *p = playerIterator.next().value();
 		if (p != exclude)
-			p->sendProtocolItem(event, false);
+			p->sendProtocolItem(cont, false);
 	}
 
-	delete event;
+	delete cont;
+}
+
+void Server_Game::sendGameEventToPlayer(Server_Player *player, GameEvent *event)
+{
+	player->sendProtocolItem(new GameEventContainer(QList<GameEvent *>() << event, gameId));
 }

common/server_game.h

@@ -73,6 +73,8 @@ public:
 
 	QList<ServerInfo_Player *> getGameState(Server_Player *playerWhosAsking) const;
 	void sendGameEvent(GameEvent *event, Server_Player *exclude = 0);
+	void sendGameEventContainer(GameEventContainer *cont, Server_Player *exclude = 0);
+	void sendGameEventToPlayer(Server_Player *player, GameEvent *event);
 };
 
 #endif