Renaming class ServerGameThread to ServerGame.

src/net/common/servergame.cpp

@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2007 by Lothar May                                      *
+ *   Copyright (C) 2007-2009 by Lothar May                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -38,7 +38,7 @@
 using namespace std;
 
 
-ServerGameThread::ServerGameThread(ServerLobbyThread &lobbyThread, u_int32_t id, const string &name, const string &pwd, const GameData &gameData, unsigned adminPlayerId, GuiInterface &gui, ConfigFile *playerConfig)
+ServerGame::ServerGame(ServerLobbyThread &lobbyThread, u_int32_t id, const string &name, const string &pwd, const GameData &gameData, unsigned adminPlayerId, GuiInterface &gui, ConfigFile *playerConfig)
 : m_adminPlayerId(adminPlayerId), m_lobbyThread(lobbyThread), m_gui(gui),
   m_gameData(gameData), m_curState(NULL), m_id(id), m_name(name), m_password(pwd), m_playerConfig(playerConfig),
   m_gameNum(1), m_curPetitionId(1), m_stateTimerId(0)
@@ -49,13 +49,13 @@ ServerGameThread::ServerGameThread(ServerLobbyThread &lobbyThread, u_int32_t id,
 
 	m_voteKickTimerId = GetLobbyThread().GetTimerManager().RegisterTimer(
 		SERVER_CHECK_VOTE_KICK_INTERVAL_MSEC,
-		boost::bind(&ServerGameThread::TimerVoteKick, this),
+		boost::bind(&ServerGame::TimerVoteKick, this),
 		true);
 
 	SetState(SERVER_INITIAL_STATE::Instance());
 }
 
-ServerGameThread::~ServerGameThread()
+ServerGame::~ServerGame()
 {
 	GetLobbyThread().GetTimerManager().UnregisterTimer(m_removePlayerTimerId);
 	GetLobbyThread().GetTimerManager().UnregisterTimer(m_voteKickTimerId);
@@ -65,26 +65,26 @@ ServerGameThread::~ServerGameThread()
 }
 
 u_int32_t
-ServerGameThread::GetId() const
+ServerGame::GetId() const
 {
 	return m_id;
 }
 
 const std::string &
-ServerGameThread::GetName() const
+ServerGame::GetName() const
 {
 	return m_name;
 }
 
 void
-ServerGameThread::AddSession(SessionWrapper session)
+ServerGame::AddSession(SessionWrapper session)
 {
 	if (session.sessionData)
 		GetState().HandleNewSession(*this, session);
 }
 
 void
-ServerGameThread::RemovePlayer(unsigned playerId, unsigned errorCode)
+ServerGame::RemovePlayer(unsigned playerId, unsigned errorCode)
 {
 	SessionWrapper tmpSession = GetSessionManager().GetSessionByUniquePlayerId(playerId);
 	// Only kick if the player was found.
@@ -93,26 +93,26 @@ ServerGameThread::RemovePlayer(unsigned playerId, unsigned errorCode)
 }
 
 void
-ServerGameThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+ServerGame::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
 	if (session.sessionData && packet)
 		GetState().ProcessPacket(*this, session, packet);
 }
 
 GameState
-ServerGameThread::GetCurRound() const
+ServerGame::GetCurRound() const
 {
 	return static_cast<GameState>(GetGame().getCurrentHand()->getCurrentRound());
 }
 
 void
-ServerGameThread::SendToAllPlayers(boost::shared_ptr<NetPacket> packet, SessionData::State state)
+ServerGame::SendToAllPlayers(boost::shared_ptr<NetPacket> packet, SessionData::State state)
 {
 	GetSessionManager().SendToAllSessions(packet, state);
 }
 
 void
-ServerGameThread::RemoveAllSessions()
+ServerGame::RemoveAllSessions()
 {
 	// Called from lobby thread.
 	// Clean up ALL sessions which are left.
@@ -120,7 +120,7 @@ ServerGameThread::RemoveAllSessions()
 }
 
 void
-ServerGameThread::TimerVoteKick()
+ServerGame::TimerVoteKick()
 {
 	// Check whether someone should be kicked, or whether a vote kick should be aborted.
 	// Only one vote kick can be active at a time.
@@ -191,7 +191,7 @@ ServerGameThread::TimerVoteKick()
 }
 
 void
-ServerGameThread::InternalStartGame()
+ServerGame::InternalStartGame()
 {
 	// Set order of players.
 	AssignPlayerNumbers();
@@ -235,13 +235,13 @@ ServerGameThread::InternalStartGame()
 }
 
 void
-ServerGameThread::ResetGame()
+ServerGame::ResetGame()
 {
 	m_game.reset();
 }
 
 void
-ServerGameThread::InternalKickPlayer(unsigned playerId)
+ServerGame::InternalKickPlayer(unsigned playerId)
 {
 	SessionWrapper tmpSession = GetSessionManager().GetSessionByUniquePlayerId(playerId);
 	// Only kick if the player was found.
@@ -258,7 +258,7 @@ ServerGameThread::InternalKickPlayer(unsigned playerId)
 }
 
 void
-ServerGameThread::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, unsigned timeoutSec)
+ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, unsigned timeoutSec)
 {
 	if (IsRunning() && byWhom.playerData)
 	{
@@ -308,7 +308,7 @@ ServerGameThread::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWh
 }
 
 void
-ServerGameThread::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, DenyKickPlayerReason reason)
+ServerGame::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, DenyKickPlayerReason reason)
 {
 	boost::shared_ptr<NetPacket> denyPetition(new NetPacketAskKickPlayerDenied);
 	NetPacketAskKickPlayerDenied::Data denyPetitionData;
@@ -319,7 +319,7 @@ ServerGameThread::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned player
 }
 
 void
