Fixed relationship of network session and player data to be consistent with the game engine. Now sending card's values via network. Fixed net packet checks.

src/engine/local_engine/localplayer.cpp

@@ -3219,3 +3219,13 @@ void LocalPlayer::riverEngine3() {
 
 }
 
+void LocalPlayer::setNetSessionData(boost::shared_ptr<SessionData> session)
+{
+	myNetSessionData = session;
+}
+
+boost::shared_ptr<SessionData> LocalPlayer::getNetSessionData()
+{
+	return myNetSessionData;
+}
+

src/engine/local_engine/localplayer.h

@@ -135,10 +135,8 @@ public:
 
 	void evaluation(int, int);
 
-
-	
-	
-
+	void setNetSessionData(boost::shared_ptr<SessionData> session);
+	boost::shared_ptr<SessionData> getNetSessionData();
 
 private:
 
@@ -180,6 +178,7 @@ private:
 	int sBluff;
 	bool sBluffStatus;
 
+	boost::shared_ptr<SessionData> myNetSessionData;
 };
 
 #endif

src/engine/playerinterface.h

@@ -23,6 +23,10 @@
 #include "handinterface.h"
 #include <playerdata.h>
 
+#include <boost/shared_ptr.hpp>
+
+class SessionData;
+
 class PlayerInterface{
 public:
 
@@ -98,6 +102,8 @@ public:
 	virtual void turnEngine() =0;
 	virtual void riverEngine() =0;
 
+	virtual void setNetSessionData(boost::shared_ptr<SessionData> session) =0;
+	virtual boost::shared_ptr<SessionData> getNetSessionData() =0;
 };
 
 #endif

src/game.cpp

@@ -67,6 +67,7 @@ Game::Game(GuiInterface* gui, const PlayerDataList &playerDataList, const GameDa
 		string myAvatarFile;
 		unsigned uniqueId = 0;
 		PlayerType type = PLAYER_TYPE_COMPUTER;
+		boost::shared_ptr<SessionData> myNetSession;
 
 		if (player_i != player_end)
 		{
@@ -74,12 +75,14 @@ Game::Game(GuiInterface* gui, const PlayerDataList &playerDataList, const GameDa
 			type = (*player_i)->GetType();
 			myName = (*player_i)->GetName();
 			myAvatarFile = (*player_i)->GetAvatarFile();
+			myNetSession = (*player_i)->GetNetSessionData();
 			// TODO: set player type
 			++player_i;
 		}
 
 		//PlayerObjekte erzeugen
 		playerArray[i] = myFactory->createPlayer(actualBoard, i, uniqueId, type, myName, myAvatarFile, startCash, startQuantityPlayers > i, 0);
+		playerArray[i]->setNetSessionData(myNetSession);
 	}
 	actualBoard->setPlayer(playerArray);
 }

src/game.h

@@ -47,6 +47,8 @@ public:
 
 	HandInterface *getCurrentHand();
 
+	PlayerInterface** getPlayerArray() {return playerArray;}
+
 	//Zufgriff Startvariablen
 	void setStartQuantityPlayers(const int& theValue) { startQuantityPlayers = theValue; }
 	int getStartQuantityPlayers() const { return startQuantityPlayers; }

src/gui/generic/genericservergui.cpp

@@ -18,7 +18,7 @@
  ***************************************************************************/
 
 #include "genericservergui.h"
-
+#include <session.h>
 
 using namespace std;
 
@@ -39,6 +39,7 @@ void GenericServerGui::initGui(int speed)
 
 Session &GenericServerGui::getSession()
 {
+	assert(mySession.get());
 	return *mySession;
 }
 
@@ -49,5 +50,6 @@ void GenericServerGui::setSession(boost::shared_ptr<Session> session)
 
 void GenericServerGui::waitForNetworkAction(GameState state, unsigned uniquePlayerId)
 {
+	getSession().waitForNetworkServerAction(state, uniquePlayerId);
 }
 

src/gui/generic/serverguiwrapper.cpp

