more server code

common/protocol.cpp

@@ -193,3 +193,37 @@ void Event_ChatListPlayers::writeElement(QXmlStreamWriter *xml)
 		xml->writeEndElement();
 	}
 }
+
+bool Event_ListGames::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isStartElement() && (xml->name() == "game")) {
+		gameList.append(GameInfo(
+			xml->attributes().value("id").toString().toInt(),
+			xml->attributes().value("description").toString(),
+			xml->attributes().value("has_password").toString().toInt(),
+			xml->attributes().value("player_count").toString().toInt(),
+			xml->attributes().value("max_players").toString().toInt(),
+			xml->attributes().value("creator").toString(),
+			xml->attributes().value("spectators_allowed").toString().toInt(),
+			xml->attributes().value("spectator_count").toString().toInt()
+		));
+		return true;
+	}
+	return false;
+}
+
+void Event_ListGames::writeElement(QXmlStreamWriter *xml)
+{
+	for (int i = 0; i < gameList.size(); ++i) {
+		xml->writeStartElement("game");
+		xml->writeAttribute("id", QString::number(gameList[i].getGameId()));
+		xml->writeAttribute("description", gameList[i].getDescription());
+		xml->writeAttribute("has_password", gameList[i].getHasPassword() ? "1" : "0");
+		xml->writeAttribute("player_count", QString::number(gameList[i].getPlayerCount()));
+		xml->writeAttribute("max_players", QString::number(gameList[i].getMaxPlayers()));
+		xml->writeAttribute("creator", gameList[i].getCreatorName());
+		xml->writeAttribute("spectators_allowed", gameList[i].getSpectatorsAllowed() ? "1" : "0");
+		xml->writeAttribute("spectator_count", QString::number(gameList[i].getSpectatorCount()));
+		xml->writeEndElement();
+	}
+}

common/protocol.h

@@ -15,6 +15,7 @@ class QXmlStreamAttributes;
 enum ItemId {
 	ItemId_Event_ChatListChannels = ItemId_Other + 1,
 	ItemId_Event_ChatListPlayers = ItemId_Other + 2,
+	ItemId_Event_ListGames = ItemId_Other + 3
 };
 
 class ProtocolItem : public QObject {
@@ -139,6 +140,9 @@ protected:
 	void extractParameters();
 public:
 	GameEvent(const QString &_eventName, int _gameId, int _playerId);
+	int getGameId() const { return gameId; }
+	int getPlayerId() const { return playerId; }
+	void setGameId(int _gameId) { gameId = _gameId; }
 };
 
 class ChatEvent : public ProtocolItem {
@@ -210,4 +214,44 @@ public:
 	void writeElement(QXmlStreamWriter *xml);
 };
 
+class Event_ListGames : public GenericEvent {
+	Q_OBJECT
+public:
+	class GameInfo {
+	private:
+		int gameId;
+		QString description;
+		bool hasPassword;
+		int playerCount;
+		int maxPlayers;
+		QString creatorName;
+		bool spectatorsAllowed;
+		int spectatorCount;
+	public:
+		GameInfo(int _gameId, const QString &_description, bool _hasPassword, int _playerCount, int _maxPlayers, const QString &_creatorName, bool _spectatorsAllowed, int _spectatorCount)
+			: gameId(_gameId), description(_description), hasPassword(_hasPassword), playerCount(_playerCount), maxPlayers(_maxPlayers), creatorName(_creatorName), spectatorsAllowed(_spectatorsAllowed), spectatorCount(_spectatorCount) { }
+		int getGameId() const { return gameId; }
+		QString getDescription() const { return description; }
+		bool getHasPassword() const { return hasPassword; }
+		int getPlayerCount() const { return playerCount; }
+		int getMaxPlayers() const { return maxPlayers; }
+		QString getCreatorName() const { return creatorName; }
+		bool getSpectatorsAllowed() const { return spectatorsAllowed; }
+		int getSpectatorCount() const { return spectatorCount; }
+	};
+private:
+	QList<GameInfo> gameList;
+public:
+	Event_ListGames() : GenericEvent("list_games") { }
+	int getItemId() const { return ItemId_Event_ListGames; }
+	void addGame(int _gameId, const QString &_description, bool _hasPassword, int _playerCount, int _maxPlayers, const QString &_creatorName, bool _spectatorsAllowed, int _spectatorCount)
+	{
+		gameList.append(GameInfo(_gameId, _description, _hasPassword, _playerCount, _maxPlayers, _creatorName, _spectatorsAllowed, _spectatorCount));
+	}
+	const QList<GameInfo> &getGameList() const { return gameList; }
+
+	bool readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+};
+
 #endif