-ServerGameThread::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVote vote)
+ServerGame::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVote vote)
 {
 	if (IsRunning() && byWhom.playerData)
 	{
@@ -357,7 +357,7 @@ ServerGameThread::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, K
 }
 
 void
-ServerGameThread::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionId, DenyVoteReason reason)
+ServerGame::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionId, DenyVoteReason reason)
 {
 	boost::shared_ptr<NetPacket> denyVote(new NetPacketVoteKickPlayerDenied);
 	NetPacketVoteKickPlayerDenied::Data denyVoteData;
@@ -368,7 +368,7 @@ ServerGameThread::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionI
 }
 
 PlayerDataList
-ServerGameThread::GetFullPlayerDataList() const
+ServerGame::GetFullPlayerDataList() const
 {
 	PlayerDataList playerList(GetSessionManager().GetPlayerDataList());
 	boost::mutex::scoped_lock lock(m_computerPlayerListMutex);
@@ -378,7 +378,7 @@ ServerGameThread::GetFullPlayerDataList() const
 }
 
 boost::shared_ptr<PlayerData>
-ServerGameThread::GetPlayerDataByUniqueId(unsigned playerId) const
+ServerGame::GetPlayerDataByUniqueId(unsigned playerId) const
 {
 	boost::shared_ptr<PlayerData> tmpPlayer;
 	SessionWrapper session = GetSessionManager().GetSessionByUniquePlayerId(playerId);
@@ -405,7 +405,7 @@ ServerGameThread::GetPlayerDataByUniqueId(unsigned playerId) const
 }
 
 PlayerIdList
-ServerGameThread::GetPlayerIdList() const
+ServerGame::GetPlayerIdList() const
 {
 	PlayerIdList idList(GetSessionManager().GetPlayerIdList());
 	boost::mutex::scoped_lock lock(m_computerPlayerListMutex);
@@ -421,31 +421,31 @@ ServerGameThread::GetPlayerIdList() const
 }
 
 bool
-ServerGameThread::IsPlayerConnected(const std::string &name) const
+ServerGame::IsPlayerConnected(const std::string &name) const
 {
 	return GetSessionManager().IsPlayerConnected(name);
 }
 
 bool
-ServerGameThread::IsRunning() const
+ServerGame::IsRunning() const
 {
 	return m_game.get() != NULL;
 }
 
 unsigned
-ServerGameThread::GetAdminPlayerId() const
+ServerGame::GetAdminPlayerId() const
 {
 	return m_adminPlayerId;
 }
 
 void
-ServerGameThread::SetAdminPlayerId(unsigned playerId)
+ServerGame::SetAdminPlayerId(unsigned playerId)
 {
 	m_adminPlayerId = playerId;
 }
 
 void
