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),
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());