common/server.cpp

@@ -21,6 +21,7 @@
 #include "server_game.h"
 #include "server_counter.h"
 #include "server_chatchannel.h"
+#include "server_protocolhandler.h"
 
 Server::Server(QObject *parent)
 	: QObject(parent), nextGameId(0)
@@ -31,7 +32,7 @@ Server::~Server()
 {
 }
 
-Server_Game *Server::createGame(const QString &description, const QString &password, int maxPlayers, bool spectatorsAllowed, const QString &creator)
+Server_Game *Server::createGame(const QString &description, const QString &password, int maxPlayers, bool spectatorsAllowed, Server_ProtocolHandler *creator)
 {
 	Server_Game *newGame = new Server_Game(creator, nextGameId++, description, password, maxPlayers, spectatorsAllowed, this);
 	games.insert(newGame->getGameId(), newGame);
@@ -60,19 +61,40 @@ Server_Game *Server::getGame(int gameId) const
 
 void Server::broadcastGameListUpdate(Server_Game *game)
 {
-/*	QString line = game->getGameListLine();
+	Event_ListGames *event = new Event_ListGames;
+	if (game->getPlayerCount())
+		// Game is open
+		event->addGame(
+			game->getGameId(),
+			game->getDescription(),
+			!game->getPassword().isEmpty(),
+			game->getPlayerCount(),
+			game->getMaxPlayers(),
+			game->getCreatorName(),
+			game->getSpectatorsAllowed(),
+			game->getSpectatorCount()
+		);
+	else
+		// Game is closing
+		event->addGame(game->getGameId(), QString(), false, 0, game->getMaxPlayers(), QString(), false, 0);
+	
 	for (int i = 0; i < clients.size(); i++)
 		if (clients[i]->getAcceptsGameListChanges())
-			clients[i]->msg(line);
+			clients[i]->sendProtocolItem(event, false);
-*/}
+	delete event;
+}
 
 void Server::broadcastChannelUpdate()
 {
-/*	QString line = qobject_cast<Server_ChatChannel *>(sender())->getChannelListLine();
+	Server_ChatChannel *channel = static_cast<Server_ChatChannel *>(sender());
-	for (int i = 0; i < players.size(); ++i)
+	Event_ChatListChannels *event = new Event_ChatListChannels;
-	  	if (players[i]->getAcceptsChatChannelListChanges())
+	event->addChannel(channel->getName(), channel->getDescription(), channel->size(), channel->getAutoJoin());
-		  	players[i]->msg(line);
+
-*/}
+	for (int i = 0; i < clients.size(); ++i)
+	  	if (clients[i]->getAcceptsChatChannelListChanges())
+		  	clients[i]->sendProtocolItem(event, false);
+	delete event;
+}
 
 void Server::gameClosing()
 {

common/server.h

@@ -29,7 +29,7 @@ public:
 	void addClient(Server_ProtocolHandler *player);
 	void removeClient(Server_ProtocolHandler *player);
 	virtual QString getLoginMessage() const = 0;
-	Server_Game *createGame(const QString &description, const QString &password, int maxPlayers, bool spectatorsAllowed, const QString &playerName);
+	Server_Game *createGame(const QString &description, const QString &password, int maxPlayers, bool spectatorsAllowed, Server_ProtocolHandler *creator);
 private:
 	QMap<int, Server_Game *> games;
 	QList<Server_ProtocolHandler *> clients;

common/server_game.cpp

@@ -23,7 +23,7 @@
 #include "server_arrow.h"
 #include <QSqlQuery>
 
-Server_Game::Server_Game(const QString &_creator, int _gameId, const QString &_description, const QString &_password, int _maxPlayers, bool _spectatorsAllowed, QObject *parent)
+Server_Game::Server_Game(Server_ProtocolHandler *_creator, int _gameId, const QString &_description, const QString &_password, int _maxPlayers, bool _spectatorsAllowed, QObject *parent)
 	: QObject(parent), gameStarted(false), gameId(_gameId), description(_description), password(_password), maxPlayers(_maxPlayers), spectatorsAllowed(_spectatorsAllowed)
 {
 	creator = addPlayer(_creator, false);
@@ -31,7 +31,7 @@ Server_Game::Server_Game(const QString &_creator, int _gameId, const QString &_d
 
 Server_Game::~Server_Game()
 {
-	broadcastEvent("game_closed", 0);
+	sendGameEvent(new Event_GameClosed);
 	
 	QMapIterator<int, Server_Player *> playerIterator(players);
 	while (playerIterator.hasNext())
@@ -45,30 +45,6 @@ Server_Game::~Server_Game()
 	qDebug("Server_Game destructor");
 }
 
-QString Server_Game::getGameListLine() const
-{
-	if (players.isEmpty())
-		return QString("list_games|%1|||0|%2||0|0").arg(gameId).arg(maxPlayers);
-	else {
-		QString creatorName = creator ? creator->getPlayerName() : QString();
-		return QString("list_games|%1|%2|%3|%4|%5|%6|%7|%8").arg(gameId)
-							      .arg(description)
-							      .arg(password.isEmpty() ? 0 : 1)
-							      .arg(players.size())
-							      .arg(maxPlayers)
-							      .arg(creatorName)
-							      .arg(spectatorsAllowed ? 1 : 0)
-							      .arg(spectators.size());
-	}
-}
-
-void Server_Game::broadcastEvent(const QString &eventStr, Server_Player *player)
-{
-	QList<Server_Player *> allClients = QList<Server_Player *>() << players.values() << spectators;
-	for (int i = 0; i < allClients.size(); ++i)
-		allClients[i]->publicEvent(eventStr, player);
-}
-
 void Server_Game::startGameIfReady()
 {
 	if (players.size() < maxPlayers)
@@ -97,7 +73,7 @@ void Server_Game::startGameIfReady()
 	}
 */	
 	gameStarted = true;
-	broadcastEvent("game_start", NULL);
+	sendGameEvent(new Event_GameStart);
 	setActivePlayer(0);
 }
 
@@ -114,7 +90,7 @@ ProtocolResponse::ResponseCode Server_Game::checkJoin(const QString &_password,
 	return ProtocolResponse::RespOk;
 }
 
-Server_Player *Server_Game::addPlayer(const QString &playerName, bool spectator)
+Server_Player *Server_Game::addPlayer(Server_ProtocolHandler *handler, bool spectator)
 {
 	int playerId;
 	if (!spectator) {
@@ -129,8 +105,8 @@ Server_Player *Server_Game::addPlayer(const QString &playerName, bool spectator)
 	} else
 		playerId = -1;
 	
-	Server_Player *newPlayer = new Server_Player(this, playerId, playerName, spectator);
+	Server_Player *newPlayer = new Server_Player(this, playerId, handler->getPlayerName(), spectator, handler);
-	broadcastEvent(QString("join|%1").arg(spectator ? 1 : 0), newPlayer);
+	sendGameEvent(new Event_Join(-1, playerId, handler->getPlayerName(), spectator));
 	
 	if (spectator)
 		spectators << newPlayer;
@@ -148,7 +124,7 @@ void Server_Game::removePlayer(Server_Player *player)
 		spectators.removeAt(spectators.indexOf(player));
 	else
 		players.remove(player->getPlayerId());
-	broadcastEvent("leave", player);
+	sendGameEvent(new Event_Leave(-1, player->getPlayerId()));
 	delete player;
 	
 	if (!players.size())
@@ -159,7 +135,7 @@ void Server_Game::removePlayer(Server_Player *player)
 void Server_Game::setActivePlayer(int _activePlayer)
 {
 	activePlayer = _activePlayer;
-	broadcastEvent(QString("set_active_player|%1").arg(_activePlayer), NULL);
+	sendGameEvent(new Event_SetActivePlayer(-1, -1, activePlayer));
 	setActivePhase(0);
 }
 
@@ -171,11 +147,22 @@ 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];
-			broadcastEvent(QString("delete_arrow|%1").arg(a->getId()), player);
+			sendGameEvent(new Event_DeleteArrow(-1, player->getPlayerId(), a->getId()));
 			player->deleteArrow(a->getId());
 		}
 	}
 	
 	activePhase = _activePhase;
-	broadcastEvent(QString("set_active_phase|%1").arg(_activePhase), NULL);
+	sendGameEvent(new Event_SetActivePhase(-1, -1, activePhase));
+}
+
+void Server_Game::sendGameEvent(GameEvent *event)
+{
+	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);
+
+	delete event;
 }

common/server_game.h

@@ -42,11 +42,13 @@ private:
 signals:
 	void gameClosing();
 public:
-	Server_Game(const QString &_creator, int _gameId, const QString &_description, const QString &_password, int _maxPlayers, bool _spectatorsAllowed, QObject *parent = 0);
+	Server_Game(Server_ProtocolHandler *_creator, int _gameId, const QString &_description, const QString &_password, int _maxPlayers, bool _spectatorsAllowed, QObject *parent = 0);
 	~Server_Game();
 	Server_Player *getCreator() const { return creator; }
+	QString getCreatorName() const { return creator ? creator->getPlayerName() : QString(); }
 	bool getGameStarted() const { return gameStarted; }
 	int getPlayerCount() const { return players.size(); }
+	int getSpectatorCount() const { return spectators.size(); }
 	QList<Server_Player *> getPlayers() const { return players.values(); }
 	Server_Player *getPlayer(int playerId) const { return players.value(playerId, 0); }
 	int getGameId() const { return gameId; }