-ServerGameThread::AddComputerPlayer(boost::shared_ptr<PlayerData> player)
+ServerGame::AddComputerPlayer(boost::shared_ptr<PlayerData> player)
 {
 	{
 		boost::mutex::scoped_lock lock(m_computerPlayerListMutex);
@@ -455,7 +455,7 @@ ServerGameThread::AddComputerPlayer(boost::shared_ptr<PlayerData> player)
 }
 
 boost::shared_ptr<PlayerData>
-ServerGameThread::RemoveComputerPlayer(unsigned playerId)
+ServerGame::RemoveComputerPlayer(unsigned playerId)
 {
 	boost::shared_ptr<PlayerData> tmpPlayer;
 	{
@@ -478,7 +478,7 @@ ServerGameThread::RemoveComputerPlayer(unsigned playerId)
 }
 
 bool
-ServerGameThread::IsComputerPlayerActive(unsigned playerId) const
+ServerGame::IsComputerPlayerActive(unsigned playerId) const
 {
 	bool retVal = false;
 	boost::mutex::scoped_lock lock(m_computerPlayerListMutex);
@@ -494,7 +494,7 @@ ServerGameThread::IsComputerPlayerActive(unsigned playerId) const
 }
 
 void
-ServerGameThread::ResetComputerPlayerList()
+ServerGame::ResetComputerPlayerList()
 {
 	boost::mutex::scoped_lock lock(m_computerPlayerListMutex);
 
@@ -512,7 +512,7 @@ ServerGameThread::ResetComputerPlayerList()
 }
 
 void
-ServerGameThread::GracefulRemoveSession(SessionWrapper session, int reason)
+ServerGame::GracefulRemoveSession(SessionWrapper session, int reason)
 {
 	if (!session.sessionData.get())
 		throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0);
@@ -526,7 +526,7 @@ ServerGameThread::GracefulRemoveSession(SessionWrapper session, int reason)
 }
 
 void
-ServerGameThread::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
+ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
 {
 	if (player->GetRights() == PLAYER_RIGHTS_ADMIN)
 	{
@@ -564,14 +564,14 @@ ServerGameThread::RemovePlayerData(boost::shared_ptr<PlayerData> player, int rea
 }
 
 void
-ServerGameThread::ErrorRemoveSession(SessionWrapper session)
+ServerGame::ErrorRemoveSession(SessionWrapper session)
 {
 	GetLobbyThread().RemoveSessionFromGame(session);
 	GracefulRemoveSession(session, NTF_NET_INTERNAL);
 }
 
 void
-ServerGameThread::SessionError(SessionWrapper session, int errorCode)
+ServerGame::SessionError(SessionWrapper session, int errorCode)
 {
 	if (!session.sessionData.get())
 		throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0);
@@ -580,7 +580,7 @@ ServerGameThread::SessionError(SessionWrapper session, int errorCode)
 }
 
 void
-ServerGameThread::MoveSessionToLobby(SessionWrapper session, int reason)
+ServerGame::MoveSessionToLobby(SessionWrapper session, int reason)
 {
 	GracefulRemoveSession(session, reason);
 	// Reset ready flag - just in case it is set, player may leave at any time.
@@ -589,7 +589,7 @@ ServerGameThread::MoveSessionToLobby(SessionWrapper session, int reason)
 }
 
 void
-ServerGameThread::RemoveDisconnectedPlayers()
+ServerGame::RemoveDisconnectedPlayers()
 {
 	// This should only be called between hands.
 	if (m_game.get())
@@ -612,13 +612,13 @@ ServerGameThread::RemoveDisconnectedPlayers()
 }
 
 size_t
-ServerGameThread::GetCurNumberOfPlayers() const
+ServerGame::GetCurNumberOfPlayers() const
 {
 	return GetFullPlayerDataList().size();
 }
 
 void
-ServerGameThread::AssignPlayerNumbers()
+ServerGame::AssignPlayerNumbers()
 {
 	int playerNumber = 0;
 
@@ -635,7 +635,7 @@ ServerGameThread::AssignPlayerNumbers()
 }
 
 bool
-ServerGameThread::IsValidPlayer(unsigned playerId) const
+ServerGame::IsValidPlayer(unsigned playerId) const
 {
 	bool retVal = false;
 	const PlayerIdList list(GetPlayerIdList());
@@ -645,38 +645,38 @@ ServerGameThread::IsValidPlayer(unsigned playerId) const
 }
 
 SessionManager &
-ServerGameThread::GetSessionManager()
+ServerGame::GetSessionManager()
 {
 	return m_sessionManager;
 }
 
 const SessionManager &
-ServerGameThread::GetSessionManager() const
+ServerGame::GetSessionManager() const
 {
 	return m_sessionManager;
 }
 
 ServerLobbyThread &
-ServerGameThread::GetLobbyThread()
+ServerGame::GetLobbyThread()
 {
 	return m_lobbyThread;
 }
 
 ServerCallback &
-ServerGameThread::GetCallback()
+ServerGame::GetCallback()
 {
 	return m_gui;
 }
 
 ServerGameState &
-ServerGameThread::GetState()
+ServerGame::GetState()
 {
 	assert(m_curState);
 	return *m_curState;
 }
 
 void
-ServerGameThread::SetState(ServerGameState &newState)
+ServerGame::SetState(ServerGameState &newState)
 {
 	if (m_curState)
 		m_curState->Exit(*this);
@@ -685,76 +685,76 @@ ServerGameThread::SetState(ServerGameState &newState)
 }
 
 unsigned
-ServerGameThread::GetStateTimerId() const
+ServerGame::GetStateTimerId() const
 {
 	return m_stateTimerId;
 }
 
 void
-ServerGameThread::SetStateTimerId(unsigned newTimerId)
+ServerGame::SetStateTimerId(unsigned newTimerId)
 {
 	m_stateTimerId = newTimerId;
 }
 
 ReceiverHelper &
-ServerGameThread::GetReceiver()
+ServerGame::GetReceiver()
 {
 	assert(m_receiver.get());
 	return *m_receiver;
 }
 
 Game &
-ServerGameThread::GetGame()
+ServerGame::GetGame()
 {
 	assert(m_game.get());
 	return *m_game;
 }
 
 const Game &
-ServerGameThread::GetGame() const
+ServerGame::GetGame() const
 {
 	assert(m_game.get());
 	return *m_game;
 }
 
 const GameData &
-ServerGameThread::GetGameData() const
+ServerGame::GetGameData() const
 {
 	return m_gameData;
 }
 
 const StartData &
-ServerGameThread::GetStartData() const
+ServerGame::GetStartData() const
 {
 	return m_startData;
 }
 
 void
-ServerGameThread::SetStartData(const StartData &startData)
+ServerGame::SetStartData(const StartData &startData)
 {
 	m_startData = startData;
 }
 
 bool
-ServerGameThread::IsPasswordProtected() const
+ServerGame::IsPasswordProtected() const
 {
 	return !m_password.empty();
 }
 
 bool
-ServerGameThread::CheckPassword(const string &password) const
+ServerGame::CheckPassword(const string &password) const
 {
 	return (password == m_password);
 }
 
 GuiInterface &
-ServerGameThread::GetGui()
+ServerGame::GetGui()
 {
 	return m_gui;
 }
 
 unsigned
-ServerGameThread::GetNextGameNum()
+ServerGame::GetNextGameNum()
 {
 	return m_gameNum++;
 }

src/net/common/servergamestate.cpp

@@ -69,7 +69,7 @@ using namespace std;
 // Helper functions
 // TODO: these are hacks.
 
-static void SendPlayerAction(ServerGameThread &server, boost::shared_ptr<PlayerInterface> player)
+static void SendPlayerAction(ServerGame &server, boost::shared_ptr<PlayerInterface> player)
 {
 	if (!player.get())
 		throw ServerException(__FILE__, __LINE__, ERR_NET_NO_CURRENT_PLAYER, 0);
@@ -86,7 +86,7 @@ static void SendPlayerAction(ServerGameThread &server, boost::shared_ptr<PlayerI
 	server.SendToAllPlayers(notifyActionDone, SessionData::Game);
 }
 
-static void SendNewRoundCards(ServerGameThread &server, Game &curGame, int state)
+static void SendNewRoundCards(ServerGame &server, Game &curGame, int state)
 {
 	// TODO: no switch needed here if game states are polymorphic
 	switch(state) {
@@ -130,7 +130,7 @@ static void SendNewRoundCards(ServerGameThread &server, Game &curGame, int state
 	}
 }
 
-static void StartNewHand(ServerGameThread &server)
+static void StartNewHand(ServerGame &server)
 {
 	// Initialize hand.
 	Game &curGame = server.GetGame();
@@ -218,7 +218,7 @@ static void StartNewHand(ServerGameThread &server)
 	}
 }
 
-static void PerformPlayerAction(ServerGameThread &server, boost::shared_ptr<PlayerInterface> player, PlayerAction action, int bet)
+static void PerformPlayerAction(ServerGame &server, boost::shared_ptr<PlayerInterface> player, PlayerAction action, int bet)
 {
 	Game &curGame = server.GetGame();
 	if (!player.get())
@@ -271,7 +271,7 @@ AbstractServerGameStateReceiving::~AbstractServerGameStateReceiving()
 }
 
 int
-AbstractServerGameStateReceiving::ProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+AbstractServerGameStateReceiving::ProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
 	// This is the receive loop for the server.
 	int retVal = MSG_SOCK_INTERNAL_PENDING;
@@ -382,26 +382,26 @@ ServerGameStateInit::~ServerGameStateInit()
 }
 
 void
-ServerGameStateInit::Enter(ServerGameThread &server)
+ServerGameStateInit::Enter(ServerGame &server)
 {
 	RegisterAdminTimer(server);
 }
 
 void
-ServerGameStateInit::Exit(ServerGameThread &server)
+ServerGameStateInit::Exit(ServerGame &server)
 {
 	UnregisterAdminTimer(server);
 }
 
 void
-ServerGameStateInit::NotifyGameAdminChanged(ServerGameThread &server)
+ServerGameStateInit::NotifyGameAdminChanged(ServerGame &server)
 {
 	UnregisterAdminTimer(server);
 	RegisterAdminTimer(server);
 }
 
 void
-ServerGameStateInit::HandleNewSession(ServerGameThread &server, SessionWrapper session)
+ServerGameStateInit::HandleNewSession(ServerGame &server, SessionWrapper session)
 {
 	if (session.sessionData.get() && session.playerData.get())
 	{
@@ -457,7 +457,7 @@ ServerGameStateInit::HandleNewSession(ServerGameThread &server, SessionWrapper s
 }
 
 void
-ServerGameStateInit::RegisterAdminTimer(ServerGameThread &server)
+ServerGameStateInit::RegisterAdminTimer(ServerGame &server)
 {
 	server.SetStateTimerId(
 		server.GetLobbyThread().GetTimerManager().RegisterTimer(
@@ -466,14 +466,14 @@ ServerGameStateInit::RegisterAdminTimer(ServerGameThread &server)
 }
 
 void
-ServerGameStateInit::UnregisterAdminTimer(ServerGameThread &server)
+ServerGameStateInit::UnregisterAdminTimer(ServerGame &server)
 {
 	server.GetLobbyThread().GetTimerManager().UnregisterTimer(server.GetStateTimerId());
 	server.SetStateTimerId(0);
 }
 
 void
-ServerGameStateInit::TimerAdminWarning(ServerGameThread &server)
+ServerGameStateInit::TimerAdminWarning(ServerGame &server)
 {
 	// Find game admin.
 	SessionWrapper session = server.GetSessionManager().GetSessionByUniquePlayerId(server.GetAdminPlayerId());
@@ -495,7 +495,7 @@ ServerGameStateInit::TimerAdminWarning(ServerGameThread &server)
 }
 
 void
-ServerGameStateInit::TimerAdminTimeout(ServerGameThread &server)
+ServerGameStateInit::TimerAdminTimeout(ServerGame &server)
 {
 	// Find game admin.
 	SessionWrapper session = server.GetSessionManager().GetSessionByUniquePlayerId(server.GetAdminPlayerId());
@@ -507,7 +507,7 @@ ServerGameStateInit::TimerAdminTimeout(ServerGameThread &server)
 }
 
 int
-ServerGameStateInit::InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+ServerGameStateInit::InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
 	int retVal = MSG_SOCK_INTERNAL_PENDING;
 
@@ -594,7 +594,7 @@ ServerGameStateStartGame::~ServerGameStateStartGame()
 }
 
 void
-ServerGameStateStartGame::Enter(ServerGameThread &server)
+ServerGameStateStartGame::Enter(ServerGame &server)
 {
 	server.SetStateTimerId(
 		server.GetLobbyThread().GetTimerManager().RegisterTimer(
@@ -603,7 +603,7 @@ ServerGameStateStartGame::Enter(ServerGameThread &server)
 }
 
 void
-ServerGameStateStartGame::Exit(ServerGameThread &server)
+ServerGameStateStartGame::Exit(ServerGame &server)
 {
 	// The Id might be invalid, but this is not a problem.
 	server.GetLobbyThread().GetTimerManager().UnregisterTimer(server.GetStateTimerId());
@@ -611,14 +611,14 @@ ServerGameStateStartGame::Exit(ServerGameThread &server)
 }
 
 void
-ServerGameStateStartGame::HandleNewSession(ServerGameThread &server, SessionWrapper session)
+ServerGameStateStartGame::HandleNewSession(ServerGame &server, SessionWrapper session)
 {
 	// Do not accept new sessions in this state.
 	server.MoveSessionToLobby(session, NTF_NET_REMOVED_ALREADY_RUNNING);
 }
 
 int
-ServerGameStateStartGame::InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+ServerGameStateStartGame::InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
 	int retVal = MSG_SOCK_INTERNAL_PENDING;
 
@@ -638,7 +638,7 @@ ServerGameStateStartGame::InternalProcessPacket(ServerGameThread &server, Sessio
 }
 
 void
-ServerGameStateStartGame::TimerTimeout(ServerGameThread &server)
+ServerGameStateStartGame::TimerTimeout(ServerGame &server)
 {
 	// On timeout: start anyway.
 	server.GetSessionManager().ResetAllReadyFlags();
@@ -648,7 +648,7 @@ ServerGameStateStartGame::TimerTimeout(ServerGameThread &server)
 }
 
 void
-ServerGameStateStartGame::DoStart(ServerGameThread &server)
+ServerGameStateStartGame::DoStart(ServerGame &server)
 {
 	PlayerDataList tmpPlayerList = server.GetFullPlayerDataList();
 	if (tmpPlayerList.size() <= 1)
@@ -711,7 +711,7 @@ ServerGameStateHand::~ServerGameStateHand()
 }
 
 void
-ServerGameStateHand::Enter(ServerGameThread &server)
+ServerGameStateHand::Enter(ServerGame &server)
 {
 	server.SetStateTimerId(
 		server.GetLobbyThread().GetTimerManager().RegisterTimer(
@@ -720,7 +720,7 @@ ServerGameStateHand::Enter(ServerGameThread &server)
 }
 
 void
-ServerGameStateHand::Exit(ServerGameThread &server)
+ServerGameStateHand::Exit(ServerGame &server)
 {
 	// The Id might be invalid, but this is not a problem.
 	server.GetLobbyThread().GetTimerManager().UnregisterTimer(server.GetStateTimerId());
@@ -728,21 +728,21 @@ ServerGameStateHand::Exit(ServerGameThread &server)
 }
 
 void
-ServerGameStateHand::HandleNewSession(ServerGameThread &server, SessionWrapper session)
+ServerGameStateHand::HandleNewSession(ServerGame &server, SessionWrapper session)
 {
 	// Do not accept new sessions in this state.
 	server.MoveSessionToLobby(session, NTF_NET_REMOVED_ALREADY_RUNNING);
 }
 
 int
-ServerGameStateHand::InternalProcessPacket(ServerGameThread &/*server*/, SessionWrapper /*session*/, boost::shared_ptr<NetPacket> /*packet*/)
+ServerGameStateHand::InternalProcessPacket(ServerGame &/*server*/, SessionWrapper /*session*/, boost::shared_ptr<NetPacket> /*packet*/)
 {
 	// TODO: maybe reject packet.
 	return MSG_SOCK_INTERNAL_PENDING;
 }
 
 void
-ServerGameStateHand::TimerLoop(ServerGameThread &server)
+ServerGameStateHand::TimerLoop(ServerGame &server)
 {
 	server.SetStateTimerId(0);
 	Game &curGame = server.GetGame();
@@ -941,7 +941,7 @@ ServerGameStateHand::TimerLoop(ServerGameThread &server)
 }
 
 void
-ServerGameStateHand::TimerShowCards(ServerGameThread &server)
+ServerGameStateHand::TimerShowCards(ServerGame &server)
 {
 	Game &curGame = server.GetGame();
 	SendNewRoundCards(server, curGame, curGame.getCurrentHand()->getCurrentRound());
@@ -953,7 +953,7 @@ ServerGameStateHand::TimerShowCards(ServerGameThread &server)
 }
 
 void
-ServerGameStateHand::TimerComputerAction(ServerGameThread &server)
+ServerGameStateHand::TimerComputerAction(ServerGame &server)
 {
 	boost::shared_ptr<PlayerInterface> tmpPlayer = server.GetGame().getCurrentPlayer();
 
@@ -963,14 +963,14 @@ ServerGameStateHand::TimerComputerAction(ServerGameThread &server)
 }
 
 void
-ServerGameStateHand::TimerNextHand(ServerGameThread &server)
+ServerGameStateHand::TimerNextHand(ServerGame &server)
 {
 	StartNewHand(server);
 	TimerLoop(server);
 }
 
 void
-ServerGameStateHand::TimerNextGame(ServerGameThread &server)
+ServerGameStateHand::TimerNextGame(ServerGame &server)
 {
 	Game &curGame = server.GetGame();
 	// The game has ended. Notify all clients.
@@ -1000,7 +1000,7 @@ ServerGameStateHand::TimerNextGame(ServerGameThread &server)
 }
 
 int
-ServerGameStateHand::GetDealCardsDelaySec(ServerGameThread &server)
+ServerGameStateHand::GetDealCardsDelaySec(ServerGame &server)
 {
 	Game &curGame = server.GetGame();
 	int allInDelay = curGame.getCurrentHand()->getAllInCondition() ? SERVER_DEAL_ADD_ALL_IN_DELAY_SEC : 0;
@@ -1041,7 +1041,7 @@ ServerGameStateWaitPlayerAction::~ServerGameStateWaitPlayerAction()
 }
 
 void
-ServerGameStateWaitPlayerAction::Enter(ServerGameThread &server)
+ServerGameStateWaitPlayerAction::Enter(ServerGame &server)
 {
 #ifdef SERVER_TEST
 	int timeoutSec = 0;
@@ -1056,7 +1056,7 @@ ServerGameStateWaitPlayerAction::Enter(ServerGameThread &server)
 }
 
 void
-ServerGameStateWaitPlayerAction::Exit(ServerGameThread &server)
+ServerGameStateWaitPlayerAction::Exit(ServerGame &server)
 {
 	// The Id might be invalid, but this is not a problem.
 	server.GetLobbyThread().GetTimerManager().UnregisterTimer(server.GetStateTimerId());
@@ -1064,14 +1064,14 @@ ServerGameStateWaitPlayerAction::Exit(ServerGameThread &server)
 }
 
 void
-ServerGameStateWaitPlayerAction::HandleNewSession(ServerGameThread &server, SessionWrapper session)
+ServerGameStateWaitPlayerAction::HandleNewSession(ServerGame &server, SessionWrapper session)
 {
 	// Do not accept new sessions in this state.
 	server.MoveSessionToLobby(session, NTF_NET_REMOVED_ALREADY_RUNNING);
 }
 
 int
-ServerGameStateWaitPlayerAction::InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+ServerGameStateWaitPlayerAction::InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
 	int retVal = MSG_SOCK_INTERNAL_PENDING;
 
@@ -1145,7 +1145,7 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(ServerGameThread &server,
 }
 
 void
-ServerGameStateWaitPlayerAction::TimerTimeout(ServerGameThread &server)
+ServerGameStateWaitPlayerAction::TimerTimeout(ServerGame &server)
 {
 	Game &curGame = server.GetGame();
 	// Retrieve current player.

src/net/common/serverlobbythread.cpp

@@ -188,7 +188,7 @@ ServerLobbyThread::ReAddSession(SessionWrapper session, int reason)
 }
 
 void
-ServerLobbyThread::MoveSessionToGame(ServerGameThread &game, SessionWrapper session)
+ServerLobbyThread::MoveSessionToGame(ServerGame &game, SessionWrapper session)
 {
 	// Remove session from the lobby.
 	m_sessionManager.RemoveSession(session.sessionData->GetId());
@@ -574,7 +574,7 @@ ServerLobbyThread::HandleRead(SessionId sessionId, const boost::system::error_co
 	{
 		// Retrieve current game, if applicable.
 		unsigned gameId = session.sessionData->GetGameId();
-		boost::shared_ptr<ServerGameThread> game;
+		boost::shared_ptr<ServerGame> game;
 		if (gameId)
 		{
 			GameMap::iterator pos = m_gameMap.find(gameId);
@@ -939,8 +939,8 @@ ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const NetPa
 	NetPacketCreateGame::Data createGameData;
 	tmpPacket.GetData(createGameData);
 
-	boost::shared_ptr<ServerGameThread> game(
-		new ServerGameThread(
+	boost::shared_ptr<ServerGame> game(
+		new ServerGame(
 			*this,
 			GetNextGameId(),
 			createGameData.gameName,
@@ -967,7 +967,7 @@ ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPack
 
 	if (pos != m_gameMap.end())
 	{
-		ServerGameThread &game = *pos->second;
+		ServerGame &game = *pos->second;
 		if (game.CheckPassword(joinGameData.password))
 		{
 			MoveSessionToGame(game, session);
@@ -1058,7 +1058,7 @@ ServerLobbyThread::TimerRemoveGame()
 	{
 		GameMap::iterator next = i;
 		++next;
-		boost::shared_ptr<ServerGameThread> tmpGame = i->second;
+		boost::shared_ptr<ServerGame> tmpGame = i->second;
 		if (!tmpGame->GetSessionManager().HasSessions())
 			InternalRemoveGame(tmpGame); // This will delete the entry from the map.
 		i = next;
@@ -1145,7 +1145,7 @@ ServerLobbyThread::TimerCleanupAvatarCache()
 }
 
 void
-ServerLobbyThread::InternalAddGame(boost::shared_ptr<ServerGameThread> game)
+ServerLobbyThread::InternalAddGame(boost::shared_ptr<ServerGame> game)
 {
 	// Add game to list.
 	m_gameMap.insert(GameMap::value_type(game->GetId(), game));
@@ -1165,7 +1165,7 @@ ServerLobbyThread::InternalAddGame(boost::shared_ptr<ServerGameThread> game)
 }
 
 void
-ServerLobbyThread::InternalRemoveGame(boost::shared_ptr<ServerGameThread> game)
+ServerLobbyThread::InternalRemoveGame(boost::shared_ptr<ServerGame> game)
 {
 	{
 		boost::mutex::scoped_lock lock(m_statMutex);
@@ -1200,7 +1200,7 @@ ServerLobbyThread::InternalRemovePlayer(unsigned playerId, unsigned errorCode)
 
 		while (i != end)
 		{
-			boost::shared_ptr<ServerGameThread> tmpGame = i->second;
+			boost::shared_ptr<ServerGame> tmpGame = i->second;
 			if (tmpGame->GetPlayerDataByUniqueId(playerId).get())
 			{
 				tmpGame->RemovePlayer(playerId, errorCode);
@@ -1527,7 +1527,7 @@ ServerLobbyThread::IsIPAddressBanned(const std::string &ipAddress) const
 }
 
 boost::shared_ptr<NetPacket>
-ServerLobbyThread::CreateNetPacketGameListNew(const ServerGameThread &game)
+ServerLobbyThread::CreateNetPacketGameListNew(const ServerGame &game)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacketGameListNew);
 	NetPacketGameListNew::Data packetData;

src/net/servergame.h

@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2007 by Lothar May                                      *
+ *   Copyright (C) 2007-2009 by Lothar May                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -16,10 +16,10 @@
  *   Free Software Foundation, Inc.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
-/* Network server game thread. */
+/* Network server game. */
 
-#ifndef _SERVERGAMETHREAD_H_
-#define _SERVERGAMETHREAD_H_
+#ifndef _SERVERGAME_H_
+#define _SERVERGAME_H_
 
 #include <third_party/boost/timers.hpp>
 #include <deque>
@@ -29,9 +29,6 @@
 #include <gamedata.h>
 
 
-#define GAME_THREAD_TERMINATE_TIMEOUT	THREAD_WAIT_INFINITE
-
-
 class ReceiverHelper;
 class ServerLobbyThread;
 class ServerGameState;
@@ -39,12 +36,12 @@ class ConfigFile;
 struct GameData;
 class Game;
 
-class ServerGameThread
+class ServerGame
 {
 public:
-	ServerGameThread(
+	ServerGame(
 		ServerLobbyThread &lobbyThread, u_int32_t id, const std::string &name, const std::string &pwd, const GameData &gameData, unsigned adminPlayerId, GuiInterface &gui, ConfigFile *playerConfig);
-	virtual ~ServerGameThread();
+	virtual ~ServerGame();
 
 	u_int32_t GetId() const;
 	const std::string &GetName() const;
@@ -131,7 +128,7 @@ protected:
 	SessionManager &GetSessionManager();
 
 private:
-	ServerGameThread(const ServerGameThread &other);
+	ServerGame(const ServerGame &other);
 
 	SessionManager m_sessionManager;
 	PlayerDataList m_computerPlayerList;

src/net/servergamestate.h

@@ -33,7 +33,7 @@
 #define SERVER_INITIAL_STATE	ServerGameStateInit
 
 class Game;
-class ServerGameThread;
+class ServerGame;
 class PlayerInterface;
 class ServerCallback;
 
@@ -41,16 +41,16 @@ class ServerGameState
 {
 public:
 	virtual ~ServerGameState();
-	virtual void Enter(ServerGameThread &server) = 0;
-	virtual void Exit(ServerGameThread &server) = 0;
+	virtual void Enter(ServerGame &server) = 0;
+	virtual void Exit(ServerGame &server) = 0;
 
-	virtual void NotifyGameAdminChanged(ServerGameThread &server) = 0;
+	virtual void NotifyGameAdminChanged(ServerGame &server) = 0;
 
 	// Handling of a new session.
-	virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session) = 0;
+	virtual void HandleNewSession(ServerGame &server, SessionWrapper session) = 0;
 
 	// Main processing function of the current state.
-	virtual int ProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0;
+	virtual int ProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0;
 };
 
 // Abstract State: Receiving.
@@ -61,11 +61,11 @@ public:
 
 	// Globally handle packets which are allowed in all running states.
 	// Calls InternalProcess if packet has not been processed.
-	virtual int ProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
+	virtual int ProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
 
 protected:
 
-	virtual int InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0;
+	virtual int InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0;
 };
 
 // State: Initialization.
@@ -73,24 +73,24 @@ class ServerGameStateInit : public AbstractServerGameStateReceiving
 {
 public:
 	static ServerGameStateInit &Instance();
-	virtual void Enter(ServerGameThread &server);
-	virtual void Exit(ServerGameThread &server);
+	virtual void Enter(ServerGame &server);
+	virtual void Exit(ServerGame &server);
 
 	virtual ~ServerGameStateInit();
 
-	virtual void NotifyGameAdminChanged(ServerGameThread &server);
+	virtual void NotifyGameAdminChanged(ServerGame &server);
 
-	virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session);
+	virtual void HandleNewSession(ServerGame &server, SessionWrapper session);
 
 protected:
 	ServerGameStateInit();
 
-	void RegisterAdminTimer(ServerGameThread &server);
-	void UnregisterAdminTimer(ServerGameThread &server);
-	void TimerAdminWarning(ServerGameThread &server);
-	void TimerAdminTimeout(ServerGameThread &server);
+	void RegisterAdminTimer(ServerGame &server);
+	void UnregisterAdminTimer(ServerGame &server);
+	void TimerAdminWarning(ServerGame &server);
+	void TimerAdminTimeout(ServerGame &server);
 
-	virtual int InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
+	virtual int InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
 
 	static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(const PlayerData &playerData);
 
@@ -103,20 +103,20 @@ class ServerGameStateStartGame : public AbstractServerGameStateReceiving
 {
 public:
 	static ServerGameStateStartGame &Instance();
-	virtual void Enter(ServerGameThread &server);
-	virtual void Exit(ServerGameThread &server);
+	virtual void Enter(ServerGame &server);
+	virtual void Exit(ServerGame &server);
 
 	virtual ~ServerGameStateStartGame();
 
-	virtual void NotifyGameAdminChanged(ServerGameThread &/*server*/) {}
-	virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session);
+	virtual void NotifyGameAdminChanged(ServerGame &/*server*/) {}
+	virtual void HandleNewSession(ServerGame &server, SessionWrapper session);
 
 protected:
 	ServerGameStateStartGame();
 
-	virtual int InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
-	void TimerTimeout(ServerGameThread &server);
-	void DoStart(ServerGameThread &server);
+	virtual int InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
+	void TimerTimeout(ServerGame &server);
+	void DoStart(ServerGame &server);
 
 private:
 	static ServerGameStateStartGame s_state;
@@ -127,24 +127,24 @@ class ServerGameStateHand : public AbstractServerGameStateReceiving
 {
 public:
 	static ServerGameStateHand &Instance();
-	virtual void Enter(ServerGameThread &server);
-	virtual void Exit(ServerGameThread &server);
+	virtual void Enter(ServerGame &server);
+	virtual void Exit(ServerGame &server);
 
 	virtual ~ServerGameStateHand();
 
-	virtual void NotifyGameAdminChanged(ServerGameThread &/*server*/) {}
-	virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session);
+	virtual void NotifyGameAdminChanged(ServerGame &/*server*/) {}
+	virtual void HandleNewSession(ServerGame &server, SessionWrapper session);
 
 protected:
 	ServerGameStateHand();
 
-	virtual int InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
-	void TimerLoop(ServerGameThread &server);
-	void TimerShowCards(ServerGameThread &server);
-	void TimerComputerAction(ServerGameThread &server);
-	void TimerNextHand(ServerGameThread &server);
-	void TimerNextGame(ServerGameThread &server);
-	int GetDealCardsDelaySec(ServerGameThread &server);
+	virtual int InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
+	void TimerLoop(ServerGame &server);
+	void TimerShowCards(ServerGame &server);
+	void TimerComputerAction(ServerGame &server);
+	void TimerNextHand(ServerGame &server);
+	void TimerNextGame(ServerGame &server);
+	int GetDealCardsDelaySec(ServerGame &server);
 
 private:
 	static ServerGameStateHand s_state;
@@ -155,19 +155,19 @@ class ServerGameStateWaitPlayerAction : public AbstractServerGameStateReceiving
 {
 public:
 	static ServerGameStateWaitPlayerAction &Instance();
-	virtual void Enter(ServerGameThread &server);
-	virtual void Exit(ServerGameThread &server);
+	virtual void Enter(ServerGame &server);
+	virtual void Exit(ServerGame &server);
 
 	virtual ~ServerGameStateWaitPlayerAction();
 
-	virtual void NotifyGameAdminChanged(ServerGameThread &/*server*/) {}
-	virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session);
+	virtual void NotifyGameAdminChanged(ServerGame &/*server*/) {}
+	virtual void HandleNewSession(ServerGame &server, SessionWrapper session);
 
 protected:
 	ServerGameStateWaitPlayerAction();
 
-	virtual int InternalProcessPacket(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
-	void TimerTimeout(ServerGameThread &server);
+	virtual int InternalProcessPacket(ServerGame &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
+	void TimerTimeout(ServerGame &server);
 
 private:
 	static ServerGameStateWaitPlayerAction s_state;

src/net/serverlobbythread.h

@@ -39,7 +39,7 @@
 class SenderInterface;
 class ReceiverHelper;
 class ServerSenderCallback;
-class ServerGameThread;
+class ServerGame;
 class ConfigFile;
 class AvatarManager;
 struct GameData;
@@ -56,7 +56,7 @@ public:
 
 	void AddConnection(boost::shared_ptr<boost::asio::ip::tcp::socket> sock);
 	void ReAddSession(SessionWrapper session, int reason);
-	void MoveSessionToGame(ServerGameThread &game, SessionWrapper session);
+	void MoveSessionToGame(ServerGame &game, SessionWrapper session);
 	void RemoveSessionFromGame(SessionWrapper session);
 	void SessionError(SessionWrapper session, int errorCode);
 	void ResubscribeLobbyMsg(SessionWrapper session);
@@ -103,7 +103,7 @@ protected:
 	typedef std::list<SessionWrapper> SessionList;
 	typedef std::list<SessionId> SessionIdList;
 	typedef std::map<SessionId, boost::timers::portable::microsec_timer> TimerSessionMap;
-	typedef std::map<unsigned, boost::shared_ptr<ServerGameThread> > GameMap;
+	typedef std::map<unsigned, boost::shared_ptr<ServerGame> > GameMap;
 	typedef std::map<std::string, boost::timers::portable::microsec_timer> TimerClientAddressMap;
 	typedef std::list<unsigned> RemoveGameList;
 	typedef std::map<unsigned, boost::regex> RegexMap;
@@ -134,8 +134,8 @@ protected:
 	void TimerCheckSessionTimeouts();
 	void TimerCleanupAvatarCache();
 
-	void InternalAddGame(boost::shared_ptr<ServerGameThread> game);
-	void InternalRemoveGame(boost::shared_ptr<ServerGameThread> game);
+	void InternalAddGame(boost::shared_ptr<ServerGame> game);
+	void InternalRemoveGame(boost::shared_ptr<ServerGame> game);
 	void InternalRemovePlayer(unsigned playerId, unsigned errorCode);
 	void InternalResubscribeMsg(SessionWrapper session);
 
@@ -168,7 +168,7 @@ protected:
 	bool IsPlayerBanned(const std::string &name) const;
 	bool IsIPAddressBanned(const std::string &ipAddress) const;
 
-	static boost::shared_ptr<NetPacket> CreateNetPacketGameListNew(const ServerGameThread &game);
+	static boost::shared_ptr<NetPacket> CreateNetPacketGameListNew(const ServerGame &game);
 	static boost::shared_ptr<NetPacket> CreateNetPacketGameListUpdate(unsigned gameId, GameMode mode);
 
 private: