Merge pull request #671 from kaiserfro/jo-reduce-whitespace-from-game-description

Reduce the game descriptions whitespace.

cockatrice/src/dlg_creategame.cpp

@@ -31,13 +31,13 @@ void DlgCreateGame::sharedCtor()
     maxPlayersEdit->setMaximum(100);
     maxPlayersEdit->setValue(2);
     maxPlayersLabel->setBuddy(maxPlayersEdit);
-    
+
     QGridLayout *generalGrid = new QGridLayout;
     generalGrid->addWidget(descriptionLabel, 0, 0);
     generalGrid->addWidget(descriptionEdit, 0, 1);
     generalGrid->addWidget(maxPlayersLabel, 1, 0);
     generalGrid->addWidget(maxPlayersEdit, 1, 1);
-    
+
     QVBoxLayout *gameTypeLayout = new QVBoxLayout;
     QMapIterator<int, QString> gameTypeIterator(gameTypes);
     while (gameTypeIterator.hasNext()) {
@@ -48,7 +48,7 @@ void DlgCreateGame::sharedCtor()
     }
     QGroupBox *gameTypeGroupBox = new QGroupBox(tr("Game type"));
     gameTypeGroupBox->setLayout(gameTypeLayout);
-    
+
     passwordLabel = new QLabel(tr("&Password:"));
     passwordEdit = new QLineEdit;
     passwordLabel->setBuddy(passwordEdit);
@@ -60,18 +60,18 @@ void DlgCreateGame::sharedCtor()
         onlyRegisteredCheckBox->setChecked(true);
     } else {
         onlyBuddiesCheckBox->setEnabled(false);
-        onlyRegisteredCheckBox->setEnabled(false);        
+        onlyRegisteredCheckBox->setEnabled(false);
     }
-    
+
     QGridLayout *joinRestrictionsLayout = new QGridLayout;
     joinRestrictionsLayout->addWidget(passwordLabel, 0, 0);
     joinRestrictionsLayout->addWidget(passwordEdit, 0, 1);
     joinRestrictionsLayout->addWidget(onlyBuddiesCheckBox, 1, 0, 1, 2);
     joinRestrictionsLayout->addWidget(onlyRegisteredCheckBox, 2, 0, 1, 2);
-    
+
     QGroupBox *joinRestrictionsGroupBox = new QGroupBox(tr("Joining restrictions"));
     joinRestrictionsGroupBox->setLayout(joinRestrictionsLayout);
-    
+
     spectatorsAllowedCheckBox = new QCheckBox(tr("&Spectators allowed"));
     spectatorsAllowedCheckBox->setChecked(true);
     connect(spectatorsAllowedCheckBox, SIGNAL(stateChanged(int)), this, SLOT(spectatorsAllowedChanged(int)));
@@ -94,7 +94,7 @@ void DlgCreateGame::sharedCtor()
 
     buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok);
     connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
-    
+
     QVBoxLayout *mainLayout = new QVBoxLayout;
     mainLayout->addLayout(grid);
     mainLayout->addWidget(buttonBox);
@@ -108,10 +108,10 @@ DlgCreateGame::DlgCreateGame(TabRoom *_room, const QMap<int, QString> &_gameType
     : QDialog(parent), room(_room), gameTypes(_gameTypes)
 {
     sharedCtor();
-    
+
     buttonBox->addButton(QDialogButtonBox::Cancel);
     connect(buttonBox, SIGNAL(accepted()), this, SLOT(actOK()));
-    
+
     setWindowTitle(tr("Create game"));
 }
 
@@ -119,7 +119,7 @@ DlgCreateGame::DlgCreateGame(const ServerInfo_Game &gameInfo, const QMap<int, QS
     : QDialog(parent), room(0), gameTypes(_gameTypes)
 {
     sharedCtor();
-    
+
     descriptionEdit->setEnabled(false);
     maxPlayersEdit->setEnabled(false);
     passwordEdit->setEnabled(false);
@@ -129,7 +129,7 @@ DlgCreateGame::DlgCreateGame(const ServerInfo_Game &gameInfo, const QMap<int, QS
     spectatorsNeedPasswordCheckBox->setEnabled(false);
     spectatorsCanTalkCheckBox->setEnabled(false);
     spectatorsSeeEverythingCheckBox->setEnabled(false);
-    
+
     descriptionEdit->setText(QString::fromStdString(gameInfo.description()));
     maxPlayersEdit->setValue(gameInfo.max_players());
     onlyBuddiesCheckBox->setChecked(gameInfo.only_buddies());
@@ -138,29 +138,29 @@ DlgCreateGame::DlgCreateGame(const ServerInfo_Game &gameInfo, const QMap<int, QS
     spectatorsNeedPasswordCheckBox->setChecked(gameInfo.spectators_need_password());
     spectatorsCanTalkCheckBox->setChecked(gameInfo.spectators_can_chat());
     spectatorsSeeEverythingCheckBox->setChecked(gameInfo.spectators_omniscient());
-    
+
     QSet<int> types;
     for (int i = 0; i < gameInfo.game_types_size(); ++i)
         types.insert(gameInfo.game_types(i));
-    
+
     QMapIterator<int, QString> gameTypeIterator(gameTypes);
     while (gameTypeIterator.hasNext()) {
         gameTypeIterator.next();
-        
+
         QCheckBox *gameTypeCheckBox = gameTypeCheckBoxes.value(gameTypeIterator.key());
         gameTypeCheckBox->setEnabled(false);
         gameTypeCheckBox->setChecked(types.contains(gameTypeIterator.key()));
     }
-    
+
     connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
-    
+
     setWindowTitle(tr("Game information"));
 }
 
 void DlgCreateGame::actOK()
 {
     Command_CreateGame cmd;
-    cmd.set_description(descriptionEdit->text().toStdString());
+    cmd.set_description(descriptionEdit->text().simplified().toStdString());
     cmd.set_password(passwordEdit->text().toStdString());
     cmd.set_max_players(maxPlayersEdit->value());
     cmd.set_only_buddies(onlyBuddiesCheckBox->isChecked());
@@ -169,18 +169,18 @@ void DlgCreateGame::actOK()
     cmd.set_spectators_need_password(spectatorsNeedPasswordCheckBox->isChecked());
     cmd.set_spectators_can_talk(spectatorsCanTalkCheckBox->isChecked());
     cmd.set_spectators_see_everything(spectatorsSeeEverythingCheckBox->isChecked());
-    
+
     QMapIterator<int, QCheckBox *> gameTypeCheckBoxIterator(gameTypeCheckBoxes);
     while (gameTypeCheckBoxIterator.hasNext()) {
         gameTypeCheckBoxIterator.next();
         if (gameTypeCheckBoxIterator.value()->isChecked())
             cmd.add_game_type_ids(gameTypeCheckBoxIterator.key());
     }
-    
+
     PendingCommand *pend = room->prepareRoomCommand(cmd);
     connect(pend, SIGNAL(finished(Response, CommandContainer, QVariant)), this, SLOT(checkResponse(Response)));
     room->sendRoomCommand(pend);
-    
+
     buttonBox->setEnabled(false);
 }
 

common/server_game.cpp

@@ -56,7 +56,6 @@ Server_Game::Server_Game(const ServerInfo_User &_creatorInfo, int _gameId, const
           gameStarted(false),
           gameClosed(false),
           gameId(_gameId),
-          description(_description),
           password(_password),
           maxPlayers(_maxPlayers),
           gameTypes(_gameTypes),
@@ -77,9 +76,10 @@ Server_Game::Server_Game(const ServerInfo_User &_creatorInfo, int _gameId, const
 {
     currentReplay = new GameReplay;
     currentReplay->set_replay_id(room->getServer()->getDatabaseInterface()->getNextReplayId());
-    
+    description = _description.simplified();
+
     connect(this, SIGNAL(sigStartGameIfReady()), this, SLOT(doStartGameIfReady()), Qt::QueuedConnection);
-    
+
     getInfo(*currentReplay->mutable_game_info());
 
     if (room->getServer()->getGameShouldPing()) {
@@ -93,36 +93,36 @@ Server_Game::~Server_Game()
 {
     room->gamesLock.lockForWrite();
     gameMutex.lock();
-    
+
     gameClosed = true;
     sendGameEventContainer(prepareGameEvent(Event_GameClosed(), -1));
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext())
         playerIterator.next().value()->prepareDestroy();
     players.clear();
-    
+
     room->removeGame(this);
     delete creatorInfo;
     creatorInfo = 0;
-    
+
     gameMutex.unlock();
     room->gamesLock.unlock();
-    
+
     currentReplay->set_duration_seconds(secondsElapsed - startTimeOfThisGame);
     replayList.append(currentReplay);
     storeGameInformation();
-    
+
     for (int i = 0; i < replayList.size(); ++i)
         delete replayList[i];
-    
+
     qDebug() << "Server_Game destructor: gameId=" << gameId;
 }
 
 void Server_Game::storeGameInformation()
 {
     const ServerInfo_Game &gameInfo = replayList.first()->game_info();
-    
+
     Event_ReplayAdded replayEvent;
     ServerInfo_ReplayMatch *replayMatchInfo = replayEvent.mutable_match_info();
     replayMatchInfo->set_game_id(gameInfo.game_id());
@@ -130,26 +130,26 @@ void Server_Game::storeGameInformation()
     replayMatchInfo->set_time_started(QDateTime::currentDateTime().addSecs(-secondsElapsed).toTime_t());
     replayMatchInfo->set_length(secondsElapsed);
     replayMatchInfo->set_game_name(gameInfo.description());
-    
+
     const QStringList &allGameTypes = room->getGameTypes();
     QStringList gameTypes;
     for (int i = gameInfo.game_types_size() - 1; i >= 0; --i)
         gameTypes.append(allGameTypes[gameInfo.game_types(i)]);
-    
+
     QSetIterator<QString> playerIterator(allPlayersEver);
     while (playerIterator.hasNext())
         replayMatchInfo->add_player_names(playerIterator.next().toStdString());
-    
+
     for (int i = 0; i < replayList.size(); ++i) {
         ServerInfo_Replay *replayInfo = replayMatchInfo->add_replay_list();
         replayInfo->set_replay_id(replayList[i]->replay_id());
         replayInfo->set_replay_name(gameInfo.description());
         replayInfo->set_duration(replayList[i]->duration_seconds());
     }
-    
+
     QSet<QString> allUsersInGame = allPlayersEver + allSpectatorsEver;
     QSetIterator<QString> allUsersIterator(allUsersInGame);
-    
+
     SessionEvent *sessionEvent = Server_ProtocolHandler::prepareSessionEvent(replayEvent);
     Server *server = room->getServer();
     server->clientsLock.lockForRead();
@@ -160,7 +160,7 @@ void Server_Game::storeGameInformation()
     }
     server->clientsLock.unlock();
     delete sessionEvent;
-    
+
     server->getDatabaseInterface()->storeGameInformation(room->getName(), gameTypes, gameInfo, allPlayersEver, allSpectatorsEver, replayList);
 }
 
@@ -168,10 +168,10 @@ void Server_Game::pingClockTimeout()
 {
     QMutexLocker locker(&gameMutex);
     ++secondsElapsed;
-    
+
     GameEventStorage ges;
     ges.setGameEventContext(Context_PingChanged());
-    
+
     QList<ServerInfo_PlayerPing *> pingList;
     QMapIterator<int, Server_Player *> playerIterator(players);
     bool allPlayersInactive = true;
@@ -180,7 +180,7 @@ void Server_Game::pingClockTimeout()
         Server_Player *player = playerIterator.next().value();
         if (!player->getSpectator())
             ++playerCount;
-        
+
         const int oldPingTime = player->getPingTime();
         player->playerMutex.lock();
         int newPingTime;
@@ -189,20 +189,20 @@ void Server_Game::pingClockTimeout()
         else
             newPingTime = -1;
         player->playerMutex.unlock();
-        
+
         if ((newPingTime != -1) && !player->getSpectator())
             allPlayersInactive = false;
-        
+
         if ((abs(oldPingTime - newPingTime) > 1) || ((newPingTime == -1) && (oldPingTime != -1)) || ((newPingTime != -1) && (oldPingTime == -1))) {
             player->setPingTime(newPingTime);
-            
+
             Event_PlayerPropertiesChanged event;
             event.mutable_player_properties()->set_ping_seconds(newPingTime);
             ges.enqueueGameEvent(event, player->getPlayerId());
         }
     }
     ges.sendToGame(this);
-    
+
     const int maxTime = room->getServer()->getMaxGameInactivityTime();
     if (allPlayersInactive) {
         if (((++inactivityCounter >= maxTime) && (maxTime > 0)) || (playerCount < maxPlayers))
@@ -214,7 +214,7 @@ void Server_Game::pingClockTimeout()
 int Server_Game::getPlayerCount() const
 {
     QMutexLocker locker(&gameMutex);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     int result = 0;
     while (playerIterator.hasNext())
@@ -226,7 +226,7 @@ int Server_Game::getPlayerCount() const
 int Server_Game::getSpectatorCount() const
 {
     QMutexLocker locker(&gameMutex);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     int result = 0;
     while (playerIterator.hasNext())
@@ -244,7 +244,7 @@ void Server_Game::createGameStateChangedEvent(Event_GameStateChanged *event, Ser
         event->set_active_phase(0);
     } else
         event->set_game_started(false);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext())
         playerIterator.next().value()->getInfo(event->add_player_list(), playerWhosAsking, omniscient, withUserInfo);
@@ -255,13 +255,13 @@ void Server_Game::sendGameStateToPlayers()
     // game state information for replay and omniscient spectators
     Event_GameStateChanged omniscientEvent;
     createGameStateChangedEvent(&omniscientEvent, 0, true, false);
-    
+
     GameEventContainer *replayCont = prepareGameEvent(omniscientEvent, -1);
     replayCont->set_seconds_elapsed(secondsElapsed - startTimeOfThisGame);
     replayCont->clear_game_id();
     currentReplay->add_event_list()->CopyFrom(*replayCont);
     delete replayCont;
-    
+
     // If spectators are not omniscient, we need an additional createGameStateChangedEvent call, otherwise we can use the data we used for the replay.
     // All spectators are equal, so we don't need to make a createGameStateChangedEvent call for each one.
     Event_GameStateChanged spectatorEvent;
@@ -269,7 +269,7 @@ void Server_Game::sendGameStateToPlayers()
         spectatorEvent = omniscientEvent;
     else
         createGameStateChangedEvent(&spectatorEvent, 0, false, false);
-    
+
     // send game state info to clients according to their role in the game
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext()) {
@@ -280,7 +280,7 @@ void Server_Game::sendGameStateToPlayers()
         else {
             Event_GameStateChanged event;
             createGameStateChangedEvent(&event, player, false, false);
-            
+
             gec = prepareGameEvent(event, -1);
         }
         player->sendGameEvent(*gec);
@@ -292,7 +292,7 @@ void Server_Game::doStartGameIfReady()
 {
     Server_DatabaseInterface *databaseInterface = room->getServer()->getDatabaseInterface();
     QMutexLocker locker(&gameMutex);
-    
+
     if (getPlayerCount() < maxPlayers)
         return;
     QMapIterator<int, Server_Player *> playerIterator(players);
@@ -315,7 +315,7 @@ void Server_Game::doStartGameIfReady()
         player->setConceded(false);
         player->setReadyStart(false);
     }
-    
+
     if (firstGameStarted) {
         currentReplay->set_duration_seconds(secondsElapsed - startTimeOfThisGame);
         replayList.append(currentReplay);
@@ -324,27 +324,27 @@ void Server_Game::doStartGameIfReady()
         ServerInfo_Game *gameInfo = currentReplay->mutable_game_info();
         getInfo(*gameInfo);
         gameInfo->set_started(false);
-        
+
         Event_GameStateChanged omniscientEvent;
         createGameStateChangedEvent(&omniscientEvent, 0, true, true);
-        
+
         GameEventContainer *replayCont = prepareGameEvent(omniscientEvent, -1);
         replayCont->set_seconds_elapsed(0);
         replayCont->clear_game_id();
         currentReplay->add_event_list()->CopyFrom(*replayCont);
         delete replayCont;
-        
+
         startTimeOfThisGame = secondsElapsed;
     } else
         firstGameStarted = true;
-    
+
     sendGameStateToPlayers();
-    
+
     activePlayer = -1;
     nextTurn();
-    
+
     locker.unlock();
-    
+
     ServerInfo_Game gameInfo;
     gameInfo.set_room_id(room->getId());
     gameInfo.set_game_id(gameId);
@@ -360,7 +360,7 @@ void Server_Game::startGameIfReady()
 void Server_Game::stopGameIfFinished()
 {
     QMutexLocker locker(&gameMutex);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     int playing = 0;
     while (playerIterator.hasNext()) {
@@ -381,9 +381,9 @@ void Server_Game::stopGameIfFinished()
     }
 
     sendGameStateToPlayers();
-    
+
     locker.unlock();
-    
+
     ServerInfo_Game gameInfo;
     gameInfo.set_room_id(room->getId());
     gameInfo.set_game_id(gameId);
@@ -417,14 +417,14 @@ Response::ResponseCode Server_Game::checkJoin(ServerInfo_User *user, const QStri
     }
     if (!spectator && (gameStarted || (getPlayerCount() >= getMaxPlayers())))
         return Response::RespGameFull;
-    
+
     return Response::RespOk;
 }
 
 bool Server_Game::containsUser(const QString &userName) const
 {
     QMutexLocker locker(&gameMutex);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext())
         if (playerIterator.next().value()->getUserInfo()->name() == userName.toStdString())
@@ -435,14 +435,14 @@ bool Server_Game::containsUser(const QString &userName) const
 void Server_Game::addPlayer(Server_AbstractUserInterface *userInterface, ResponseContainer &rc, bool spectator, bool broadcastUpdate)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     Server_Player *newPlayer = new Server_Player(this, nextPlayerId++, userInterface->copyUserInfo(true, true, true), spectator, userInterface);
     newPlayer->moveToThread(thread());
-    
+
     Event_Join joinEvent;
     newPlayer->getProperties(*joinEvent.mutable_player_properties(), true);
     sendGameEventContainer(prepareGameEvent(joinEvent, -1));
-    
+
     const QString playerName = QString::fromStdString(newPlayer->getUserInfo()->name());
     if (spectator)
         allSpectatorsEver.insert(playerName);
@@ -453,7 +453,7 @@ void Server_Game::addPlayer(Server_AbstractUserInterface *userInterface, Respons
         hostId = newPlayer->getPlayerId();
         sendGameEventContainer(prepareGameEvent(Event_GameHostChanged(), hostId));
     }
-    
+
     if (broadcastUpdate) {
         ServerInfo_Game gameInfo;
         gameInfo.set_room_id(room->getId());
@@ -462,12 +462,12 @@ void Server_Game::addPlayer(Server_AbstractUserInterface *userInterface, Respons
         gameInfo.set_spectators_count(getSpectatorCount());
         emit gameInfoChanged(gameInfo);
     }
-    
+
     if ((newPlayer->getUserInfo()->user_level() & ServerInfo_User::IsRegistered) && !spectator)
         room->getServer()->addPersistentPlayer(playerName, room->getId(), gameId, newPlayer->getPlayerId());
-    
+
     userInterface->playerAddedToGame(gameId, room->getId(), newPlayer->getPlayerId());
-    
+
     createGameJoinedEvent(newPlayer, rc, false);
 }
 
@@ -475,18 +475,18 @@ void Server_Game::removePlayer(Server_Player *player)
 {
     room->getServer()->removePersistentPlayer(QString::fromStdString(player->getUserInfo()->name()), room->getId(), gameId, player->getPlayerId());
     players.remove(player->getPlayerId());
-    
+
     GameEventStorage ges;
     removeArrowsRelatedToPlayer(ges, player);
     unattachCards(ges, player);
     ges.enqueueGameEvent(Event_Leave(), player->getPlayerId());
     ges.sendToGame(this);
-    
+
     bool playerActive = activePlayer == player->getPlayerId();
     bool playerHost = hostId == player->getPlayerId();
     bool spectator = player->getSpectator();
     player->prepareDestroy();
-    
+
     if (!getPlayerCount()) {
         gameClosed = true;
         deleteLater();
@@ -511,7 +511,7 @@ void Server_Game::removePlayer(Server_Player *player)
         if (gameStarted && playerActive)
             nextTurn();
     }
-    
+
     ServerInfo_Game gameInfo;
     gameInfo.set_room_id(room->getId());
     gameInfo.set_game_id(gameId);
@@ -523,7 +523,7 @@ void Server_Game::removePlayer(Server_Player *player)
 void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Player *player)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     // Remove all arrows of other players pointing to the player being removed or to one of his cards.
     // Also remove all arrows starting at one of his cards. This is necessary since players can create
     // arrows that start at another person's cards.
@@ -540,7 +540,7 @@ void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Play
                     toDelete.append(a);
             } else if (static_cast<Server_Player *>(a->getTargetItem()) == player)
                 toDelete.append(a);
-            
+
             // Don't use else here! It has to happen regardless of whether targetCard == 0.
             if (a->getStartCard()->getZone()->getPlayer() == player)
                 toDelete.append(a);
@@ -549,7 +549,7 @@ void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Play
             Event_DeleteArrow event;
             event.set_arrow_id(toDelete[i]->getId());
             ges.enqueueGameEvent(event, p->getPlayerId());
-            
+
             p->deleteArrow(toDelete[i]->getId());
         }
     }
@@ -558,13 +558,13 @@ void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Play
 void Server_Game::unattachCards(GameEventStorage &ges, Server_Player *player)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     QMapIterator<QString, Server_CardZone *> zoneIterator(player->getZones());
     while (zoneIterator.hasNext()) {
         Server_CardZone *zone = zoneIterator.next().value();
         for (int i = 0; i < zone->getCards().size(); ++i) {
             Server_Card *card = zone->getCards().at(i);
-            
+
             // Make a copy of the list because the original one gets modified during the loop
             QList<Server_Card *> attachedCards = card->getAttachedCards();
             for (int i = 0; i < attachedCards.size(); ++i)
@@ -576,54 +576,54 @@ void Server_Game::unattachCards(GameEventStorage &ges, Server_Player *player)
 bool Server_Game::kickPlayer(int playerId)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     Server_Player *playerToKick = players.value(playerId);
     if (!playerToKick)
         return false;
-    
+
     GameEventContainer *gec = prepareGameEvent(Event_Kicked(), -1);
     playerToKick->sendGameEvent(*gec);
     delete gec;
-    
+
     removePlayer(playerToKick);
-    
+
     return true;
 }
 
 void Server_Game::setActivePlayer(int _activePlayer)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     activePlayer = _activePlayer;
-    
+
     Event_SetActivePlayer event;
     event.set_active_player_id(activePlayer);
     sendGameEventContainer(prepareGameEvent(event, -1));
-    
+
     setActivePhase(0);
 }
 
 void Server_Game::setActivePhase(int _activePhase)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext()) {
         Server_Player *player = playerIterator.next().value();
         QList<Server_Arrow *> toDelete = player->getArrows().values();
         for (int i = 0; i < toDelete.size(); ++i) {
             Server_Arrow *a = toDelete[i];
-            
+
             Event_DeleteArrow event;
             event.set_arrow_id(a->getId());
             sendGameEventContainer(prepareGameEvent(event, player->getPlayerId()));
-            
+
             player->deleteArrow(a->getId());
         }
     }
-    
+
     activePhase = _activePhase;
-    
+
     Event_SetActivePhase event;
     event.set_phase(activePhase);
     sendGameEventContainer(prepareGameEvent(event, -1));
@@ -632,7 +632,7 @@ void Server_Game::setActivePhase(int _activePhase)
 void Server_Game::nextTurn()
 {
     QMutexLocker locker(&gameMutex);
-    
+
     const QList<int> keys = players.keys();
     int listPos = -1;
     if (activePlayer != -1)
@@ -642,7 +642,7 @@ void Server_Game::nextTurn()
         if (listPos == keys.size())
             listPos = 0;
     } while (players.value(keys[listPos])->getSpectator() || players.value(keys[listPos])->getConceded());
-    
+
     setActivePlayer(keys[listPos]);
 }
 
@@ -663,13 +663,13 @@ void Server_Game::createGameJoinedEvent(Server_Player *player, ResponseContainer
         }
     }
     rc.enqueuePostResponseItem(ServerMessage::SESSION_EVENT, Server_AbstractUserInterface::prepareSessionEvent(event1));
-    
+
     Event_GameStateChanged event2;
     event2.set_seconds_elapsed(secondsElapsed);
     event2.set_game_started(gameStarted);
     event2.set_active_player_id(activePlayer);
     event2.set_active_phase(activePhase);
-    
+
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext())
         playerIterator.next().value()->getInfo(event2.add_player_list(), player, player->getSpectator() && spectatorsSeeEverything, true);
@@ -680,7 +680,7 @@ void Server_Game::createGameJoinedEvent(Server_Player *player, ResponseContainer
 void Server_Game::sendGameEventContainer(GameEventContainer *cont, GameEventStorageItem::EventRecipients recipients, int privatePlayerId)
 {
     QMutexLocker locker(&gameMutex);
-    
+
     cont->set_game_id(gameId);
     QMapIterator<int, Server_Player *> playerIterator(players);
     while (playerIterator.hasNext()) {
@@ -694,7 +694,7 @@ void Server_Game::sendGameEventContainer(GameEventContainer *cont, GameEventStor
         cont->clear_game_id();
         currentReplay->add_event_list()->CopyFrom(*cont);
     }
-    
+
     delete cont;
 }
 
@@ -714,7 +714,7 @@ GameEventContainer *Server_Game::prepareGameEvent(const ::google::protobuf::Mess
 void Server_Game::getInfo(ServerInfo_Game &result) const
 {
     QMutexLocker locker(&gameMutex);
-    
+
     result.set_room_id(room->getId());
     result.set_game_id(gameId);
     if (gameClosed)
@@ -722,7 +722,7 @@ void Server_Game::getInfo(ServerInfo_Game &result) const
     else {
         for (int i = 0; i < gameTypes.size(); ++i)
             result.add_game_types(gameTypes[i]);
-        
+
         result.set_max_players(getMaxPlayers());
         result.set_description(getDescription().toStdString());
         result.set_with_password(!getPassword().isEmpty());