@@ -57,6 +57,7 @@ void
 ServerGuiWrapper::waitForNetworkAction(GameState state, unsigned uniquePlayerId)
 {
 	/* TODO hack */
+	myGui->waitForNetworkAction(state, uniquePlayerId);
 }
 
 void ServerGuiWrapper::refreshSet() const {}

src/net/clientthread.h

@@ -95,6 +95,7 @@ friend class ClientStateConnecting;
 friend class ClientStateStartSession;
 friend class ClientStateWaitSession;
 friend class ClientStateWaitGame;
+friend class ClientStateFinal;
 };
 
 #endif

src/net/common/clientstate.cpp

@@ -416,7 +416,6 @@ ClientStateWaitGame::Process(ClientThread &client)
 	ClientContext &context = client.GetContext();
 
 	// delegate to receiver helper class
-
 	boost::shared_ptr<NetPacket> tmpPacket = client.GetReceiver().Recv(context.GetSocket());
 
 	if (tmpPacket.get())
@@ -424,7 +423,7 @@ ClientStateWaitGame::Process(ClientThread &client)
 		if (tmpPacket->ToNetPacketGameStart())
 		{
 			client.SetState(ClientStateFinal::Instance());
-			retVal = MSG_NET_GAME_START;
+			retVal = MSG_NET_GAME_CLIENT_START;
 		}
 		else if (tmpPacket->ToNetPacketPlayerJoined())
 		{
@@ -467,7 +466,21 @@ ClientStateFinal::~ClientStateFinal()
 int
 ClientStateFinal::Process(ClientThread &client)
 {
-	Thread::Msleep(CLIENT_WAIT_TIMEOUT_MSEC);
+	ClientContext &context = client.GetContext();
+
+	// delegate to receiver helper class
+	boost::shared_ptr<NetPacket> tmpPacket = client.GetReceiver().Recv(context.GetSocket());
+
+	if (tmpPacket.get())
+	{
+		if (tmpPacket->ToNetPacketHandStart())
+		{
+			// TODO
+			NetPacketHandStart::Data tmpData;
+			tmpPacket->ToNetPacketHandStart()->GetData(tmpData);
+			int z = 1;
+		}
+	}
 
 	return MSG_SOCK_INTERNAL_PENDING;
 }

src/net/common/clientthread.cpp

@@ -106,7 +106,7 @@ ClientThread::Main()
 					GetCallback().SignalNetClientGameInfo(msg);
 
 				// Additionally signal the start of the game.
-				if (msg == MSG_NET_GAME_START)
+				if (msg == MSG_NET_GAME_CLIENT_START)
 					GetCallback().SignalNetClientGameStart(GetGameData());
 			}
 		}

src/net/common/netpacket.cpp

@@ -793,7 +793,7 @@ NetPacketGameStart::Check(const NetPacketHeader* data) const
 //-----------------------------------------------------------------------------
 
 NetPacketHandStart::NetPacketHandStart()
-: NetPacket(NET_TYPE_GAME_START, sizeof(NetPacketGameStartData))
+: NetPacket(NET_TYPE_HAND_START, sizeof(NetPacketHandStartData))
 {
 }
 
@@ -852,7 +852,7 @@ NetPacketHandStart::Check(const NetPacketHeader* data) const
 		throw NetException(ERR_SOCK_INVALID_PACKET, 0);
 	}
 
-	NetPacketHandStartData *tmpData = (NetPacketHandStartData *)GetRawData();
+	NetPacketHandStartData *tmpData = (NetPacketHandStartData *)data;
 	if (ntohs(tmpData->yourCards[0]) > 51 || ntohs(tmpData->yourCards[1]) > 51)
 	{
 		throw NetException(ERR_SOCK_INVALID_PACKET, 0);
@@ -922,7 +922,7 @@ NetPacketPlayersTurn::Check(const NetPacketHeader* data) const
 	}
 
 	// Check whether the state is valid.
