sco/pokerth
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored server states - removed all thread local storage objects to ensure that they do not cause resource leaks.

Browse Source
This commit is contained in:
lotodore
2007-11-21 23:34:25 +00:00
parent a7f0a23f22
commit e28220a8ad
4 changed files with 84 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/net/common/servergamestate.cpp
+35 -75
View File
@@ -220,33 +220,26 @@ AbstractServerGameStateReceiving::Process(ServerGameThread &server)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
AbstractServerGameStateTimer::AbstractServerGameStateTimer()
: m_timer(boost::posix_time::time_duration(0, 0, 0), boost::timers::portable::microsec_timer::manual_start)
{
}
AbstractServerGameStateTimer::~AbstractServerGameStateTimer() AbstractServerGameStateTimer::~AbstractServerGameStateTimer()
{ {
} }
void void
AbstractServerGameStateTimer::Init() AbstractServerGameStateTimer::Init(ServerGameThread & server)
{ {
m_timer.reset(); // Reset timer.
m_timer.start(); server.GetStateTimer().reset();
server.GetStateTimer().start();
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateInit> ServerGameStateInit::Ptr; ServerGameStateInit ServerGameStateInit::m_state;
ServerGameStateInit & ServerGameStateInit &
ServerGameStateInit::Instance() ServerGameStateInit::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateInit);
return *Ptr;
} }
ServerGameStateInit::ServerGameStateInit() ServerGameStateInit::ServerGameStateInit()
@@ -388,15 +381,12 @@ AbstractServerGameStateRunning::HandleNewSession(ServerGameThread &server, Sessi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateWaitAck> ServerGameStateWaitAck::Ptr; ServerGameStateWaitAck ServerGameStateWaitAck::m_state;
ServerGameStateWaitAck & ServerGameStateWaitAck &
ServerGameStateWaitAck::Instance() ServerGameStateWaitAck::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateWaitAck);
return *Ptr;
} }
ServerGameStateWaitAck::ServerGameStateWaitAck() ServerGameStateWaitAck::ServerGameStateWaitAck()
@@ -412,7 +402,7 @@ ServerGameStateWaitAck::Process(ServerGameThread &server)
{ {
int retVal; int retVal;
if (GetTimer().elapsed().total_seconds() >= SERVER_START_GAME_TIMEOUT_SEC) if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_START_GAME_TIMEOUT_SEC)
{ {
// On timeout: start anyway. // On timeout: start anyway.
server.SetState(SERVER_START_GAME_STATE::Instance()); server.SetState(SERVER_START_GAME_STATE::Instance());
@@ -447,15 +437,12 @@ ServerGameStateWaitAck::InternalProcess(ServerGameThread &server, SessionWrapper
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateStartGame> ServerGameStateStartGame::Ptr; ServerGameStateStartGame ServerGameStateStartGame::m_state;
ServerGameStateStartGame & ServerGameStateStartGame &
ServerGameStateStartGame::Instance() ServerGameStateStartGame::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateStartGame);
return *Ptr;
} }
ServerGameStateStartGame::ServerGameStateStartGame() ServerGameStateStartGame::ServerGameStateStartGame()
@@ -500,15 +487,12 @@ ServerGameStateStartGame::Process(ServerGameThread &server)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateStartHand> ServerGameStateStartHand::Ptr; ServerGameStateStartHand ServerGameStateStartHand::m_state;
ServerGameStateStartHand & ServerGameStateStartHand &
ServerGameStateStartHand::Instance() ServerGameStateStartHand::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateStartHand);
return *Ptr;
} }
ServerGameStateStartHand::ServerGameStateStartHand() ServerGameStateStartHand::ServerGameStateStartHand()
@@ -614,15 +598,12 @@ ServerGameStateStartHand::Process(ServerGameThread &server)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateStartRound> ServerGameStateStartRound::Ptr; ServerGameStateStartRound ServerGameStateStartRound::m_state;
ServerGameStateStartRound & ServerGameStateStartRound &
ServerGameStateStartRound::Instance() ServerGameStateStartRound::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateStartRound);
return *Ptr;
} }
ServerGameStateStartRound::ServerGameStateStartRound() ServerGameStateStartRound::ServerGameStateStartRound()
@@ -810,15 +791,12 @@ ServerGameStateStartRound::Process(ServerGameThread &server)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateWaitPlayerAction> ServerGameStateWaitPlayerAction::Ptr; ServerGameStateWaitPlayerAction ServerGameStateWaitPlayerAction::m_state;
ServerGameStateWaitPlayerAction & ServerGameStateWaitPlayerAction &
ServerGameStateWaitPlayerAction::Instance() ServerGameStateWaitPlayerAction::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateWaitPlayerAction);
return *Ptr;
} }
ServerGameStateWaitPlayerAction::ServerGameStateWaitPlayerAction() ServerGameStateWaitPlayerAction::ServerGameStateWaitPlayerAction()
@@ -855,7 +833,7 @@ ServerGameStateWaitPlayerAction::Process(ServerGameThread &server)
#ifdef SERVER_TEST #ifdef SERVER_TEST
else if (true) else if (true)
#else #else
else if (GetTimer().elapsed().total_seconds() >= server.GetGameData().playerActionTimeoutSec + SERVER_PLAYER_TIMEOUT_ADD_DELAY_SEC) else if (server.GetStateTimer().elapsed().total_seconds() >= server.GetGameData().playerActionTimeoutSec + SERVER_PLAYER_TIMEOUT_ADD_DELAY_SEC)
#endif #endif
{ {
// Player did not act fast enough. Act for him. // Player did not act fast enough. Act for him.
@@ -979,15 +957,12 @@ ServerGameStateWaitPlayerAction::PerformPlayerAction(ServerGameThread &server, b
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateComputerAction> ServerGameStateComputerAction::Ptr; ServerGameStateComputerAction ServerGameStateComputerAction::m_state;
ServerGameStateComputerAction & ServerGameStateComputerAction &
ServerGameStateComputerAction::Instance() ServerGameStateComputerAction::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateComputerAction);
return *Ptr;
} }
ServerGameStateComputerAction::ServerGameStateComputerAction() ServerGameStateComputerAction::ServerGameStateComputerAction()
@@ -1003,7 +978,7 @@ ServerGameStateComputerAction::Process(ServerGameThread &server)
{ {
int retVal = AbstractServerGameStateReceiving::Process(server); int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_COMPUTER_ACTION_DELAY_SEC) if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_COMPUTER_ACTION_DELAY_SEC)
{ {
boost::shared_ptr<PlayerInterface> tmpPlayer = server.GetGame().getCurrentPlayer(); boost::shared_ptr<PlayerInterface> tmpPlayer = server.GetGame().getCurrentPlayer();
@@ -1025,15 +1000,12 @@ ServerGameStateComputerAction::InternalProcess(ServerGameThread &/*server*/, Ses
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateDealCardsDelay> ServerGameStateDealCardsDelay::Ptr; ServerGameStateDealCardsDelay ServerGameStateDealCardsDelay::m_state;
ServerGameStateDealCardsDelay & ServerGameStateDealCardsDelay &
ServerGameStateDealCardsDelay::Instance() ServerGameStateDealCardsDelay::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateDealCardsDelay);
return *Ptr;
} }
ServerGameStateDealCardsDelay::ServerGameStateDealCardsDelay() ServerGameStateDealCardsDelay::ServerGameStateDealCardsDelay()
@@ -1066,7 +1038,7 @@ ServerGameStateDealCardsDelay::Process(ServerGameThread &server)
delay = SERVER_DEAL_RIVER_CARD_DELAY_SEC; delay = SERVER_DEAL_RIVER_CARD_DELAY_SEC;
break; break;
} }
if (!delay || GetTimer().elapsed().total_seconds() >= delay) if (!delay || server.GetStateTimer().elapsed().total_seconds() >= delay)
server.SetState(ServerGameStateStartRound::Instance()); server.SetState(ServerGameStateStartRound::Instance());
return retVal; return retVal;
@@ -1080,15 +1052,12 @@ ServerGameStateDealCardsDelay::InternalProcess(ServerGameThread &/*server*/, Ses
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateShowCardsDelay> ServerGameStateShowCardsDelay::Ptr; ServerGameStateShowCardsDelay ServerGameStateShowCardsDelay::m_state;
ServerGameStateShowCardsDelay & ServerGameStateShowCardsDelay &
ServerGameStateShowCardsDelay::Instance() ServerGameStateShowCardsDelay::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateShowCardsDelay);
return *Ptr;
} }
ServerGameStateShowCardsDelay::ServerGameStateShowCardsDelay() ServerGameStateShowCardsDelay::ServerGameStateShowCardsDelay()
@@ -1104,7 +1073,7 @@ ServerGameStateShowCardsDelay::Process(ServerGameThread &server)
{ {
int retVal = AbstractServerGameStateReceiving::Process(server); int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_SHOW_CARDS_DELAY_SEC) if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_SHOW_CARDS_DELAY_SEC)
{ {
Game &curGame = server.GetGame(); Game &curGame = server.GetGame();
SendNewRoundCards(server, curGame, curGame.getCurrentHand()->getCurrentRound()); SendNewRoundCards(server, curGame, curGame.getCurrentHand()->getCurrentRound());
@@ -1124,15 +1093,12 @@ ServerGameStateShowCardsDelay::InternalProcess(ServerGameThread &/*server*/, Ses
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateNextHandDelay> ServerGameStateNextHandDelay::Ptr; ServerGameStateNextHandDelay ServerGameStateNextHandDelay::m_state;
ServerGameStateNextHandDelay & ServerGameStateNextHandDelay &
ServerGameStateNextHandDelay::Instance() ServerGameStateNextHandDelay::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateNextHandDelay);
return *Ptr;
} }
ServerGameStateNextHandDelay::ServerGameStateNextHandDelay() ServerGameStateNextHandDelay::ServerGameStateNextHandDelay()
@@ -1148,7 +1114,7 @@ ServerGameStateNextHandDelay::Process(ServerGameThread &server)
{ {
int retVal = AbstractServerGameStateReceiving::Process(server); int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_HAND_SEC) if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_HAND_SEC)
server.SetState(ServerGameStateStartHand::Instance()); server.SetState(ServerGameStateStartHand::Instance());
return retVal; return retVal;
@@ -1162,15 +1128,12 @@ ServerGameStateNextHandDelay::InternalProcess(ServerGameThread &/*server*/, Sess
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateNextGameDelay> ServerGameStateNextGameDelay::Ptr; ServerGameStateNextGameDelay ServerGameStateNextGameDelay::m_state;
ServerGameStateNextGameDelay & ServerGameStateNextGameDelay &
ServerGameStateNextGameDelay::Instance() ServerGameStateNextGameDelay::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateNextGameDelay);
return *Ptr;
} }
ServerGameStateNextGameDelay::ServerGameStateNextGameDelay() ServerGameStateNextGameDelay::ServerGameStateNextGameDelay()
@@ -1186,7 +1149,7 @@ ServerGameStateNextGameDelay::Process(ServerGameThread &server)
{ {
int retVal = AbstractServerGameStateReceiving::Process(server); int retVal = AbstractServerGameStateReceiving::Process(server);
if (GetTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_GAME_SEC) if (server.GetStateTimer().elapsed().total_seconds() >= SERVER_DELAY_NEXT_GAME_SEC)
{ {
Game &curGame = server.GetGame(); Game &curGame = server.GetGame();
// The game has ended. Notify all clients. // The game has ended. Notify all clients.
@@ -1226,15 +1189,12 @@ ServerGameStateNextGameDelay::InternalProcess(ServerGameThread &/*server*/, Sess
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
boost::thread_specific_ptr<ServerGameStateFinal> ServerGameStateFinal::Ptr; ServerGameStateFinal ServerGameStateFinal::m_state;
ServerGameStateFinal & ServerGameStateFinal &
ServerGameStateFinal::Instance() ServerGameStateFinal::Instance()
{ {
if (!Ptr.get()) return m_state;
Ptr.reset(new ServerGameStateFinal);
return *Ptr;
} }
ServerGameStateFinal::ServerGameStateFinal() ServerGameStateFinal::ServerGameStateFinal()
src/net/common/servergamethread.cpp
+15 -2
View File
@@ -56,7 +56,8 @@ private:
ServerGameThread::ServerGameThread(ServerLobbyThread &lobbyThread, u_int32_t id, const string &name, const string &pwd, const GameData &gameData, unsigned adminPlayerId, GuiInterface &gui, ConfigFile *playerConfig) ServerGameThread::ServerGameThread(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_adminPlayerId(adminPlayerId), m_lobbyThread(lobbyThread), m_gui(gui),
m_gameData(gameData), m_id(id), m_name(name), m_password(pwd), m_playerConfig(playerConfig), m_gameData(gameData), m_id(id), m_name(name), m_password(pwd), m_playerConfig(playerConfig),
m_curState(NULL), m_gameNum(1) m_curState(NULL), m_gameNum(1),
m_stateTimer(boost::posix_time::time_duration(0, 0, 0), boost::timers::portable::microsec_timer::manual_start)
{ {
m_senderCallback.reset(new GameSenderCallback(*this)); m_senderCallback.reset(new GameSenderCallback(*this));
m_sender.reset(new SenderThread(GetSenderCallback())); m_sender.reset(new SenderThread(GetSenderCallback()));
@@ -499,10 +500,22 @@ ServerGameThread::GetState()
void void
ServerGameThread::SetState(ServerGameState &newState) ServerGameThread::SetState(ServerGameState &newState)
{ {
newState.Init(); newState.Init(*this);
m_curState = &newState; m_curState = &newState;
} }
const boost::timers::portable::microsec_timer &
ServerGameThread::GetStateTimer() const
{
return m_stateTimer;
}
boost::timers::portable::microsec_timer &
ServerGameThread::GetStateTimer()
{
return m_stateTimer;
}
SenderThread & SenderThread &
ServerGameThread::GetSender() ServerGameThread::GetSender()
{ {
src/net/servergamestate.h
+27 -36
View File
@@ -44,7 +44,7 @@ public:
virtual ~ServerGameState(); virtual ~ServerGameState();
// Initialize after switching to this state. // Initialize after switching to this state.
virtual void Init() = 0; virtual void Init(ServerGameThread &server) = 0;
// Handling of a new session. // Handling of a new session.
virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session) = 0; virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session) = 0;
@@ -70,24 +70,6 @@ protected:
virtual int InternalProcess(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0; virtual int InternalProcess(ServerGameThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) = 0;
}; };
// Abstract State: Timer.
class AbstractServerGameStateTimer : virtual public ServerGameState
{
public:
virtual ~AbstractServerGameStateTimer();
virtual void Init();
const boost::timers::portable::microsec_timer &GetTimer() const {return m_timer;}
protected:
AbstractServerGameStateTimer();
private:
boost::timers::portable::microsec_timer m_timer;
};
// Abstract State: Game is running. // Abstract State: Game is running.
class AbstractServerGameStateRunning : virtual public ServerGameState class AbstractServerGameStateRunning : virtual public ServerGameState
{ {
@@ -102,6 +84,15 @@ protected:
AbstractServerGameStateRunning(); AbstractServerGameStateRunning();
}; };
// Abstract State: Timer.
class AbstractServerGameStateTimer : virtual public ServerGameState
{
public:
virtual ~AbstractServerGameStateTimer();
virtual void Init(ServerGameThread &server);
};
// State: Initialization. // State: Initialization.
class ServerGameStateInit : public AbstractServerGameStateReceiving class ServerGameStateInit : public AbstractServerGameStateReceiving
{ {
@@ -111,7 +102,7 @@ public:
virtual ~ServerGameStateInit(); virtual ~ServerGameStateInit();
virtual void Init() {} virtual void Init(ServerGameThread & /*server*/) {}
// //
virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session); virtual void HandleNewSession(ServerGameThread &server, SessionWrapper session);
@@ -126,7 +117,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateInit> Ptr; static ServerGameStateInit m_state;
}; };
// Wait for Ack of start event. // Wait for Ack of start event.
@@ -150,7 +141,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateWaitAck> Ptr; static ServerGameStateWaitAck m_state;
}; };
// State: Start server game. // State: Start server game.
@@ -162,7 +153,7 @@ public:
virtual ~ServerGameStateStartGame(); virtual ~ServerGameStateStartGame();
virtual void Init() {} virtual void Init(ServerGameThread & /*server*/) {}
// //
virtual int Process(ServerGameThread &server); virtual int Process(ServerGameThread &server);
@@ -174,7 +165,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateStartGame> Ptr; static ServerGameStateStartGame m_state;
}; };
// State: Start new hand. // State: Start new hand.
@@ -186,7 +177,7 @@ public:
virtual ~ServerGameStateStartHand(); virtual ~ServerGameStateStartHand();
virtual void Init() {} virtual void Init(ServerGameThread & /*server*/) {}
// //
virtual int Process(ServerGameThread &server); virtual int Process(ServerGameThread &server);
@@ -198,7 +189,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateStartHand> Ptr; static ServerGameStateStartHand m_state;
}; };
// State: Start new round. // State: Start new round.
@@ -210,7 +201,7 @@ public:
virtual ~ServerGameStateStartRound(); virtual ~ServerGameStateStartRound();
virtual void Init() {} virtual void Init(ServerGameThread & /*server*/) {}
// //
virtual int Process(ServerGameThread &server); virtual int Process(ServerGameThread &server);
@@ -222,7 +213,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateStartRound> Ptr; static ServerGameStateStartRound m_state;
}; };
// State: Wait for a player action. // State: Wait for a player action.
@@ -248,7 +239,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateWaitPlayerAction> Ptr; static ServerGameStateWaitPlayerAction m_state;
}; };
// State: Delay and computer action // State: Delay and computer action
@@ -272,7 +263,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateComputerAction> Ptr; static ServerGameStateComputerAction m_state;
}; };
// State: Delay after dealing cards // State: Delay after dealing cards
@@ -296,7 +287,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateDealCardsDelay> Ptr; static ServerGameStateDealCardsDelay m_state;
}; };
// State: Delay after showing cards (all in) // State: Delay after showing cards (all in)
@@ -320,7 +311,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateShowCardsDelay> Ptr; static ServerGameStateShowCardsDelay m_state;
}; };
// State: Delay before next hand. // State: Delay before next hand.
@@ -344,7 +335,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateNextHandDelay> Ptr; static ServerGameStateNextHandDelay m_state;
}; };
// State: Delay before next hand. // State: Delay before next hand.
@@ -368,7 +359,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateNextGameDelay> Ptr; static ServerGameStateNextGameDelay m_state;
}; };
// State: Final. // State: Final.
@@ -380,7 +371,7 @@ public:
virtual ~ServerGameStateFinal(); virtual ~ServerGameStateFinal();
virtual void Init() {} virtual void Init(ServerGameThread & /*server*/) {}
protected: protected:
@@ -391,7 +382,7 @@ protected:
private: private:
static boost::thread_specific_ptr<ServerGameStateFinal> Ptr; static ServerGameStateFinal m_state;
}; };
#ifdef _MSC_VER #ifdef _MSC_VER
src/net/servergamethread.h
+7
View File
@@ -24,6 +24,7 @@
#include <net/sessionmanager.h> #include <net/sessionmanager.h>
#include <gui/guiinterface.h> #include <gui/guiinterface.h>
#include <gamedata.h> #include <gamedata.h>
#include <core/boost/timers.hpp>
#include <deque> #include <deque>
@@ -108,6 +109,9 @@ protected:
ServerGameState &GetState(); ServerGameState &GetState();
void SetState(ServerGameState &newState); void SetState(ServerGameState &newState);
const boost::timers::portable::microsec_timer &GetStateTimer() const;
boost::timers::portable::microsec_timer &GetStateTimer();
SenderThread &GetSender(); SenderThread &GetSender();
ReceiverHelper &GetReceiver(); ReceiverHelper &GetReceiver();
@@ -153,8 +157,11 @@ private:
ServerGameState *m_curState; ServerGameState *m_curState;
unsigned m_gameNum; unsigned m_gameNum;
boost::timers::portable::microsec_timer m_stateTimer;
friend class AbstractServerGameStateReceiving; friend class AbstractServerGameStateReceiving;
friend class AbstractServerGameStateRunning; friend class AbstractServerGameStateRunning;
friend class AbstractServerGameStateTimer;
friend class ServerGameStateInit; friend class ServerGameStateInit;
friend class ServerGameStateWaitAck; friend class ServerGameStateWaitAck;
friend class ServerGameStateStartGame; friend class ServerGameStateStartGame;