aly/servatrice
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Reduce the whitespace in the server game constructor.

Browse source
This commit is contained in:
Jeffrey Oliver 2015-02-03 22:22:31 -08:00
parent bd39d60388
commit 843cd9718e
1 changed files with 81 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

162
common/server_game.cpp
View file

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