-	NetPacketPlayersTurnData *tmpData = (NetPacketPlayersTurnData *)GetRawData();
+	NetPacketPlayersTurnData *tmpData = (NetPacketPlayersTurnData *)data;
 	if (ntohs(tmpData->gameState) > GAME_STATE_RIVER)
 	{
 		throw NetException(ERR_SOCK_INVALID_PACKET, 0);
@@ -994,7 +994,7 @@ NetPacketPlayersAction::Check(const NetPacketHeader* data) const
 	}
 
 	// Check whether the state is valid.
-	NetPacketPlayersActionData *tmpData = (NetPacketPlayersActionData *)GetRawData();
+	NetPacketPlayersActionData *tmpData = (NetPacketPlayersActionData *)data;
 	if (ntohs(tmpData->gameState) > GAME_STATE_RIVER)
 	{
 		throw NetException(ERR_SOCK_INVALID_PACKET, 0);
@@ -1076,7 +1076,7 @@ NetPacketPlayersActionRejected::Check(const NetPacketHeader* data) const
 	}
 
 	// Check whether the state is valid.
-	NetPacketPlayersActionRejectedData *tmpData = (NetPacketPlayersActionRejectedData *)GetRawData();
+	NetPacketPlayersActionRejectedData *tmpData = (NetPacketPlayersActionRejectedData *)data;
 	if (ntohs(tmpData->gameState) > GAME_STATE_RIVER)
 	{
 		throw NetException(ERR_SOCK_INVALID_PACKET, 0);

src/net/common/serverrecvstate.cpp

@@ -26,6 +26,8 @@
 #include <net/netexception.h>
 #include <core/rand.h>
 #include <gamedata.h>
+#include <game.h>
+#include <playerinterface.h>
 
 using namespace std;
 
@@ -75,14 +77,14 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 
 	if (recvSock != INVALID_SOCKET)
 	{
-		boost::shared_ptr<SessionData> session = server.GetSession(recvSock);
+		SessionWrapper session = server.GetSession(recvSock);
 		boost::shared_ptr<NetPacket> packet;
 		try
 		{
 			packet = server.GetReceiver().Recv(recvSock);
 		} catch (const NetException &)
 		{
-			if (session.get())
+			if (session.sessionData.get())
 			{
 				server.CloseSessionDelayed(session);
 				return retVal;
@@ -90,10 +92,10 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 		}
 
 		// Ignore if no session / no packet.
-		if (packet.get() && session.get())
+		if (packet.get() && session.sessionData.get())
 		{
 			// Session should be in initial state.
-			if (session->GetState() != SessionData::Init)
+			if (session.sessionData->GetState() != SessionData::Init)
 			{
 				server.SessionError(session, ERR_SOCK_INVALID_STATE);
 				return retVal;
@@ -144,13 +146,14 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			boost::shared_ptr<PlayerData> tmpPlayerData(
 				new PlayerData(m_curUniquePlayerId++, server.GetNextPlayerNumber(), joinGameData.ptype));
 			tmpPlayerData->SetName(joinGameData.playerName);
+			tmpPlayerData->SetNetSessionData(session.sessionData);
 
 			// Send ACK to client.
 			boost::shared_ptr<NetPacket> answer(new NetPacketJoinGameAck);
 			NetPacketJoinGameAck::Data joinGameAckData;
 			joinGameAckData.playerId = tmpPlayerData->GetUniqueId();
 			joinGameAckData.playerNumber = tmpPlayerData->GetNumber();
-			joinGameAckData.sessionId = session->GetId(); // TODO: currently unused.
+			joinGameAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
 			joinGameAckData.gameData = server.GetGameData();
 			static_cast<NetPacketJoinGameAck *>(answer.get())->SetData(joinGameAckData);
 			server.GetSender().Send(recvSock, answer);
@@ -168,7 +171,7 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 				otherPlayerJoinedData.playerNumber = (*player_i)->GetNumber();
 				otherPlayerJoinedData.ptype = (*player_i)->GetType();
 				static_cast<NetPacketPlayerJoined *>(otherPlayerJoined.get())->SetData(otherPlayerJoinedData);
-				server.GetSender().Send(session->GetSocket(), otherPlayerJoined);
+				server.GetSender().Send(session.sessionData->GetSocket(), otherPlayerJoined);
 
 				++player_i;
 			}
@@ -181,13 +184,13 @@ ServerRecvStateInit::Process(ServerRecvThread &server)
 			thisPlayerJoinedData.playerNumber = tmpPlayerData->GetNumber();
 			thisPlayerJoinedData.ptype = tmpPlayerData->GetType();
 			static_cast<NetPacketPlayerJoined *>(thisPlayerJoined.get())->SetData(thisPlayerJoinedData);
-			server.SendToAllButOnePlayers(thisPlayerJoined, session->GetSocket());
+			server.SendToAllButOnePlayers(thisPlayerJoined, session.sessionData->GetSocket());
 
 			// Set player data for session.
-			server.SetSessionPlayerData(session, tmpPlayerData);
+			server.SetSessionPlayerData(session.sessionData, tmpPlayerData);
 
 			// Session is now established.
-			session->SetState(SessionData::Established);
+			session.sessionData->SetState(SessionData::Established);
 		}
 	}
 	return retVal;
@@ -222,10 +225,93 @@ ServerRecvStateStartGame::Process(ServerRecvThread &server)
 	boost::shared_ptr<NetPacket> answer(new NetPacketGameStart);
 
 	server.SendToAllPlayers(answer);
-	Thread::Msleep(100);
+	server.SetState(ServerRecvStateStartHand::Instance());
+
+	return MSG_NET_GAME_SERVER_START;
+}
+
+//-----------------------------------------------------------------------------
+
+ServerRecvStateStartHand &
+ServerRecvStateStartHand::Instance()
+{
+	static ServerRecvStateStartHand state;
+	return state;
+}
+
+ServerRecvStateStartHand::ServerRecvStateStartHand()
+{
+}
+
+ServerRecvStateStartHand::~ServerRecvStateStartHand()
+{
+}
+
+void
+ServerRecvStateStartHand::HandleNewConnection(ServerRecvThread &server, boost::shared_ptr<ConnectData> connData)
+{
+	// TODO: send error msg
+}
+
+int
+ServerRecvStateStartHand::Process(ServerRecvThread &server)
+{
+	boost::shared_ptr<NetPacket> answer(new NetPacketHandStart);
+
+	Game &curGame = server.GetGame();
+	curGame.initHand();
+	PlayerInterface **playerArray = curGame.getPlayerArray();
+
+	for (int i = 0; i < curGame.getActualQuantityPlayers(); i++)
+	{
+		if (playerArray[i]->getNetSessionData().get())
+		{
+			int cards[2];
+			playerArray[i]->getMyCards(cards);
+			boost::shared_ptr<NetPacket> notification(new NetPacketHandStart);
+			NetPacketHandStart::Data handStartData;
+			handStartData.yourCards[0] = static_cast<unsigned>(cards[0]);
+			handStartData.yourCards[1] = static_cast<unsigned>(cards[1]);
+			static_cast<NetPacketHandStart *>(notification.get())->SetData(handStartData);
+
+			server.GetSender().Send(playerArray[i]->getNetSessionData()->GetSocket(), notification);
+		}
+	}
+
+	server.SetState(ServerRecvStateFinal::Instance());
+
+	return MSG_NET_GAME_SERVER_HAND;
+}
+
+//-----------------------------------------------------------------------------
+
+ServerRecvStateFinal &
+ServerRecvStateFinal::Instance()
+{
+	static ServerRecvStateFinal state;
+	return state;
+}
+
+ServerRecvStateFinal::ServerRecvStateFinal()
+{
+}
+
+ServerRecvStateFinal::~ServerRecvStateFinal()
+{
+}
+
+void
+ServerRecvStateFinal::HandleNewConnection(ServerRecvThread &server, boost::shared_ptr<ConnectData> connData)
+{
+	// TODO: send error msg
+}
+
+int
+ServerRecvStateFinal::Process(ServerRecvThread &server)
+{
+	Thread::Msleep(10);
 
 	return MSG_SOCK_INTERNAL_PENDING;
 }
 
 //-----------------------------------------------------------------------------
-

src/net/common/serverrecvthread.cpp

@@ -51,8 +51,8 @@ private:
 };
 
 