@@ -54,9 +56,8 @@ public:
 	QString getPassword() const { return password; }
 	int getMaxPlayers() const { return maxPlayers; }
 	bool getSpectatorsAllowed() const { return spectatorsAllowed; }
-	QString getGameListLine() const;
 	ProtocolResponse::ResponseCode checkJoin(const QString &_password, bool spectator);
-	Server_Player *addPlayer(const QString &playerName, bool spectator);
+	Server_Player *addPlayer(Server_ProtocolHandler *handler, bool spectator);
 	void removePlayer(Server_Player *player);
 	void startGameIfReady();
 	int getActivePlayer() const { return activePlayer; }
@@ -64,7 +65,7 @@ public:
 	void setActivePlayer(int _activePlayer);
 	void setActivePhase(int _activePhase);
 
-	void broadcastEvent(const QString &eventStr, Server_Player *player);
+	void sendGameEvent(GameEvent *event);
 };
 
 #endif

common/server_player.cpp

@@ -4,9 +4,12 @@
 #include "server_arrow.h"
 #include "server_cardzone.h"
 #include "server_game.h"
+#include "server_protocolhandler.h"
+#include "protocol.h"
+#include "protocol_items.h"
 
-Server_Player::Server_Player(Server_Game *_game, int _playerId, const QString &_playerName, bool _spectator)
+Server_Player::Server_Player(Server_Game *_game, int _playerId, const QString &_playerName, bool _spectator, Server_ProtocolHandler *_handler)
-	: game(_game), socket(0), playerId(_playerId), playerName(_playerName), spectator(_spectator), nextCardId(0), PlayerStatus(StatusNormal)
+	: game(_game), handler(_handler), playerId(_playerId), playerName(_playerName), spectator(_spectator), nextCardId(0), PlayerStatus(StatusNormal)
 {
 }
 