-ServerRecvThread::ServerRecvThread(ServerCallback &cb)
-: m_callback(cb)
+ServerRecvThread::ServerRecvThread(GuiInterface &gui, ConfigFile *playerConfig)
+: m_curGameId(0), m_gui(gui), m_playerConfig(playerConfig)
 {
 	m_senderCallback.reset(new ServerSenderCallback(*this));
 	m_sender.reset(new SenderThread(GetSenderCallback()));
@@ -247,14 +247,16 @@ ServerRecvThread::CleanupSessionMap()
 void
 ServerRecvThread::InternalStartGame()
 {
-//	m_game.reset(...);
+	GuiInterface &gui = GetGui();
+	PlayerDataList playerData = GetPlayerDataList();
+	m_game.reset(new Game(&gui, playerData, GetGameData(), m_curGameId++, m_playerConfig));
 	SetState(SERVER_START_GAME_STATE::Instance());
 }
 
-boost::shared_ptr<SessionData>
+SessionWrapper
 ServerRecvThread::GetSession(SOCKET sock)
 {
-	boost::shared_ptr<SessionData> tmpSession;
+	SessionWrapper tmpSession;
 	boost::mutex::scoped_lock lock(m_sessionMapMutex);
 
 	SocketSessionMap::iterator pos = m_sessionMap.find(sock);
@@ -278,27 +280,27 @@ ServerRecvThread::AddSession(boost::shared_ptr<SessionData> sessionData)
 	{
 		throw ServerException(ERR_SOCK_CONN_EXISTS, 0);
 	}
-	m_sessionMap.insert(pos, SocketSessionMap::value_type(sessionData->GetSocket(), sessionData));
+	m_sessionMap.insert(pos, SocketSessionMap::value_type(sessionData->GetSocket(), SessionWrapper(sessionData, boost::shared_ptr<PlayerData>())));
 }
 
 void
-ServerRecvThread::SessionError(boost::shared_ptr<SessionData> sessionData, int errorCode)
+ServerRecvThread::SessionError(SessionWrapper session, int errorCode)
 {
-	assert(sessionData.get());
-	SendError(sessionData->GetSocket(), errorCode);
-	CloseSessionDelayed(sessionData);
+	assert(session.sessionData.get());
+	SendError(session.sessionData->GetSocket(), errorCode);
+	CloseSessionDelayed(session);
 }
 
 void
-ServerRecvThread::CloseSessionDelayed(boost::shared_ptr<SessionData> sessionData)
+ServerRecvThread::CloseSessionDelayed(SessionWrapper session)
 {
 	{
 		boost::mutex::scoped_lock lock(m_sessionMapMutex);
 
-		m_sessionMap.erase(sessionData->GetSocket());
+		m_sessionMap.erase(session.sessionData->GetSocket());
 	}
 
-	boost::shared_ptr<PlayerData> tmpPlayerData = sessionData->GetPlayerData();
+	boost::shared_ptr<PlayerData> tmpPlayerData = session.playerData;
 	if (tmpPlayerData.get() && !tmpPlayerData->GetName().empty())
 	{
 		GetCallback().SignalNetServerPlayerLeft(tmpPlayerData->GetName());
@@ -313,7 +315,7 @@ ServerRecvThread::CloseSessionDelayed(boost::shared_ptr<SessionData> sessionData
 
 	boost::microsec_timer closeTimer;
 	closeTimer.start();
-	CloseSessionList::value_type closeSessionData(closeTimer, sessionData);
+	CloseSessionList::value_type closeSessionData(closeTimer, session.sessionData);
 	m_closeSessionList.push_back(closeSessionData);
 }
 
@@ -349,10 +351,20 @@ ServerRecvThread::IsPlayerConnected(const std::string &playerName) const
 void
 ServerRecvThread::SetSessionPlayerData(boost::shared_ptr<SessionData> sessionData, boost::shared_ptr<PlayerData> playerData)
 {
-	sessionData->SetPlayerData(playerData);
-	// Signal joining player to GUI.
 	if (playerData.get() && !playerData->GetName().empty())
-		GetCallback().SignalNetServerPlayerJoined(playerData->GetName());
+	{
+		assert(sessionData.get());
+		boost::mutex::scoped_lock lock(m_sessionMapMutex);
+
+		SocketSessionMap::iterator pos = m_sessionMap.find(sessionData->GetSocket());
+		if (pos != m_sessionMap.end())
+		{
+			pos->second.playerData = playerData;
+
+			// Signal joining player to GUI.
+			GetCallback().SignalNetServerPlayerJoined(playerData->GetName());
+		}
+	}
 }
 
 PlayerDataList
@@ -366,7 +378,7 @@ ServerRecvThread::GetPlayerDataList() const
 
 	while (session_i != session_end)
 	{
-		boost::shared_ptr<PlayerData> tmpPlayer(session_i->second->GetPlayerData());
+		boost::shared_ptr<PlayerData> tmpPlayer(session_i->second.playerData);
 		if (tmpPlayer.get() && !tmpPlayer->GetName().empty())
 			playerList.push_back(tmpPlayer);
 		++session_i;
@@ -446,7 +458,7 @@ ServerRecvThread::SendToAllButOnePlayers(boost::shared_ptr<NetPacket> packet, SO
 ServerCallback &
 ServerRecvThread::GetCallback()
 {
-	return m_callback;
+	return m_gui;
 }
 
 ServerRecvState &
@@ -503,3 +515,9 @@ ServerRecvThread::GetSenderCallback()
 	return *m_senderCallback;
 }
 
+GuiInterface &
+ServerRecvThread::GetGui()
+{
+	return m_gui;
+}
+

src/net/common/serverthread.cpp

@@ -29,11 +29,11 @@
 #define NET_SERVER_LISTEN_BACKLOG	5
 
 
-ServerThread::ServerThread(ServerCallback &cb)
-: m_callback(cb)
+ServerThread::ServerThread(GuiInterface &gui, ConfigFile *config)
+: m_gui(gui)
 {
 	m_context.reset(new ServerContext);
-	m_recvThread.reset(new ServerRecvThread(cb));
+	m_recvThread.reset(new ServerRecvThread(gui, config));
 }
 
 ServerThread::~ServerThread()
@@ -78,7 +78,13 @@ ServerThread::WaitForClientAction(GameState state, unsigned uniquePlayerId)
 ServerCallback &
 ServerThread::GetCallback()
 {
-	return m_callback;
+	return m_gui;
+}
+
+GuiInterface &
+ServerThread::GetGui()
+{
+	return m_gui;
 }
 
 void

src/net/serverrecvstate.h

@@ -88,4 +88,46 @@ protected:
 	ServerRecvStateStartGame();
 };
 
+// State: Start new hand.
+class ServerRecvStateStartHand : public ServerRecvState
+{
+public:
+	// Access the state singleton.
+	static ServerRecvStateStartHand &Instance();
+
+	virtual ~ServerRecvStateStartHand();
+
+	// 
+	virtual void HandleNewConnection(ServerRecvThread &server, boost::shared_ptr<ConnectData> data);
+
+	// 
+	virtual int Process(ServerRecvThread &server);
+
+protected:
+
+	// Protected constructor - this is a singleton.
+	ServerRecvStateStartHand();
+};
+
+// State: Final.
+class ServerRecvStateFinal : public ServerRecvState
+{
+public:
+	// Access the state singleton.
+	static ServerRecvStateFinal &Instance();
+
+	virtual ~ServerRecvStateFinal();
+
+	// 
+	virtual void HandleNewConnection(ServerRecvThread &server, boost::shared_ptr<ConnectData> data);
+
+	// 
+	virtual int Process(ServerRecvThread &server);
+
+protected:
+
+	// Protected constructor - this is a singleton.
+	ServerRecvStateFinal();
+};
+
 #endif

src/net/serverrecvthread.h

@@ -24,7 +24,7 @@
 #include <core/thread.h>
 #include <net/connectdata.h>
 #include <net/sessiondata.h>
-#include <net/servercallback.h>
+#include <gui/guiinterface.h>
 
 #include <deque>
 #include <map>
@@ -44,13 +44,23 @@ class SenderThread;
 class ReceiverHelper;
 class ServerSenderCallback;
 class NetPacket;
+class ConfigFile;
 struct GameData;
 class Game;
 
+struct SessionWrapper
+{
+	SessionWrapper() {}
+	SessionWrapper(boost::shared_ptr<SessionData> s, boost::shared_ptr<PlayerData> p)
+		: sessionData(s), playerData(p) {}
+	boost::shared_ptr<SessionData>	sessionData;
+	boost::shared_ptr<PlayerData>	playerData;
+};
+
 class ServerRecvThread : public Thread
 {
 public:
-	ServerRecvThread(ServerCallback &gui);
+	ServerRecvThread(GuiInterface &gui, ConfigFile *playerConfig);
 	virtual ~ServerRecvThread();
 
 	void Init(const std::string &pwd, const GameData &gameData);
@@ -72,7 +82,7 @@ protected:
 	};
 
 	typedef std::deque<boost::shared_ptr<ConnectData> > ConnectQueue;
-	typedef std::map<SOCKET, boost::shared_ptr<SessionData> > SocketSessionMap;
+	typedef std::map<SOCKET, SessionWrapper> SocketSessionMap;
 	typedef std::deque<Notification> NotificationQueue;
 	typedef std::list<std::pair<boost::microsec_timer, boost::shared_ptr<SessionData> > > CloseSessionList;
 
@@ -89,10 +99,10 @@ protected:
 
 	void InternalStartGame();
 
-	boost::shared_ptr<SessionData> GetSession(SOCKET sock);
-	void AddSession(boost::shared_ptr<SessionData> sessionData);
-	void SessionError(boost::shared_ptr<SessionData> sessionData, int errorCode);
-	void CloseSessionDelayed(boost::shared_ptr<SessionData> sessionData);
+	SessionWrapper GetSession(SOCKET sock);
+	void AddSession(boost::shared_ptr<SessionData> sessionData); // new Sessions have no player data
+	void SessionError(SessionWrapper session, int errorCode);
+	void CloseSessionDelayed(SessionWrapper session);
 
 	size_t GetCurNumberOfPlayers() const;
 	bool IsPlayerConnected(const std::string &playerName) const;
@@ -116,6 +126,7 @@ protected:
 	bool CheckPassword(const std::string &password) const;
 
 	ServerSenderCallback &GetSenderCallback();
+	GuiInterface &GetGui();
 
 private:
 
@@ -136,14 +147,18 @@ private:
 
 	std::auto_ptr<Game> m_game;
 	std::auto_ptr<GameData> m_gameData;
+	unsigned m_curGameId;
 	std::auto_ptr<ServerSenderCallback> m_senderCallback;
 
 	std::string m_password;
 
-	ServerCallback &m_callback;
+	GuiInterface &m_gui;
+
+	ConfigFile *m_playerConfig;
 
 friend class ServerRecvStateInit;
 friend class ServerRecvStateStartGame;
+friend class ServerRecvStateStartHand;
 };
 
 #endif

src/net/serverthread.h

@@ -23,20 +23,21 @@
 
 #include <game_defs.h>
 #include <core/thread.h>
+#include <gui/guiinterface.h>
 #include <string>
 #include <memory>
-#include <net/servercallback.h>
 
 class ServerContext;
 class ServerRecvThread;
 class ServerSenderCallback;
 class SenderThread;
+class ConfigFile;
 struct GameData;
 
 class ServerThread : public Thread
 {
 public:
-	ServerThread(ServerCallback &gui);
+	ServerThread(GuiInterface &gui, ConfigFile *config);
 	virtual ~ServerThread();
 
 	// Set the parameters.
@@ -46,6 +47,7 @@ public:
 	void WaitForClientAction(GameState state, unsigned uniquePlayerId);
 
 	ServerCallback &GetCallback();
+	GuiInterface &GetGui();
 
 protected:
 
@@ -64,7 +66,7 @@ private:
 	std::auto_ptr<ServerContext> m_context;
 	std::auto_ptr<ServerRecvThread> m_recvThread;
 
-	ServerCallback &m_callback;
+	GuiInterface &m_gui;
 };
 
 #endif

src/net/sessiondata.h

@@ -42,11 +42,6 @@ public:
 	void SetState(State state)
 	{m_state = state;}
 
-	const boost::shared_ptr<PlayerData> GetPlayerData() const
-	{return m_playerData;}
-	void SetPlayerData(boost::shared_ptr<PlayerData> playerData)
-	{m_playerData = playerData;}
-
 	SOCKET GetSocket() const
 	{return m_sockfd;}
 
@@ -60,7 +55,6 @@ private:
 	unsigned						m_id;
 	State							m_state;
 	std::string						m_clientAddr;
-	boost::shared_ptr<PlayerData>	m_playerData;
 };
 
 #endif

src/net/socket_msg.h

@@ -61,7 +61,10 @@
 #define MSG_SOCK_LAST					MSG_SOCK_SESSION_DONE
 
 // The following messages are game messages.
-#define MSG_NET_GAME_START				5
+#define MSG_NET_GAME_CLIENT_START		5
+#define MSG_NET_GAME_SERVER_START		6
+#define MSG_NET_GAME_CLIENT_HAND		7
+#define MSG_NET_GAME_SERVER_HAND		8
 
 #endif
 

src/playerdata.h

@@ -26,6 +26,8 @@
 #include <map>
 #include <boost/shared_ptr.hpp>
 
+class SessionData;
+
 enum PlayerType
 {
 	PLAYER_TYPE_COMPUTER,
@@ -46,6 +48,10 @@ public:
 	{return m_avatarFile;}
 	void SetAvatarFile(const std::string &avatarFile)
 	{m_avatarFile = avatarFile;}
+	boost::shared_ptr<SessionData> GetNetSessionData()
+	{return m_netSessionData;}
+	void SetNetSessionData(boost::shared_ptr<SessionData> session)
+	{m_netSessionData = session;}
 	PlayerType GetType() const
 	{return m_type;}
 	unsigned GetUniqueId() const
@@ -57,11 +63,12 @@ public:
 	{return m_number < other.GetNumber();}
 
 private:
-	unsigned	m_uniqueId;
-	int			m_number;
-	std::string	m_name;
-	std::string	m_avatarFile;
-	PlayerType	m_type;
+	unsigned						m_uniqueId;
+	int								m_number;
+	std::string						m_name;
+	std::string						m_avatarFile;
+	PlayerType						m_type;
+	boost::shared_ptr<SessionData>	m_netSessionData;
 };
 
 typedef std::list<boost::shared_ptr<PlayerData> > PlayerDataList;

src/session.cpp

@@ -139,7 +139,7 @@ void Session::startNetworkServer(const GameData &gameData)
 {
 	if (myNetServer)
 		return; // TODO: throw exception
-	myNetServer = new ServerThread(*myGui);
+	myNetServer = new ServerThread(*myGui, myConfig);
 	myNetServer->Init(
 		myConfig->readConfigInt("ServerPort"),
 		myConfig->readConfigInt("ServerUseIpv6") == 1,