@@ -73,8 +76,7 @@ void Server_Player::setupZones()
 	nextCardId = i;
 	
 	PlayerStatus = StatusPlaying;
-	game->broadcastEvent(QString("setup_zones|%1|%2").arg(deck->cards.size())
+	game->sendGameEvent(new Event_SetupZones(-1, playerId, deck->cards.size(), sb->cards.size()));
-						   .arg(sb->cards.size()), this);
 }
 
 void Server_Player::clearZones()
@@ -130,19 +132,8 @@ bool Server_Player::deleteCounter(int counterId)
 	return true;
 }
 
-void Server_Player::privateEvent(const QString &line)
+void Server_Player::sendProtocolItem(ProtocolItem *item, bool deleteItem)
 {
-/*	if (!socket)
+	if (handler)
-		return;
+		handler->sendProtocolItem(item, deleteItem);
-	socket->msg(QString("private|%1|%2|%3").arg(playerId).arg(playerName).arg(line));
+}
-*/}
-
-void Server_Player::publicEvent(const QString &line, Server_Player *player)
-{
-/*	if (!socket)
-		return;
-	if (player)
-		socket->msg(QString("public|%1|%2|%3").arg(player->getPlayerId()).arg(player->getPlayerName()).arg(line));
-	else
-		socket->msg(QString("public|||%1").arg(line));
-*/}

common/server_player.h

@@ -6,11 +6,12 @@
 #include <QList>
 #include <QMap>
 
-class ServerSocket;
 class Server_Game;
 class Server_CardZone;
 class Server_Counter;
 class Server_Arrow;
+class Server_ProtocolHandler;
+class ProtocolItem;
 
 enum PlayerStatusEnum { StatusNormal, StatusSubmitDeck, StatusReadyStart, StatusPlaying };
 
@@ -18,7 +19,7 @@ class Server_Player : public QObject {
 	Q_OBJECT
 private:
 	Server_Game *game;
-	ServerSocket *socket;
+	Server_ProtocolHandler *handler;
 	QMap<QString, Server_CardZone *> zones;
 	QMap<int, Server_Counter *> counters;
 	QMap<int, Server_Arrow *> arrows;
@@ -34,8 +35,8 @@ public:
 	QList<QString> SideboardList;
 	// Pfusch Ende
 	
-	Server_Player(Server_Game *_game, int _playerId, const QString &_playerName, bool _spectator);
+	Server_Player(Server_Game *_game, int _playerId, const QString &_playerName, bool _spectator, Server_ProtocolHandler *_handler);
-	void setSocket(ServerSocket *_socket) { socket = _socket; }
+	void setProtocolHandler(Server_ProtocolHandler *_handler) { handler = _handler; }
 	
 	void setStatus(PlayerStatusEnum _status) { PlayerStatus = _status; }
 	void setPlayerId(int _id) { playerId = _id; }
@@ -59,8 +60,7 @@ public:
 	
 	void setupZones();
 
-	void privateEvent(const QString &line);
+	void sendProtocolItem(ProtocolItem *item, bool deleteItem = true);
-	void publicEvent(const QString &line, Server_Player *player = 0);
 };
 
 #endif

common/server_protocolhandler.cpp

@@ -1,4 +1,5 @@
 #include <QDebug>
+#include "rng_abstract.h"
 #include "server_protocolhandler.h"
 #include "protocol.h"
 #include "protocol_items.h"
@@ -102,7 +103,7 @@ QPair<Server_Game *, Server_Player *> Server_ProtocolHandler::getGame(int gameId
 	return QPair<Server_Game *, Server_Player *>(0, 0);
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdPing(Command_Ping *cmd)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdPing(Command_Ping * /*cmd*/)
 {
 	return ProtocolResponse::RespOk;
 }
@@ -118,7 +119,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdLogin(Command_Login *c
 	return ProtocolResponse::RespOk;
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdChatListChannels(Command_ChatListChannels *cmd)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdChatListChannels(Command_ChatListChannels * /*cmd*/)
 {
 	Event_ChatListChannels *event = new Event_ChatListChannels;
 	QMapIterator<QString, Server_ChatChannel *> channelIterator(server->getChatChannels());
@@ -142,13 +143,12 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdChatJoinChannel(Comman
 	if (!c)
 		return ProtocolResponse::RespNameNotFound;
 
-	// hier wird irgendwo ein Event erzeugt, das nach dem ok kommen muss -> evtl mit enqueue
 	c->addClient(this);
 	chatChannels.insert(cmd->getChannel(), c);
 	return ProtocolResponse::RespOk;
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdChatLeaveChannel(Command_ChatLeaveChannel *cmd, Server_ChatChannel *channel)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdChatLeaveChannel(Command_ChatLeaveChannel * /*cmd*/, Server_ChatChannel *channel)
 {
 	chatChannels.remove(channel->getName());
 	channel->removeClient(this);
@@ -161,19 +161,32 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdChatSay(Command_ChatSa
 	return ProtocolResponse::RespOk;
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdListGames(Command_ListGames *cmd)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdListGames(Command_ListGames * /*cmd*/)
 {
+	Event_ListGames *event = new Event_ListGames;
 	const QList<Server_Game *> &gameList = server->getGames();
 	for (int i = 0; i < gameList.size(); ++i) {
-//		msg(gameList[i]->getGameListLine());
+		Server_Game *g = gameList[i];
+		event->addGame(
+			g->getGameId(),
+			g->getDescription(),
+			!g->getPassword().isEmpty(),
+			g->getPlayerCount(),
+			g->getMaxPlayers(),
+			g->getCreatorName(),
+			g->getSpectatorsAllowed(),
+			g->getSpectatorCount()
+		);
 	}
+	sendProtocolItem(event);
+	
 	acceptsGameListChanges = true;
 	return ProtocolResponse::RespOk;
 }
 
 ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdCreateGame(Command_CreateGame *cmd)
 {
-	Server_Game *game = server->createGame(cmd->getDescription(), cmd->getPassword(), cmd->getMaxPlayers(), cmd->getSpectatorsAllowed(), playerName);
+	Server_Game *game = server->createGame(cmd->getDescription(), cmd->getPassword(), cmd->getMaxPlayers(), cmd->getSpectatorsAllowed(), this);
 	games.insert(game->getGameId(), QPair<Server_Game *, Server_Player *>(game, game->getCreator()));
 	
 	return ProtocolResponse::RespOk;
@@ -187,13 +200,13 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdJoinGame(Command_JoinG
 	
 	ProtocolResponse::ResponseCode result = g->checkJoin(cmd->getPassword(), cmd->getSpectator());
 	if (result == ProtocolResponse::RespOk) {
-		Server_Player *player = g->addPlayer(playerName, cmd->getSpectator());
+		Server_Player *player = g->addPlayer(this, cmd->getSpectator());
 		games.insert(cmd->getGameId(), QPair<Server_Game *, Server_Player *>(g, player));
 	}
 	return result;
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdLeaveGame(Command_LeaveGame *cmd, Server_Game *game, Server_Player *player)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdLeaveGame(Command_LeaveGame * /*cmd*/, Server_Game *game, Server_Player *player)
 {
 	game->removePlayer(player);
 	return ProtocolResponse::RespOk;
@@ -201,20 +214,20 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdLeaveGame(Command_Leav
 
 ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdSay(Command_Say *cmd, Server_Game *game, Server_Player *player)
 {
-	// XXX
+	game->sendGameEvent(new Event_Say(-1, player->getPlayerId(), cmd->getMessage()));
 	return ProtocolResponse::RespOk;
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdShuffle(Command_Shuffle *cmd, Server_Game *game, Server_Player *player)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdShuffle(Command_Shuffle * /*cmd*/, Server_Game *game, Server_Player *player)
 {
 	player->getZones().value("deck")->shuffle();
-//	game->broadcastEvent("shuffle", player);
+	game->sendGameEvent(new Event_Shuffle(-1, player->getPlayerId()));
 	return ProtocolResponse::RespOk;
 }
 
 ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdRollDie(Command_RollDie *cmd, Server_Game *game, Server_Player *player)
 {
-//	game->broadcastEvent(QString("roll_die|%1|%2").arg(sides).arg(rng->getNumber(1, sides)), player);
+	game->sendGameEvent(new Event_RollDie(-1, player->getPlayerId(), cmd->getSides(), rng->getNumber(1, cmd->getSides())));
 	return ProtocolResponse::RespOk;
 }
 
@@ -337,7 +350,6 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdMoveCard(Command_MoveC
 
 ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdCreateToken(Command_CreateToken *cmd, Server_Game *game, Server_Player *player)
 {
-	// zone, cardname, powtough, x, y
 	// powtough wird erst mal ignoriert
 	Server_CardZone *zone = player->getZones().value(cmd->getZone());
 	if (!zone)
@@ -345,13 +357,9 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdCreateToken(Command_Cr
 
 	Server_Card *card = new Server_Card(cmd->getCardName(), player->newCardId(), cmd->getX(), cmd->getY());
 	zone->insertCard(card, cmd->getX(), cmd->getY());
-/*	game->broadcastEvent(QString("create_token|%1|%2|%3|%4|%5|%6").arg(zone->getName())
+	game->sendGameEvent(new Event_CreateToken(-1, player->getPlayerId(), zone->getName(), card->getId(), card->getName(), cmd->getPt(), cmd->getX(), cmd->getY()));
-									 .arg(cardid)
+	
-									 .arg(cardname)
+	return ProtocolResponse::RespOk;
-									 .arg(powtough)
-									 .arg(x)
-									 .arg(y), player);
-*/	return ProtocolResponse::RespOk;
 }
 
 ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Server_Game *game, Server_Player *player)
@@ -377,17 +385,19 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_Cr
 
 	Server_Arrow *arrow = new Server_Arrow(player->newArrowId(), startCard, targetCard, cmd->getColor());
 	player->addArrow(arrow);
-/*	game->broadcastEvent(QString("create_arrow|%1|%2|%3|%4|%5|%6|%7|%8")
+	game->sendGameEvent(new Event_CreateArrow(
-		.arg(arrow->getId())
+		-1,
-		.arg(startPlayer->getPlayerId())
+		player->getPlayerId(),
-		.arg(startZone->getName())
+		arrow->getId(),
-		.arg(startCard->getId())
+		startPlayer->getPlayerId(),
-		.arg(targetPlayer->getPlayerId())
+		startZone->getName(),
-		.arg(targetZone->getName())
+		startCard->getId(),
-		.arg(targetCard->getId())
+		targetPlayer->getPlayerId(),
-		.arg(cmd->getColor()), player
+		targetZone->getName(),
-	);
+		targetCard->getId(),
-*/	return ProtocolResponse::RespOk;
+		cmd->getColor()
+	));
+	return ProtocolResponse::RespOk;
 }
 
 ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdDeleteArrow(Command_DeleteArrow *cmd, Server_Game *game, Server_Player *player)
@@ -395,7 +405,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdDeleteArrow(Command_De
 	if (!player->deleteArrow(cmd->getArrowId()))
 		return ProtocolResponse::RespNameNotFound;
 	
-//	game->broadcastEvent(QString("delete_arrow|%1").arg(arrowId), player);
+	game->sendGameEvent(new Event_DeleteArrow(-1, player->getPlayerId(), cmd->getArrowId()));
 	return ProtocolResponse::RespOk;
 }
 
@@ -419,14 +429,14 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdSetCardAttr(Command_Se
 		if (!card->setAttribute(cmd->getAttrName(), cmd->getAttrValue(), false))
 			return ProtocolResponse::RespInvalidCommand;
 	}
-//	game->broadcastEvent(QString("set_card_attr|%1|%2|%3|%4").arg(zone->getName()).arg(cardid).arg(aname).arg(avalue), player);
+	game->sendGameEvent(new Event_SetCardAttr(-1, player->getPlayerId(), zone->getName(), cmd->getCardId(), cmd->getAttrName(), cmd->getAttrValue()));
 	return ProtocolResponse::RespOk;
 }
 
-ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdReadyStart(Command_ReadyStart *cmd, Server_Game *game, Server_Player *player)
+ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdReadyStart(Command_ReadyStart * /*cmd*/, Server_Game *game, Server_Player *player)
 {
 	player->setStatus(StatusReadyStart);
-//	game->broadcastEvent(QString("ready_start"), player);
+	game->sendGameEvent(new Event_ReadyStart(-1, player->getPlayerId()));
 	game->startGameIfReady();
 	return ProtocolResponse::RespOk;
 }
@@ -439,7 +449,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdIncCounter(Command_Inc
 		return ProtocolResponse::RespNameNotFound;
 	
 	c->setCount(c->getCount() + cmd->getDelta());
-//	game->broadcastEvent(QString("set_counter|%1|%2").arg(c->getId()).arg(c->getCount()), player);
+	game->sendGameEvent(new Event_SetCounter(-1, player->getPlayerId(), c->getId(), c->getCount()));
 	return ProtocolResponse::RespOk;
 }
 
@@ -447,7 +457,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdAddCounter(Command_Add
 {
 	Server_Counter *c = new Server_Counter(player->newCounterId(), cmd->getCounterName(), cmd->getColor(), cmd->getRadius(), cmd->getValue());
 	player->addCounter(c);
-//	game->broadcastEvent(QString("add_counter|%1|%2|%3|%4|%5").arg(c->getId()).arg(c->getName()).arg(color).arg(radius).arg(count), player);
+	game->sendGameEvent(new Event_AddCounter(-1, player->getPlayerId(), c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount()));
 	
 	return ProtocolResponse::RespOk;
 }
@@ -459,7 +469,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdSetCounter(Command_Set
 		return ProtocolResponse::RespNameNotFound;
 	
 	c->setCount(cmd->getValue());
-//	game->broadcastEvent(QString("set_counter|%1|%2").arg(c->getId()).arg(count), player);
+	game->sendGameEvent(new Event_SetCounter(-1, player->getPlayerId(), c->getId(), c->getCount()));
 	return ProtocolResponse::RespOk;
 }
 
@@ -467,7 +477,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdDelCounter(Command_Del
 {
 	if (!player->deleteCounter(cmd->getCounterId()))
 		return ProtocolResponse::RespNameNotFound;
-//	game->broadcastEvent(QString("del_counter|%1").arg(counterId), player);
+	game->sendGameEvent(new Event_DelCounter(-1, player->getPlayerId(), cmd->getCounterId()));
 	return ProtocolResponse::RespOk;
 }
 
@@ -518,7 +528,7 @@ ProtocolResponse::ResponseCode Server_ProtocolHandler::cmdStopDumpZone(Command_S
 	
 	if (zone->getType() == Server_CardZone::HiddenZone) {
 		zone->setCardsBeingLookedAt(0);
-//		game->broadcastEvent(QString("stop_dump_zone|%1|%2").arg(otherPlayer->getPlayerId()).arg(zone->getName()), player);
+		game->sendGameEvent(new Event_StopDumpZone(-1, player->getPlayerId(), cmd->getPlayerId(), zone->getName()));
 	}
 	return ProtocolResponse::RespOk;
 }