Builds with protocol changes (currently untested).

2014-12-28 01:03:06 +01:00
parent fdfba430b2
commit 1f6c3d8ccf
44 changed files with 8769 additions and 15778 deletions
@@ -123,7 +123,7 @@ AsioReceiveBuffer::ScanPackets(boost::shared_ptr<SessionData> session)
 			}
 		}
 		if (tmpPacket) {
-			if (validator.IsValidPacket(*tmpPacket)) {
+			if (validator.IsValidMessage(*tmpPacket->GetMsg())) {
 				receivedPackets.push_back(tmpPacket);
 			} else {
 				LOG_ERROR("Session " << session->GetId() << " - Invalid packet: " << tmpPacket->GetMsg()->messagetype());
@@ -587,8 +587,7 @@ AbstractClientStateReceiving::HandleLobbyMsg(boost::shared_ptr<ClientThread> cli
 			client->SetPlayerInfo(
 				playerId,
 				tmpInfo);
-		}
-		else {
+		} else {
 			client->SetUnknownPlayer(playerId);
 		}
 	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_TimeoutWarningMessage) {
@@ -733,8 +732,7 @@ AbstractClientStateReceiving::HandleLobbyMsg(boost::shared_ptr<ClientThread> cli
 			break;
 		}
 		client->GetCallback().SignalNetClientMsgBox(msgCode);
-	}
-	else if (lobbyMsg.messagetype() == LobbyMessage::Type_ReportGameAckMessage) {
+	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_ReportGameAckMessage) {
 		const ReportGameAckMessage &netReportAck = lobbyMsg.reportgameackmessage();
 		unsigned msgCode;
 		switch (netReportAck.reportgameresult()) {
@@ -795,7 +793,7 @@ AbstractClientStateReceiving::HandleLobbyMsg(boost::shared_ptr<ClientThread> cli
 			}
 			client->UpdateStatData(tmpStats);
 		}
-	} else if (lobbyMsg.messagetype() == GameManagementMessage::Type_ErrorMessage) {
+	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_ErrorMessage) {
 		// Server reported an error.
 		const ErrorMessage &netError = lobbyMsg.errormessage();
 		// Show the error.
@@ -808,8 +806,7 @@ AbstractClientStateReceiving::HandleLobbyMsg(boost::shared_ptr<ClientThread> cli
 void
 AbstractClientStateReceiving::HandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
 {
-	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage)
-	{
+	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
 		const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
 		if (managementMsg.messagetype() == GameManagementMessage::Type_RemovedFromGameMessage) {
 			const RemovedFromGameMessage &netRemoved = managementMsg.removedfromgamemessage();
@@ -845,8 +842,7 @@ AbstractClientStateReceiving::HandleGameMsg(boost::shared_ptr<ClientThread> clie
 			}
 			client->GetCallback().SignalNetClientRemovedFromGame(removeReason);
 			client->SetState(ClientStateWaitJoin::Instance());
-		}
-		else if (managementMsg.messagetype() == GameManagementMessage::Type_GamePlayerLeftMessage) {
+		} else if (managementMsg.messagetype() == GameManagementMessage::Type_GamePlayerLeftMessage) {
 			// A player left the game.
 			const GamePlayerLeftMessage &netLeft = managementMsg.gameplayerleftmessage();

@@ -867,22 +863,19 @@ AbstractClientStateReceiving::HandleGameMsg(boost::shared_ptr<ClientThread> clie
 				break;
 			}
 			client->RemovePlayerData(netLeft.playerid(), removeReason);
-		}
-		else if (managementMsg.messagetype() == GameManagementMessage::Type_GameAdminChangedMessage) {
+		} else if (managementMsg.messagetype() == GameManagementMessage::Type_GameAdminChangedMessage) {
 			// New admin for the game.
 			const GameAdminChangedMessage &netChanged = managementMsg.gameadminchangedmessage();

 			// Set new game admin and signal to GUI.
 			client->SetNewGameAdmin(netChanged.newadminplayerid());
-		}
-		else if (managementMsg.messagetype() == GameManagementMessage::Type_GamePlayerJoinedMessage) {
+		} else if (managementMsg.messagetype() == GameManagementMessage::Type_GamePlayerJoinedMessage) {
 			// Another player joined the network game.
 			const GamePlayerJoinedMessage &netPlayerJoined = managementMsg.gameplayerjoinedmessage();

 			boost::shared_ptr<PlayerData> playerData = client->CreatePlayerData(netPlayerJoined.playerid(), netPlayerJoined.isgameadmin());
 			client->AddPlayerData(playerData);
-		}
-		else if (managementMsg.messagetype() == GameManagementMessage::Type_GameSpectatorJoinedMessage) {
+		} else if (managementMsg.messagetype() == GameManagementMessage::Type_GameSpectatorJoinedMessage) {
 			// Another spectator joined the network game.
 			const GameSpectatorJoinedMessage &netSpectatorJoined = managementMsg.gamespectatorjoinedmessage();
 			// Request player info if needed.
@@ -891,8 +884,7 @@ AbstractClientStateReceiving::HandleGameMsg(boost::shared_ptr<ClientThread> clie
 				client->RequestPlayerInfo(netSpectatorJoined.playerid());
 			}
 			client->ModifyGameInfoAddSpectatorDuringGame(netSpectatorJoined.playerid());
-		}
-		else if (managementMsg.messagetype() == GameManagementMessage::Type_GameSpectatorLeftMessage) {
+		} else if (managementMsg.messagetype() == GameManagementMessage::Type_GameSpectatorLeftMessage) {
 			// A spectator left the network game.
 			const GameSpectatorLeftMessage &netSpectatorLeft = managementMsg.gamespectatorleftmessage();
 			// Signal to GUI and remove from data list.
@@ -937,11 +929,11 @@ AbstractClientStateReceiving::HandleGameMsg(boost::shared_ptr<ClientThread> clie
 		} else if (managementMsg.messagetype() == GameManagementMessage::Type_StartKickPetitionMessage) {
 			const StartKickPetitionMessage &netStartPetition = managementMsg.startkickpetitionmessage();
 			client->StartPetition(netStartPetition.petitionid(), netStartPetition.proposingplayerid(),
-				netStartPetition.kickplayerid(), netStartPetition.kicktimeoutsec(), netStartPetition.numvotesneededtokick());
+								  netStartPetition.kickplayerid(), netStartPetition.kicktimeoutsec(), netStartPetition.numvotesneededtokick());
 		} else if (managementMsg.messagetype() == GameManagementMessage::Type_KickPetitionUpdateMessage) {
 			const KickPetitionUpdateMessage &netPetitionUpdate = managementMsg.kickpetitionupdatemessage();
 			client->UpdatePetition(netPetitionUpdate.petitionid(), netPetitionUpdate.numvotesagainstkicking(),
-				netPetitionUpdate.numvotesinfavourofkicking(), netPetitionUpdate.numvotesneededtokick());
+								   netPetitionUpdate.numvotesinfavourofkicking(), netPetitionUpdate.numvotesneededtokick());
 		} else if (managementMsg.messagetype() == GameManagementMessage::Type_EndKickPetitionMessage) {
 			const EndKickPetitionMessage &netEndPetition = managementMsg.endkickpetitionmessage();
 			client->EndPetition(netEndPetition.petitionid());
@@ -993,10 +985,9 @@ ClientStateStartSession::InternalHandleAnnounceMsg(boost::shared_ptr<ClientThrea
 	// Server has send announcement - check data.
 	// Check current game version.
 	if (announceMsg.latestgameversion().majorversion() != POKERTH_VERSION_MAJOR
-		|| announceMsg.latestgameversion().minorversion() != POKERTH_VERSION_MINOR) {
+			|| announceMsg.latestgameversion().minorversion() != POKERTH_VERSION_MINOR) {
 		client->GetCallback().SignalNetClientNotification(NTF_NET_NEW_RELEASE_AVAILABLE);
-	}
-	else if (POKERTH_BETA_REVISION && announceMsg.latestbetarevision() != POKERTH_BETA_REVISION) {
+	} else if (POKERTH_BETA_REVISION && announceMsg.latestbetarevision() != POKERTH_BETA_REVISION) {
 		client->GetCallback().SignalNetClientNotification(NTF_NET_OUTDATED_BETA);
 	}
 	ClientContext &context = client->GetContext();
@@ -1008,7 +999,7 @@ ClientStateStartSession::InternalHandleAnnounceMsg(boost::shared_ptr<ClientThrea
 	}
 	// CASE 2: Unauthenticated login (network game or dedicated server without auth backend).
 	else if (announceMsg.servertype() == AnnounceMessage::serverTypeInternetNoAuth
-		|| announceMsg.servertype() == AnnounceMessage::serverTypeLAN) {
+			 || announceMsg.servertype() == AnnounceMessage::serverTypeLAN) {
 		boost::shared_ptr<NetPacket> auth(new NetPacket);
 		auth->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
 		AuthMessage *netAuth = auth->GetMsg()->mutable_authmessage();
@@ -1022,6 +1013,14 @@ ClientStateStartSession::InternalHandleAnnounceMsg(boost::shared_ptr<ClientThrea
 		}
 		authRequest->set_login(AuthClientRequestMessage::unauthenticatedLogin);
 		authRequest->set_nickname(context.GetPlayerName());
+		string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
+		if (!avatarFile.empty()) {
+			MD5Buf tmpMD5;
+			if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5)) {
+				// Send MD5 hash of avatar.
+				authRequest->set_avatarhash(tmpMD5.GetData(), MD5_DATA_SIZE);
+			}
+		}
 		client->GetSender().Send(context.GetSessionData(), auth);
 		client->SetState(ClientStateWaitSession::Instance());
 	}
@@ -1115,6 +1114,14 @@ ClientStateWaitEnterLogin::TimerLoop(const boost::system::error_code& ec, boost:
 					throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0);
 				string outUserData(tmpSession->AuthGetNextOutMsg());
 				authRequest->set_clientuserdata(outUserData);
+				string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
+				if (!avatarFile.empty()) {
+					MD5Buf tmpMD5;
+					if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5)) {
+						// Send MD5 hash of avatar.
+						authRequest->set_avatarhash(tmpMD5.GetData(), MD5_DATA_SIZE);
+					}
+				}
 				client->GetSender().Send(context.GetSessionData(), auth);
 				client->SetState(ClientStateWaitAuthChallenge::Instance());
 			}
@@ -1215,23 +1222,6 @@ ClientStateWaitAuthVerify::InternalHandleAuthMsg(boost::shared_ptr<ClientThread>
 		boost::shared_ptr<SessionData> tmpSession = context.GetSessionData();
 		if (!tmpSession->AuthStep(3, verificationStr.c_str()))
 			throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0);
-		client->SetGuiPlayerId(netAuth.yourplayerid());
-		context.SetSessionGuid(netAuth.yoursessionid());
-
-		boost::shared_ptr<NetPacket> init(new NetPacket);
-		init->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
-		LobbyMessage *netLobby = init->GetMsg()->mutable_lobbymessage();
-		netLobby->set_messagetype(LobbyMessage::Type_InitMessage);
-		InitMessage *netInit = netLobby->mutable_initmessage();
-		string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
-		if (!avatarFile.empty()) {
-			MD5Buf tmpMD5;
-			if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5)) {
-				// Send MD5 hash of avatar.
-				netInit->set_avatarhash(tmpMD5.GetData(), MD5_DATA_SIZE);
-			}
-		}
-		client->GetSender().Send(context.GetSessionData(), init);
 		client->SetState(ClientStateWaitSession::Instance());
 	}
 }
@@ -1266,13 +1256,15 @@ ClientStateWaitSession::Exit(boost::shared_ptr<ClientThread> /*client*/)
 void
 ClientStateWaitSession::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg)
 {
-	if (lobbyMsg.messagetype() == LobbyMessage::Type_InitAckMessage) {
+	if (lobbyMsg.messagetype() == LobbyMessage::Type_InitDoneMessage) {
 		// Everything is fine - we are in the lobby.
-		const InitAckMessage &netInitAck = lobbyMsg.initackmessage();
+		const InitDoneMessage &netInitDone = lobbyMsg.initdonemessage();
+		client->SetGuiPlayerId(netInitDone.yourplayerid());
+		client->GetContext().SetSessionGuid(netInitDone.yoursessionid());
 		client->SetSessionEstablished(true);
 		client->GetCallback().SignalNetClientConnect(MSG_SOCK_SESSION_DONE);
-		if (netInitAck.has_rejoingameid())
-			client->GetCallback().SignalNetClientRejoinPossible(netInitAck.rejoingameid());
+		if (netInitDone.has_rejoingameid())
+			client->GetCallback().SignalNetClientRejoinPossible(netInitDone.rejoingameid());
 		client->SetState(ClientStateWaitJoin::Instance());
 	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarRequestMessage) {
 		// Before letting us join the lobby, the server requests our avatar.
@@ -1321,28 +1313,81 @@ ClientStateWaitJoin::Exit(boost::shared_ptr<ClientThread> /*client*/)
 void
 ClientStateWaitJoin::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg)
 {
+	ClientContext &context = client->GetContext();
 	if (lobbyMsg.messagetype() == LobbyMessage::Type_CreateGameFailedMessage) {
 		// Failed to create a new game.
 		const CreateGameFailedMessage &netCreateFailed = lobbyMsg.creategamefailedmessage();

 		int failureCode;
 		switch (netCreateFailed.creategamefailurereason()) {
-			case CreateGameFailedMessage::notAllowedAsGuest:
-				failureCode = NTF_NET_JOIN_GUEST_FORBIDDEN;
-				break;
-			case CreateGameFailedMessage::gameNameInUse:
-				failureCode = NTF_NET_JOIN_GAME_NAME_IN_USE;
-				break;
-			case CreateGameFailedMessage::badGameName:
-				failureCode = NTF_NET_JOIN_GAME_BAD_NAME;
-				break;
-			case CreateGameFailedMessage::invalidSettings:
-				failureCode = NTF_NET_JOIN_INVALID_SETTINGS;
-				break;
-			default:
-				failureCode = NTF_NET_INTERNAL;
-				break;
+		case CreateGameFailedMessage::notAllowedAsGuest:
+			failureCode = NTF_NET_CREATE_GUEST_FORBIDDEN;
+			break;
+		case CreateGameFailedMessage::gameNameInUse:
+			failureCode = NTF_NET_CREATE_GAME_NAME_IN_USE;
+			break;
+		case CreateGameFailedMessage::badGameName:
+			failureCode = NTF_NET_CREATE_GAME_BAD_NAME;
+			break;
+		case CreateGameFailedMessage::invalidSettings:
+			failureCode = NTF_NET_CREATE_INVALID_SETTINGS;
+			break;
+		default:
+			failureCode = NTF_NET_INTERNAL;
+			break;
 		}
+		client->GetCallback().SignalNetClientNotification(failureCode);
+	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_JoinGameAckMessage) {
+		const JoinGameAckMessage &netJoinAck = lobbyMsg.joingameackmessage();
+		// Successfully joined a game.
+		client->SetGameId(netJoinAck.gameid());
+		GameData tmpData;
+		NetPacket::GetGameData(netJoinAck.gameinfo(), tmpData);
+		client->SetGameData(tmpData);
+		client->ModifyGameInfoClearSpectatorsDuringGame();
+
+		// Player number is 0 on init. Will be set when the game starts.
+		boost::shared_ptr<PlayerData> playerData(
+			new PlayerData(client->GetGuiPlayerId(), 0, PLAYER_TYPE_HUMAN,
+						   context.GetPlayerRights(), netJoinAck.areyougameadmin()));
+		playerData->SetName(context.GetPlayerName());
+		playerData->SetAvatarFile(context.GetAvatarFile());
+		client->AddPlayerData(playerData);
+
+		client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_JOIN);
+		client->SetState(ClientStateWaitGame::Instance());
+	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_JoinGameFailedMessage) {
+		// Failed to join a game.
+		const JoinGameFailedMessage &netJoinFailed = lobbyMsg.joingamefailedmessage();
+
+		int failureCode;
+		switch (netJoinFailed.joingamefailurereason()) {
+		case JoinGameFailedMessage::invalidGame:
+			failureCode = NTF_NET_JOIN_GAME_INVALID;
+			break;
+		case JoinGameFailedMessage::gameIsFull:
+			failureCode = NTF_NET_JOIN_GAME_FULL;
+			break;
+		case JoinGameFailedMessage::gameIsRunning:
+			failureCode = NTF_NET_JOIN_ALREADY_RUNNING;
+			break;
+		case JoinGameFailedMessage::invalidPassword:
+			failureCode = NTF_NET_JOIN_INVALID_PASSWORD;
+			break;
+		case JoinGameFailedMessage::notInvited:
+			failureCode = NTF_NET_JOIN_NOT_INVITED;
+			break;
+		case JoinGameFailedMessage::ipAddressBlocked:
+			failureCode = NTF_NET_JOIN_IP_BLOCKED;
+			break;
+		case JoinGameFailedMessage::rejoinFailed:
+			failureCode = NTF_NET_JOIN_REJOIN_FAILED;
+			break;
+		default:
+			failureCode = NTF_NET_INTERNAL;
+			break;
+		}
+
 		client->GetCallback().SignalNetClientNotification(failureCode);
 	} else if (lobbyMsg.messagetype() == LobbyMessage::Type_InviteNotifyMessage) {
 		const InviteNotifyMessage &netInvNotify = lobbyMsg.invitenotifymessage();
@@ -1352,69 +1397,6 @@ ClientStateWaitJoin::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> clie
 	}
 }

-void
-ClientStateWaitJoin::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
-{
-	ClientContext &context = client->GetContext();
-
-	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
-		const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
-		if (managementMsg.messagetype() == GameManagementMessage::Type_JoinGameAckMessage) {
-			const JoinGameAckMessage &netJoinAck = managementMsg.joingameackmessage();
-			// Successfully joined a game.
-			client->SetGameId(gameMsg.gameid());
-			GameData tmpData;
-			NetPacket::GetGameData(netJoinAck.gameinfo(), tmpData);
-			client->SetGameData(tmpData);
-			client->ModifyGameInfoClearSpectatorsDuringGame();
-
-			// Player number is 0 on init. Will be set when the game starts.
-			boost::shared_ptr<PlayerData> playerData(
-				new PlayerData(client->GetGuiPlayerId(), 0, PLAYER_TYPE_HUMAN,
-				context.GetPlayerRights(), netJoinAck.areyougameadmin()));
-			playerData->SetName(context.GetPlayerName());
-			playerData->SetAvatarFile(context.GetAvatarFile());
-			client->AddPlayerData(playerData);
-
-			client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_JOIN);
-			client->SetState(ClientStateWaitGame::Instance());
-		} else if (managementMsg.messagetype() == GameManagementMessage::Type_JoinGameFailedMessage) {
-			// Failed to join a game.
-			const JoinGameFailedMessage &netJoinFailed = managementMsg.joingamefailedmessage();
-
-			int failureCode;
-			switch (netJoinFailed.joingamefailurereason()) {
-			case JoinGameFailedMessage::invalidGame:
-				failureCode = NTF_NET_JOIN_GAME_INVALID;
-				break;
-			case JoinGameFailedMessage::gameIsFull:
-				failureCode = NTF_NET_JOIN_GAME_FULL;
-				break;
-			case JoinGameFailedMessage::gameIsRunning:
-				failureCode = NTF_NET_JOIN_ALREADY_RUNNING;
-				break;
-			case JoinGameFailedMessage::invalidPassword:
-				failureCode = NTF_NET_JOIN_INVALID_PASSWORD;
-				break;
-			case JoinGameFailedMessage::notInvited:
-				failureCode = NTF_NET_JOIN_NOT_INVITED;
-				break;
-			case JoinGameFailedMessage::ipAddressBlocked:
-				failureCode = NTF_NET_JOIN_IP_BLOCKED;
-				break;
-			case JoinGameFailedMessage::rejoinFailed:
-				failureCode = NTF_NET_JOIN_REJOIN_FAILED;
-				break;
-			default:
-				failureCode = NTF_NET_INTERNAL;
-				break;
-			}
-
-			client->GetCallback().SignalNetClientNotification(failureCode);
-		}
-	}
-}
-
 //-----------------------------------------------------------------------------

 ClientStateWaitGame &
@@ -1463,8 +1445,7 @@ ClientStateWaitGame::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> clie
 void
 ClientStateWaitGame::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
 {
-	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage)
-	{
+	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
 		const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
 		if (managementMsg.messagetype() == GameManagementMessage::Type_StartEventMessage) {
 			const StartEventMessage &netStartEvent = managementMsg.starteventmessage();
@@ -1591,7 +1572,7 @@ ClientStateWaitStart::InternalHandleGameMsg(boost::shared_ptr<ClientThread> clie
 	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
 		const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
 		if (managementMsg.messagetype() == GameManagementMessage::Type_GameStartInitialMessage
-			|| managementMsg.messagetype() == GameManagementMessage::Type_GameStartRejoinMessage) {
+				|| managementMsg.messagetype() == GameManagementMessage::Type_GameStartRejoinMessage) {
 			PlayerIdList tmpPlayerList;
 			unsigned tmpHandId = 0;

@@ -1691,8 +1672,7 @@ ClientStateWaitHand::InternalHandleGameMsg(boost::shared_ptr<ClientThread> clien
 {
 	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
 		const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
-		if (managementMsg.messagetype() == GameManagementMessage::Type_EndOfGameMessage)
-		{
+		if (managementMsg.messagetype() == GameManagementMessage::Type_EndOfGameMessage) {
 			boost::shared_ptr<Game> curGame = client->GetGame();
 			if (curGame) {
 				const EndOfGameMessage &netEndOfGame = managementMsg.endofgamemessage();
@@ -1890,7 +1870,7 @@ ClientStateRunHand::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client
 						tmpPlayer->getMyName(),
 						client->GetClientLog()->transformPlayerActionLog(PlayerAction(netActionDone.playeraction())),
 						netActionDone.totalplayerbet() - tmpPlayer->getMySet()
-						);
+					);
 					if (tmpPlayer->getMyID() == 0) {
 						client->EndPing();
 					}
@@ -1922,7 +1902,7 @@ ClientStateRunHand::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client
 					curGame->getCurrentHand()->getSmallBlind() * 2,
 					curGame->getPlayerByUniqueId(curGame->getCurrentHand()->getCurrentBeRo()->getBigBlindPositionId())->getMyID() + 1,
 					curGame->getSeatsList()
-					);
+				);
 			}

 			// Stop the timeout for the player.
@@ -2051,7 +2031,7 @@ ClientStateRunHand::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client
 			if (curGame->getCurrentHand()->getCurrentRound() < GAME_STATE_RIVER) {
 				client->GetClientLog()->logHoleCardsHandName(
 					curGame->getActivePlayerList()
-					);
+				);
 			}
 		} else if (engineMsg.messagetype() == GameEngineMessage::Type_EndOfHandHideCardsMessage) {
 			const EndOfHandHideCardsMessage &hideCards = engineMsg.endofhandhidecardsmessage();
@@ -259,13 +259,11 @@ ClientThread::SendJoinFirstGame(const std::string &password, bool autoLeave)
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet to request joining a game.
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
-	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
-	netGame->set_gameid(1);
-	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
-	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
-	netManage->set_messagetype(GameManagementMessage::Type_JoinGameMessage);
-	JoinGameMessage *netJoinGame = netManage->mutable_joingamemessage();
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
+	LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
+	netLobby->set_messagetype(LobbyMessage::Type_JoinGameMessage);
+	JoinGameMessage *netJoinGame = netLobby->mutable_joingamemessage();
+	netJoinGame->set_gameid(1);
 	netJoinGame->set_autoleave(autoLeave);

 	if (!password.empty()) {
@@ -280,13 +278,11 @@ ClientThread::SendJoinGame(unsigned gameId, const std::string &password, bool au
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet to request joining a game.
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
-	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
-	netGame->set_gameid(gameId);
-	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
-	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
-	netManage->set_messagetype(GameManagementMessage::Type_JoinGameMessage);
-	JoinGameMessage *netJoinGame = netManage->mutable_joingamemessage();
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
+	LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
+	netLobby->set_messagetype(LobbyMessage::Type_JoinGameMessage);
+	JoinGameMessage *netJoinGame = netLobby->mutable_joingamemessage();
+	netJoinGame->set_gameid(gameId);
 	netJoinGame->set_autoleave(autoLeave);

 	if (!password.empty()) {
@@ -301,13 +297,11 @@ ClientThread::SendRejoinGame(unsigned gameId, bool autoLeave)
 	// Warning: This function is called in the context of the GUI thread.
 	// Create a network packet to request rejoining a running game.
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
-	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
-	netGame->set_gameid(gameId);
-	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
-	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
-	netManage->set_messagetype(GameManagementMessage::Type_RejoinGameMessage);
-	RejoinGameMessage *netJoinGame = netManage->mutable_rejoingamemessage();
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
+	LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
+	netLobby->set_messagetype(LobbyMessage::Type_RejoinGameMessage);
+	RejoinGameMessage *netJoinGame = netLobby->mutable_rejoingamemessage();
+	netJoinGame->set_gameid(gameId);
 	netJoinGame->set_autoleave(autoLeave);

 	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
@@ -397,11 +391,13 @@ void
 ClientThread::SendInvitePlayerToCurrentGame(unsigned playerId)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
-	LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
-	netLobby->set_messagetype(LobbyMessage::Type_InvitePlayerToGameMessage);
-	InvitePlayerToGameMessage *netInvite = netLobby->mutable_inviteplayertogamemessage();
-	netInvite->set_gameid(GetGameId());
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(GetGameId());
+	netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+	GameManagementMessage *netManagement = netGame->mutable_gamemanagementmessage();
+	netManagement->set_messagetype(GameManagementMessage::Type_InvitePlayerToGameMessage);
+	InvitePlayerToGameMessage *netInvite = netManagement->mutable_inviteplayertogamemessage();
 	netInvite->set_playerid(playerId);
 	m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
 }
@@ -487,20 +483,19 @@ ClientThread::CloseSession(boost::shared_ptr<SessionData> /*session*/)
 void
 ClientThread::HandlePacket(boost::shared_ptr<SessionData> /*session*/, boost::shared_ptr<NetPacket> packet)
 {
-	switch (packet->GetMsg()->messagetype())
-	{
-		case PokerTHMessage::Type_AnnounceMessage :
-			GetState().HandleAnnounceMsg(shared_from_this(), packet->GetMsg()->announcemessage());
-			break;
-		case PokerTHMessage::Type_AuthMessage :
-			GetState().HandleAuthMsg(shared_from_this(), packet->GetMsg()->authmessage());
-			break;
-		case PokerTHMessage::Type_GameMessage :
-			GetState().HandleGameMsg(shared_from_this(), packet->GetMsg()->gamemessage());
-			break;
-		case PokerTHMessage::Type_LobbyMessage :
-			GetState().HandleLobbyMsg(shared_from_this(), packet->GetMsg()->lobbymessage());
-			break;
+	switch (packet->GetMsg()->messagetype()) {
+	case PokerTHMessage::Type_AnnounceMessage :
+		GetState().HandleAnnounceMsg(shared_from_this(), packet->GetMsg()->announcemessage());
+		break;
+	case PokerTHMessage::Type_AuthMessage :
+		GetState().HandleAuthMsg(shared_from_this(), packet->GetMsg()->authmessage());
+		break;
+	case PokerTHMessage::Type_GameMessage :
+		GetState().HandleGameMsg(shared_from_this(), packet->GetMsg()->gamemessage());
+		break;
+	case PokerTHMessage::Type_LobbyMessage :
+		GetState().HandleLobbyMsg(shared_from_this(), packet->GetMsg()->lobbymessage());
+		break;
 	}
 }

@@ -72,20 +72,21 @@ bool
 NetPacket::IsClientActivity() const
 {
 	bool retVal = false;
+	bool isAuthMsg = m_msg->messagetype() == PokerTHMessage::Type_AuthMessage;
 	bool isLobbyMsg = m_msg->messagetype() == PokerTHMessage::Type_LobbyMessage;
 	bool isGameManagementMsg = m_msg->messagetype() == PokerTHMessage::Type_GameMessage && m_msg->gamemessage().messagetype() == GameMessage::Type_GameManagementMessage;
 	bool isGameEngineMsg = m_msg->messagetype() == PokerTHMessage::Type_GameMessage && m_msg->gamemessage().messagetype() == GameMessage::Type_GameEngineMessage;
 	if (m_msg &&
-		(isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_InitMessage
-		|| isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_CreateGameMessage
-		|| isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_ResetTimeoutMessage
-		|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_JoinGameMessage
-		|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_RejoinGameMessage
-		|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_KickPlayerRequestMessage
-		|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_LeaveGameRequestMessage
-		|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_StartEventMessage
-		|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_ChatRequestMessage
-		|| isGameEngineMsg && m_msg->gamemessage().gameenginemessage().messagetype() == GameEngineMessage::Type_MyActionRequestMessage)) {
+			((isAuthMsg && m_msg->authmessage().messagetype() == AuthMessage::Type_AuthClientRequestMessage)
+			 || (isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_CreateGameMessage)
+			 || (isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_ResetTimeoutMessage)
+			 || (isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_JoinGameMessage)
+			 || (isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_RejoinGameMessage)
+			 || (isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_KickPlayerRequestMessage)
+			 || (isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_LeaveGameRequestMessage)
+			 || (isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_StartEventMessage)
+			 || (isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_ChatRequestMessage)
+			 || (isGameEngineMsg && m_msg->gamemessage().gameenginemessage().messagetype() == GameEngineMessage::Type_MyActionRequestMessage))) {
 		retVal = true;
 	}
 	return retVal;
@@ -31,7 +31,7 @@

 #include <net/receivebuffer.h>

-NetPacketValidator ReceiveBuffer::validator;
+PokerTHMessageValidator ReceiveBuffer::validator;

 ReceiveBuffer::~ReceiveBuffer()
 {
@@ -68,11 +68,11 @@ static bool LessThanPlayerHandStartMoney(const boost::shared_ptr<PlayerInterface
 ServerGame::ServerGame(boost::shared_ptr<ServerLobbyThread> lobbyThread, u_int32_t id, const string &name, const string &pwd, const GameData &gameData,
 					   unsigned adminPlayerId, unsigned creatorPlayerDBId, GuiInterface &gui, ConfigFile &playerConfig, const ServerMode mode)
 	: m_adminPlayerId(adminPlayerId), m_lobbyThread(lobbyThread), m_gui(gui),
-	  m_gameData(gameData), m_curState(NULL), m_id(id), m_name(name),
+	  m_serverDelayTime(mode), m_gameData(gameData), m_curState(NULL), m_id(id), m_name(name),
 	  m_password(pwd), m_creatorPlayerDBId(creatorPlayerDBId), m_playerConfig(playerConfig),
 	  m_gameNum(1), m_curPetitionId(1), m_voteKickTimer(lobbyThread->GetIOService()),
 	  m_stateTimer1(lobbyThread->GetIOService()), m_stateTimer2(lobbyThread->GetIOService()),
-	  m_isNameReported(false), m_serverDelayTime(mode)
+	  m_isNameReported(false)
 {
 	LOG_VERBOSE("Game object " << GetId() << " created.");
 }
@@ -171,10 +171,9 @@ ServerGame::MarkPlayerAsKicked(unsigned playerId)
 }

 void
-ServerGame::HandlePacket(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
+ServerGame::HandleGameMsg(boost::shared_ptr<SessionData> session, const GameMessage &gameMsg)
 {
-	if (session && packet)
-		GetState().ProcessPacket(shared_from_this(), session, packet);
+	GetState().HandleGameMsg(shared_from_this(), session, gameMsg);
 }

 GameState
@@ -265,9 +264,13 @@ ServerGame::TimerVoteKick(const boost::system::error_code &ec)
 			}
 			if (abortPetition) {
 				boost::shared_ptr<NetPacket> packet(new NetPacket);
-				packet->GetMsg()->set_messagetype(PokerTHMessage::Type_EndKickPetitionMessage);
-				EndKickPetitionMessage *netEndPetition = packet->GetMsg()->mutable_endkickpetitionmessage();
-				netEndPetition->set_gameid(GetId());
+				packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+				GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+				netGame->set_gameid(GetId());
+				netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+				GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+				netManage->set_messagetype(GameManagementMessage::Type_EndKickPetitionMessage);
+				EndKickPetitionMessage *netEndPetition = netManage->mutable_endkickpetitionmessage();
 				netEndPetition->set_petitionid(m_voteKickData->petitionId);
 				netEndPetition->set_numvotesagainstkicking(m_voteKickData->numVotesAgainstKicking);
 				netEndPetition->set_numvotesinfavourofkicking(m_voteKickData->numVotesInFavourOfKicking);
@@ -509,9 +512,13 @@ ServerGame::InternalAskVoteKick(boost::shared_ptr<SessionData> byWhom, unsigned
 					m_voteKickData->votedPlayerIds.push_back(playerIdByWhom);

 					boost::shared_ptr<NetPacket> packet(new NetPacket);
-					packet->GetMsg()->set_messagetype(PokerTHMessage::Type_StartKickPetitionMessage);
-					StartKickPetitionMessage *netStartPetition = packet->GetMsg()->mutable_startkickpetitionmessage();
-					netStartPetition->set_gameid(GetId());
+					packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+					GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+					netGame->set_gameid(GetId());
+					netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+					GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+					netManage->set_messagetype(GameManagementMessage::Type_StartKickPetitionMessage);
+					StartKickPetitionMessage *netStartPetition = netManage->mutable_startkickpetitionmessage();
 					netStartPetition->set_petitionid(m_voteKickData->petitionId);
 					netStartPetition->set_proposingplayerid(playerIdByWhom);
 					netStartPetition->set_kickplayerid(m_voteKickData->kickPlayerId);
@@ -539,9 +546,13 @@ void
 ServerGame::InternalDenyAskVoteKick(boost::shared_ptr<SessionData> byWhom, unsigned playerIdWho, DenyKickPlayerReason reason)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AskKickDeniedMessage);
-	AskKickDeniedMessage *netKickDenied = packet->GetMsg()->mutable_askkickdeniedmessage();
-	netKickDenied->set_gameid(GetId());
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(GetId());
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+	netManage->set_messagetype(GameManagementMessage::Type_AskKickDeniedMessage);
+	AskKickDeniedMessage *netKickDenied = netManage->mutable_askkickdeniedmessage();
 	netKickDenied->set_playerid(playerIdWho);
 	netKickDenied->set_kickdeniedreason(static_cast<AskKickDeniedMessage::KickDeniedReason>(reason));
 	GetLobbyThread().GetSender().Send(byWhom, packet);
@@ -563,9 +574,13 @@ ServerGame::InternalVoteKick(boost::shared_ptr<SessionData> byWhom, unsigned pet
 					m_voteKickData->numVotesAgainstKicking++;
 				// Send update notification.
 				boost::shared_ptr<NetPacket> packet(new NetPacket);
-				packet->GetMsg()->set_messagetype(PokerTHMessage::Type_KickPetitionUpdateMessage);
-				KickPetitionUpdateMessage *netKickUpdate = packet->GetMsg()->mutable_kickpetitionupdatemessage();
-				netKickUpdate->set_gameid(GetId());
+				packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+				GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+				netGame->set_gameid(GetId());
+				netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+				GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+				netManage->set_messagetype(GameManagementMessage::Type_KickPetitionUpdateMessage);
+				KickPetitionUpdateMessage *netKickUpdate = netManage->mutable_kickpetitionupdatemessage();
 				netKickUpdate->set_petitionid(m_voteKickData->petitionId);
 				netKickUpdate->set_numvotesagainstkicking(m_voteKickData->numVotesAgainstKicking);
 				netKickUpdate->set_numvotesinfavourofkicking(m_voteKickData->numVotesInFavourOfKicking);
@@ -583,9 +598,13 @@ void
 ServerGame::InternalDenyVoteKick(boost::shared_ptr<SessionData> byWhom, unsigned petitionId, DenyVoteReason reason)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_VoteKickReplyMessage);
-	VoteKickReplyMessage *netVoteReply = packet->GetMsg()->mutable_votekickreplymessage();
-	netVoteReply->set_gameid(GetId());
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(GetId());
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+	netManage->set_messagetype(GameManagementMessage::Type_VoteKickReplyMessage);
+	VoteKickReplyMessage *netVoteReply = netManage->mutable_votekickreplymessage();
 	netVoteReply->set_petitionid(petitionId);
 	switch(reason) {
 	case VOTE_DENIED_ALREADY_VOTED :
@@ -893,9 +912,13 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason, b
 			GetState().NotifyGameAdminChanged(shared_from_this());
 			// Send "Game Admin Changed" to clients.
 			boost::shared_ptr<NetPacket> adminChanged(new NetPacket);
-			adminChanged->GetMsg()->set_messagetype(PokerTHMessage::Type_GameAdminChangedMessage);
-			GameAdminChangedMessage *netGameAdmin = adminChanged->GetMsg()->mutable_gameadminchangedmessage();
-			netGameAdmin->set_gameid(GetId());
+			adminChanged->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = adminChanged->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(GetId());
+			netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+			GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+			netManage->set_messagetype(GameManagementMessage::Type_GameAdminChangedMessage);
+			GameAdminChangedMessage *netGameAdmin = netManage->mutable_gameadminchangedmessage();
 			netGameAdmin->set_newadminplayerid(newAdmin->GetUniqueId()); // Choose next player as admin.
 			GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), adminChanged, SessionData::Game);

@@ -907,6 +930,12 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason, b

 	// Send "Player Left" to clients.
 	boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacket);
+	thisPlayerLeft->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = thisPlayerLeft->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(GetId());
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+
 	GamePlayerLeftMessage::GamePlayerLeftReason netReason = GamePlayerLeftMessage::leftError;
 	switch (reason) {
 	case NTF_NET_REMOVED_ON_REQUEST :
@@ -918,15 +947,13 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason, b
 	}

 	if (spectateOnly) {
-		thisPlayerLeft->GetMsg()->set_messagetype(PokerTHMessage::Type_GameSpectatorLeftMessage);
-		GameSpectatorLeftMessage *netPlayerLeft = thisPlayerLeft->GetMsg()->mutable_gamespectatorleftmessage();
-		netPlayerLeft->set_gameid(GetId());
+		netManage->set_messagetype(GameManagementMessage::Type_GameSpectatorLeftMessage);
+		GameSpectatorLeftMessage *netPlayerLeft = netManage->mutable_gamespectatorleftmessage();
 		netPlayerLeft->set_playerid(player->GetUniqueId());
 		netPlayerLeft->set_gamespectatorleftreason(netReason);
 	} else {
-		thisPlayerLeft->GetMsg()->set_messagetype(PokerTHMessage::Type_GamePlayerLeftMessage);
-		GamePlayerLeftMessage *netPlayerLeft = thisPlayerLeft->GetMsg()->mutable_gameplayerleftmessage();
-		netPlayerLeft->set_gameid(GetId());
+		netManage->set_messagetype(GameManagementMessage::Type_GamePlayerLeftMessage);
+		GamePlayerLeftMessage *netPlayerLeft = netManage->mutable_gameplayerleftmessage();
 		netPlayerLeft->set_playerid(player->GetUniqueId());
 		netPlayerLeft->set_gameplayerleftreason(netReason);
 	}
@@ -1014,22 +1041,6 @@ ServerGame::IsValidPlayer(unsigned playerId) const
 	return retVal;
 }

-void
-ServerGame::AddReportedAvatar(unsigned playerId)
-{
-	m_reportedAvatarList.push_back(playerId);
-}
-
-bool
-ServerGame::IsAvatarReported(unsigned playerId) const
-{
-	bool retVal = false;
-	PlayerIdList::const_iterator pos = find(m_reportedAvatarList.begin(), m_reportedAvatarList.end(), playerId);
-	if (pos != m_reportedAvatarList.end())
-		retVal = true;
-	return retVal;
-}
-
 SessionManager &
 ServerGame::GetSessionManager()
 {
@@ -76,10 +76,13 @@ static void SendPlayerAction(ServerGame &server, boost::shared_ptr<PlayerInterfa
 		throw ServerException(__FILE__, __LINE__, ERR_NET_NO_CURRENT_PLAYER, 0);

 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayersActionDoneMessage);
-	PlayersActionDoneMessage *netActionDone = packet->GetMsg()->mutable_playersactiondonemessage();
-
-	netActionDone->set_gameid(server.GetId());
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(server.GetId());
+	netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+	GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+	netEngine->set_messagetype(GameEngineMessage::Type_PlayersActionDoneMessage);
+	PlayersActionDoneMessage *netActionDone = netEngine->mutable_playersactiondonemessage();
 	netActionDone->set_gamestate(static_cast<NetGameState>(server.GetCurRound()));
 	netActionDone->set_highestset(server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet());
 	netActionDone->set_minimumraise(server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise());
@@ -101,9 +104,13 @@ static void SendNewRoundCards(ServerGame &server, Game &curGame, int state)
 	case GAME_STATE_FLOP: {
 		// deal flop cards
 		boost::shared_ptr<NetPacket> packet(new NetPacket);
-		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_DealFlopCardsMessage);
-		DealFlopCardsMessage *netDealFlop = packet->GetMsg()->mutable_dealflopcardsmessage();
-		netDealFlop->set_gameid(server.GetId());
+		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+		GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server.GetId());
+		netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+		GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+		netEngine->set_messagetype(GameEngineMessage::Type_DealFlopCardsMessage);
+		DealFlopCardsMessage *netDealFlop = netEngine->mutable_dealflopcardsmessage();
 		netDealFlop->set_flopcard1(cards[0]);
 		netDealFlop->set_flopcard2(cards[1]);
 		netDealFlop->set_flopcard3(cards[2]);
@@ -113,9 +120,13 @@ static void SendNewRoundCards(ServerGame &server, Game &curGame, int state)
 	case GAME_STATE_TURN: {
 		// deal turn card
 		boost::shared_ptr<NetPacket> packet(new NetPacket);
-		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_DealTurnCardMessage);
-		DealTurnCardMessage *netDealTurn = packet->GetMsg()->mutable_dealturncardmessage();
-		netDealTurn->set_gameid(server.GetId());
+		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+		GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server.GetId());
+		netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+		GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+		netEngine->set_messagetype(GameEngineMessage::Type_DealTurnCardMessage);
+		DealTurnCardMessage *netDealTurn = netEngine->mutable_dealturncardmessage();
 		netDealTurn->set_turncard(cards[3]);
 		server.SendToAllPlayers(packet, SessionData::Game | SessionData::Spectating);
 	}
@@ -123,9 +134,13 @@ static void SendNewRoundCards(ServerGame &server, Game &curGame, int state)
 	case GAME_STATE_RIVER: {
 		// deal river card
 		boost::shared_ptr<NetPacket> packet(new NetPacket);
-		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_DealRiverCardMessage);
-		DealRiverCardMessage *netDealRiver = packet->GetMsg()->mutable_dealrivercardmessage();
-		netDealRiver->set_gameid(server.GetId());
+		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+		GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server.GetId());
+		netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+		GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+		netEngine->set_messagetype(GameEngineMessage::Type_DealRiverCardMessage);
+		DealRiverCardMessage *netDealRiver = netEngine->mutable_dealrivercardmessage();
 		netDealRiver->set_rivercard(cards[4]);
 		server.SendToAllPlayers(packet, SessionData::Game | SessionData::Spectating);
 	}
@@ -216,153 +231,111 @@ AbstractServerGameStateReceiving::~AbstractServerGameStateReceiving()
 }

 void
-AbstractServerGameStateReceiving::ProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
+AbstractServerGameStateReceiving::HandleGameMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameMessage &gameMsg)
 {
-	if (packet->IsClientActivity()) {
-		session->ResetActivityTimer();
+	if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
+		HandleGameManagementMsg(server, session, gameMsg.gamemanagementmessage());
+	} else if (gameMsg.messagetype() == GameMessage::Type_GameEngineMessage) {
+		HandleGameEngineMsg(server, session, gameMsg.gameenginemessage());
 	}
-	if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_PlayerInfoRequestMessage) {
-		// Delegate to Lobby.
-		server->GetLobbyThread().HandleGameRetrievePlayerInfo(session, packet->GetMsg()->playerinforequestmessage());
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarRequestMessage) {
-		// Delegate to Lobby.
-		server->GetLobbyThread().HandleGameRetrieveAvatar(session, packet->GetMsg()->avatarrequestmessage());
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_LeaveGameRequestMessage) {
+}
+
+void
+AbstractServerGameStateReceiving::HandleGameManagementMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameManagementMessage &managementMsg)
+{
+	if (managementMsg.messagetype() == GameManagementMessage::Type_LeaveGameRequestMessage) {
 		server->MoveSessionToLobby(session, NTF_NET_REMOVED_ON_REQUEST);
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_KickPlayerRequestMessage) {
+	} else if (managementMsg.messagetype() == GameManagementMessage::Type_KickPlayerRequestMessage) {
 		// Only admins are allowed to kick, and only in the lobby.
 		// After leaving the lobby, a vote needs to be initiated to kick.
-		const KickPlayerRequestMessage &netKickRequest = packet->GetMsg()->kickplayerrequestmessage();
+		const KickPlayerRequestMessage &netKickRequest = managementMsg.kickplayerrequestmessage();
 		if (session->GetPlayerData()->IsGameAdmin() && !server->IsRunning()
-				&& netKickRequest.gameid() == server->GetId() && server->GetGameData().gameType != GAME_TYPE_RANKING) {
+				&& server->GetGameData().gameType != GAME_TYPE_RANKING) {
 			server->KickPlayer(netKickRequest.playerid());
 		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AskKickPlayerMessage) {
+	} else if (managementMsg.messagetype() == GameManagementMessage::Type_AskKickPlayerMessage) {
 		if (server->GetGameData().gameType != GAME_TYPE_RANKING) {
-			const AskKickPlayerMessage &netAskKick = packet->GetMsg()->askkickplayermessage();
+			const AskKickPlayerMessage &netAskKick = managementMsg.askkickplayermessage();
 			server->InternalAskVoteKick(session, netAskKick.playerid(), SERVER_VOTE_KICK_TIMEOUT_SEC);
 		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_VoteKickRequestMessage) {
-		const VoteKickRequestMessage &netVoteKick = packet->GetMsg()->votekickrequestmessage();
+	} else if (managementMsg.messagetype() == GameManagementMessage::Type_VoteKickRequestMessage) {
+		const VoteKickRequestMessage &netVoteKick = managementMsg.votekickrequestmessage();
 		server->InternalVoteKick(session, netVoteKick.petitionid(), netVoteKick.votekick() ? KICK_VOTE_IN_FAVOUR : KICK_VOTE_AGAINST);
 	}
 	// Chat text is always allowed.
-	else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_ChatRequestMessage) {
+	else if (managementMsg.messagetype() == GameManagementMessage::Type_ChatRequestMessage) {
 		bool chatSent = false;
-		const ChatRequestMessage &netChatRequest = packet->GetMsg()->chatrequestmessage();
+		const ChatRequestMessage &netChatRequest = managementMsg.chatrequestmessage();
 		// Only forward if this player is known and not a guest.
 		if (session->GetPlayerData()->GetRights() != PLAYER_RIGHTS_GUEST) {
 			// Forward chat text to all players.
 			// TODO: Some limitation needed.
-			if (!netChatRequest.has_targetgameid()) {
-				if (!server->IsRunning()) {
-					server->GetLobbyThread().HandleChatRequest(session, netChatRequest);
-					chatSent = true;
-				}
-			} else {
-				boost::shared_ptr<PlayerInterface> tmpPlayer (server->GetPlayerInterfaceFromGame(session->GetPlayerData()->GetUniqueId()));
-				// If we did not find the player, then the game did not start yet. Allow chat for now.
-				// Otherwise, check whether the player is muted.
-				if (!tmpPlayer || !tmpPlayer->isMuted()) {
-					boost::shared_ptr<NetPacket> packet(new NetPacket);
-					packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ChatMessage);
-					ChatMessage *netChat = packet->GetMsg()->mutable_chatmessage();
-					netChat->set_gameid(server->GetId());
-					netChat->set_playerid(session->GetPlayerData()->GetUniqueId());
-					netChat->set_chattype(ChatMessage::chatTypeGame);
-					netChat->set_chattext(netChatRequest.chattext());
-					server->SendToAllPlayers(packet, SessionData::Game | SessionData::Spectating | SessionData::SpectatorWaiting);
-					chatSent = true;
+			boost::shared_ptr<PlayerInterface> tmpPlayer (server->GetPlayerInterfaceFromGame(session->GetPlayerData()->GetUniqueId()));
+			// If we did not find the player, then the game did not start yet. Allow chat for now.
+			// Otherwise, check whether the player is muted.
+			if (!tmpPlayer || !tmpPlayer->isMuted()) {
+				boost::shared_ptr<NetPacket> packet(new NetPacket);
+				packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+				GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+				netGame->set_gameid(server->GetId());
+				netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+				GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+				netManage->set_messagetype(GameManagementMessage::Type_ChatMessage);
+				ChatMessage *netChat = netManage->mutable_chatmessage();
+				netChat->set_playerid(session->GetPlayerData()->GetUniqueId());
+				netChat->set_chattype(ChatMessage::chatTypeStandard);
+				netChat->set_chattext(netChatRequest.chattext());
+				server->SendToAllPlayers(packet, SessionData::Game | SessionData::Spectating | SessionData::SpectatorWaiting);
+				chatSent = true;

-					// Send the message to the chat cleaner bot for ranking games.
-					//if (server->GetGameData().gameType == GAME_TYPE_RANKING)
-					//{
-					server->GetLobbyThread().GetChatCleaner().HandleGameChatText(
-						server->GetId(),
-						session->GetPlayerData()->GetUniqueId(),
-						session->GetPlayerData()->GetName(),
-						netChatRequest.chattext());
-					//}
-				}
+				// Send the message to the chat cleaner bot for ranking games.
+				//if (server->GetGameData().gameType == GAME_TYPE_RANKING)
+				//{
+				server->GetLobbyThread().GetChatCleaner().HandleGameChatText(
+					server->GetId(),
+					session->GetPlayerData()->GetUniqueId(),
+					session->GetPlayerData()->GetName(),
+					netChatRequest.chattext());
+				//}
 			}
 		}
 		// Reject chat otherwise.
 		if (!chatSent) {
 			boost::shared_ptr<NetPacket> packet(new NetPacket);
-			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ChatRejectMessage);
-			ChatRejectMessage *netReject = packet->GetMsg()->mutable_chatrejectmessage();
+			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+			GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+			netManage->set_messagetype(GameManagementMessage::Type_ChatRejectMessage);
+			ChatRejectMessage *netReject = netManage->mutable_chatrejectmessage();
 			netReject->set_chattext(netChatRequest.chattext());
 			server->GetLobbyThread().GetSender().Send(session, packet);
 		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_SubscriptionRequestMessage) {
-		const SubscriptionRequestMessage &netSubscription = packet->GetMsg()->subscriptionrequestmessage();
-		if (netSubscription.subscriptionaction() == SubscriptionRequestMessage::resubscribeGameList) {
-			if (!session->WantsLobbyMsg())
-				server->GetLobbyThread().ResubscribeLobbyMsg(session);
-		} else
-			session->ResetWantsLobbyMsg();
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_ReportAvatarMessage) {
-		const ReportAvatarMessage &netReport = packet->GetMsg()->reportavatarmessage();
-		boost::shared_ptr<PlayerData> tmpPlayer = server->GetPlayerDataByUniqueId(netReport.reportedplayerid());
-		MD5Buf tmpMD5;
-		memcpy(tmpMD5.GetData(), netReport.reportedavatarhash().data(), MD5_DATA_SIZE);
-		if (tmpPlayer && tmpPlayer->GetDBId() && !tmpMD5.IsZero() && tmpPlayer->GetAvatarMD5() == tmpMD5) {
-			if (!server->IsAvatarReported(tmpPlayer->GetUniqueId())) {
-				// Temporarily note that this avatar was reported.
-				// This prevents spamming of the avatar report.
-				server->AddReportedAvatar(tmpPlayer->GetUniqueId());
-				DB_id myDBid = session->GetPlayerData()->GetDBId();
-				// Do not use the "game" database object, but the global one.
-				// The entry should be created even if we are not running a
-				// ranking game.
-
-				string tmpAvatarType;
-				tmpAvatarType = AvatarManager::GetAvatarFileExtension(AvatarManager::GetAvatarFileType(tmpPlayer->GetAvatarFile()));
-				if (!tmpAvatarType.empty())
-					tmpAvatarType.erase(0, 1); // Only store extension without the "."
-
-				server->GetLobbyThread().GetDatabase()->AsyncReportAvatar(
-					session->GetPlayerData()->GetUniqueId(),
-					tmpPlayer->GetUniqueId(),
-					tmpPlayer->GetDBId(),
-					tmpPlayer->GetAvatarMD5().ToString(),
-					tmpAvatarType,
-					myDBid != 0 ? &myDBid : NULL
-				);
-			} else {
-				boost::shared_ptr<NetPacket> packet(new NetPacket);
-				packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ReportAvatarAckMessage);
-				ReportAvatarAckMessage *netReportAck = packet->GetMsg()->mutable_reportavatarackmessage();
-				netReportAck->set_reportedplayerid(netReport.reportedplayerid());
-				netReportAck->set_reportavatarresult(ReportAvatarAckMessage::avatarReportDuplicate);
-				server->GetLobbyThread().GetSender().Send(session, packet);
-			}
-		} else {
-			boost::shared_ptr<NetPacket> packet(new NetPacket);
-			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ReportAvatarAckMessage);
-			ReportAvatarAckMessage *netReportAck = packet->GetMsg()->mutable_reportavatarackmessage();
-			netReportAck->set_reportedplayerid(netReport.reportedplayerid());
-			netReportAck->set_reportavatarresult(ReportAvatarAckMessage::avatarReportInvalid);
-			server->GetLobbyThread().GetSender().Send(session, packet);
-		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_ReportGameMessage) {
-		// Delegate to Lobby.
-		server->GetLobbyThread().HandleGameReportGame(session, packet->GetMsg()->reportgamemessage());
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_JoinExistingGameMessage) {
-		// Ignore join game requests in this state (may be multiple clicks from the lobby).
 	} else {
-		// Packet processing in subclass.
-		InternalProcessPacket(server, session, packet);
+		// Message processing in subclass.
+		InternalHandleGameManagementMsg(server, session, managementMsg);
 	}
 }

+void
+AbstractServerGameStateReceiving::HandleGameEngineMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameEngineMessage &engineMsg)
+{
+	// Message processing in subclass.
+	InternalHandleGameEngineMsg(server, session, engineMsg);
+}
+
 boost::shared_ptr<NetPacket>
 AbstractServerGameStateReceiving::CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GamePlayerJoinedMessage);
-	GamePlayerJoinedMessage *netGamePlayer = packet->GetMsg()->mutable_gameplayerjoinedmessage();
-	netGamePlayer->set_gameid(gameId);
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(gameId);
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+	netManage->set_messagetype(GameManagementMessage::Type_GamePlayerJoinedMessage);
+	GamePlayerJoinedMessage *netGamePlayer = netManage->mutable_gameplayerjoinedmessage();
 	netGamePlayer->set_playerid(playerData.GetUniqueId());
 	netGamePlayer->set_isgameadmin(playerData.IsGameAdmin());
 	return packet;
@@ -372,9 +345,13 @@ boost::shared_ptr<NetPacket>
 AbstractServerGameStateReceiving::CreateNetPacketSpectatorJoined(unsigned gameId, const PlayerData &playerData)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameSpectatorJoinedMessage);
-	GameSpectatorJoinedMessage *netGameSpectator = packet->GetMsg()->mutable_gamespectatorjoinedmessage();
-	netGameSpectator->set_gameid(gameId);
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(gameId);
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+	netManage->set_messagetype(GameManagementMessage::Type_GameSpectatorJoinedMessage);
+	GameSpectatorJoinedMessage *netGameSpectator = netManage->mutable_gamespectatorjoinedmessage();
 	netGameSpectator->set_playerid(playerData.GetUniqueId());
 	return packet;
 }
@@ -383,12 +360,13 @@ boost::shared_ptr<NetPacket>
 AbstractServerGameStateReceiving::CreateNetPacketJoinGameAck(const ServerGame &server, const PlayerData &playerData, bool spectateOnly)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_JoinGameAckMessage);
-	JoinGameAckMessage *netJoinReply = packet->GetMsg()->mutable_joingameackmessage();
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
+	LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
+	netLobby->set_messagetype(LobbyMessage::Type_JoinGameAckMessage);
+	JoinGameAckMessage *netJoinReply = netLobby->mutable_joingameackmessage();
 	netJoinReply->set_gameid(server.GetId());
 	netJoinReply->set_areyougameadmin(playerData.IsGameAdmin());
 	netJoinReply->set_spectateonly(spectateOnly);
-
 	NetGameInfo *gameInfo = netJoinReply->mutable_gameinfo();
 	NetPacket::SetGameData(server.GetGameData(), *gameInfo);
 	gameInfo->set_gamename(server.GetName());
@@ -401,10 +379,13 @@ AbstractServerGameStateReceiving::CreateNetPacketHandStart(const ServerGame &ser
 	const Game &curGame = server.GetGame();

 	boost::shared_ptr<NetPacket> notifyCards(new NetPacket);
-	notifyCards->GetMsg()->set_messagetype(PokerTHMessage::Type_HandStartMessage);
-	HandStartMessage *netHandStart = notifyCards->GetMsg()->mutable_handstartmessage();
-	netHandStart->set_gameid(server.GetId());
-
+	notifyCards->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = notifyCards->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(server.GetId());
+	netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+	GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+	netEngine->set_messagetype(GameEngineMessage::Type_HandStartMessage);
+	HandStartMessage *netHandStart = netEngine->mutable_handstartmessage();
 	PlayerListIterator player_i = curGame.getSeatsList()->begin();
 	PlayerListIterator player_end = curGame.getSeatsList()->end();
 	int playerCounter = 0;
@@ -603,8 +584,13 @@ ServerGameStateInit::TimerAdminWarning(const boost::system::error_code &ec, boos
 		if (session) {
 			// Send him a warning.
 			boost::shared_ptr<NetPacket> packet(new NetPacket);
-			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_TimeoutWarningMessage);
-			TimeoutWarningMessage *netWarning = packet->GetMsg()->mutable_timeoutwarningmessage();
+			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+			GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+			netManage->set_messagetype(GameManagementMessage::Type_TimeoutWarningMessage);
+			TimeoutWarningMessage *netWarning = netManage->mutable_timeoutwarningmessage();
 			netWarning->set_timeoutreason(TimeoutWarningMessage::timeoutInactiveGame);
 			netWarning->set_remainingseconds(SERVER_GAME_ADMIN_WARNING_REMAINING_SEC);
 			server->GetLobbyThread().GetSender().Send(session, packet);
@@ -653,10 +639,14 @@ ServerGameStateInit::SendStartEvent(ServerGame &server, bool fillWithComputerPla
 		}
 	}
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_StartEventMessage);
-	StartEventMessage *netStartEvent = packet->GetMsg()->mutable_starteventmessage();
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(server.GetId());
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+	netManage->set_messagetype(GameManagementMessage::Type_StartEventMessage);
+	StartEventMessage *netStartEvent = netManage->mutable_starteventmessage();
 	netStartEvent->set_starteventtype(StartEventMessage::startEvent);
-	netStartEvent->set_gameid(server.GetId());
 	netStartEvent->set_fillwithcomputerplayers(fillWithComputerPlayers);

 	// Wait for all players to confirm start of game.
@@ -668,13 +658,12 @@ ServerGameStateInit::SendStartEvent(ServerGame &server, bool fillWithComputerPla
 }

 void
-ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
+ServerGameStateInit::InternalHandleGameManagementMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameManagementMessage &managementMsg)
 {
-	if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_StartEventMessage) {
-		const StartEventMessage &netStartEvent = packet->GetMsg()->starteventmessage();
+	if (managementMsg.messagetype() == GameManagementMessage::Type_StartEventMessage) {
+		const StartEventMessage &netStartEvent = managementMsg.starteventmessage();
 		// Only admins are allowed to start the game.
 		if (session->GetPlayerData()->IsGameAdmin()
-				&& netStartEvent.gameid() == server->GetId()
 				&& netStartEvent.starteventtype() == StartEventMessage::startEvent
 				&& (server->GetGameData().gameType != GAME_TYPE_RANKING // ranking games need to be full
 					|| server->GetGameData().maxNumberOfPlayers == server->GetCurNumberOfPlayers())) {
@@ -682,14 +671,16 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
 		} else { // kick players who try to start but are not allowed to
 			server->MoveSessionToLobby(session, NTF_NET_REMOVED_START_FAILED);
 		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_InvitePlayerToGameMessage) {
-		const InvitePlayerToGameMessage &netInvite = packet->GetMsg()->inviteplayertogamemessage();
+	} else if (managementMsg.messagetype() == GameManagementMessage::Type_InvitePlayerToGameMessage) {
+		const InvitePlayerToGameMessage &netInvite = managementMsg.inviteplayertogamemessage();

 		// Only invite players which are not already within the group.
 		if (netInvite.gameid() == server->GetId() && !server->IsPlayerConnected(netInvite.playerid())) {
 			boost::shared_ptr<NetPacket> packet(new NetPacket);
-			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_InviteNotifyMessage);
-			InviteNotifyMessage *netInvNotif = packet->GetMsg()->mutable_invitenotifymessage();
+			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
+			LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
+			netLobby->set_messagetype(LobbyMessage::Type_InviteNotifyMessage);
+			InviteNotifyMessage *netInvNotif = netLobby->mutable_invitenotifymessage();
 			netInvNotif->set_gameid(netInvite.gameid());
 			netInvNotif->set_playeridbywhom(session->GetPlayerData()->GetUniqueId());
 			netInvNotif->set_playeridwho(netInvite.playerid());
@@ -702,8 +693,10 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
 			} else {
 				// Player is not in lobby - send reject message.
 				boost::shared_ptr<NetPacket> p2(new NetPacket);
-				p2->GetMsg()->set_messagetype(PokerTHMessage::Type_RejectInvNotifyMessage);
-				RejectInvNotifyMessage *netRejNotif = p2->GetMsg()->mutable_rejectinvnotifymessage();
+				p2->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
+				LobbyMessage *netLobby = p2->GetMsg()->mutable_lobbymessage();
+				netLobby->set_messagetype(LobbyMessage::Type_RejectInvNotifyMessage);
+				RejectInvNotifyMessage *netRejNotif = netLobby->mutable_rejectinvnotifymessage();
 				netRejNotif->set_gameid(netInvite.gameid());
 				netRejNotif->set_playerid(netInvite.playerid());
 				netRejNotif->set_playerrejectreason(RejectGameInvitationMessage::rejectReasonBusy);
@@ -711,19 +704,18 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
 				server->SendToAllPlayers(p2, SessionData::Game);
 			}
 		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_ResetTimeoutMessage) {
+	} else if (managementMsg.messagetype() == GameManagementMessage::Type_ResetTimeoutMessage) {
 		if (session->GetPlayerData()->IsGameAdmin()) {
 			RegisterAdminTimer(server);
 		}
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AdminRemoveGameMessage) {
-		server->GetLobbyThread().HandleAdminRemoveGame(session, packet->GetMsg()->adminremovegamemessage());
-	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AdminBanPlayerMessage) {
-		server->GetLobbyThread().HandleAdminBanPlayer(session, packet->GetMsg()->adminbanplayermessage());
-	} else {
-		server->SessionError(session, ERR_SOCK_INVALID_PACKET);
 	}
 }

+void
+ServerGameStateInit::InternalHandleGameEngineMsg(boost::shared_ptr<ServerGame> /*server*/, boost::shared_ptr<SessionData> /*session*/, const GameEngineMessage &/*engineMsg*/)
+{
+}
+
 //-----------------------------------------------------------------------------

 ServerGameStateStartGame ServerGameStateStartGame::s_state;
@@ -774,9 +766,9 @@ ServerGameStateStartGame::HandleNewSpectator(boost::shared_ptr<ServerGame> serve
 }

 void
-ServerGameStateStartGame::InternalProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
+ServerGameStateStartGame::InternalHandleGameManagementMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameManagementMessage &managementMsg)
 {
-	if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_StartEventAckMessage) {
+	if (managementMsg.messagetype() == GameManagementMessage::Type_StartEventAckMessage) {
 		session->SetReadyFlag();
 		if (server->GetSessionManager().CountReadySessions() == server->GetSessionManager().GetSessionCountWithState(SessionData::Game)) {
 			// Everyone is ready.
@@ -786,6 +778,11 @@ ServerGameStateStartGame::InternalProcessPacket(boost::shared_ptr<ServerGame> se
 	}
 }

+void
+ServerGameStateStartGame::InternalHandleGameEngineMsg(boost::shared_ptr<ServerGame> /*server*/, boost::shared_ptr<SessionData> /*session*/, const GameEngineMessage &/*engineMsg*/)
+{
+}
+
 void
 ServerGameStateStartGame::TimerTimeout(const boost::system::error_code &ec, boost::shared_ptr<ServerGame> server)
 {
@@ -811,9 +808,13 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
 		}
 	} else {
 		boost::shared_ptr<NetPacket> packet(new NetPacket);
-		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameStartInitialMessage);
-		GameStartInitialMessage *netGameStart = packet->GetMsg()->mutable_gamestartinitialmessage();
-		netGameStart->set_gameid(server->GetId());
+		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+		GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server->GetId());
+		netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+		GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+		netManage->set_messagetype(GameManagementMessage::Type_GameStartInitialMessage);
+		GameStartInitialMessage *netGameStart = netManage->mutable_gamestartinitialmessage();
 		netGameStart->set_startdealerplayerid(server->GetStartData().startDealerPlayerId);

 		// Send player order to clients.
@@ -854,10 +855,14 @@ AbstractServerGameStateRunning::HandleNewPlayer(boost::shared_ptr<ServerGame> se

 			// Send start event right away.
 			boost::shared_ptr<NetPacket> packet(new NetPacket);
-			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_StartEventMessage);
-			StartEventMessage *netStartEvent = packet->GetMsg()->mutable_starteventmessage();
+			packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+			GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+			netManage->set_messagetype(GameManagementMessage::Type_StartEventMessage);
+			StartEventMessage *netStartEvent = netManage->mutable_starteventmessage();
 			netStartEvent->set_starteventtype(StartEventMessage::rejoinEvent);
-			netStartEvent->set_gameid(server->GetId());

 			// Wait for rejoining player to confirm start of game.
 			server->GetLobbyThread().GetSender().Send(session, packet);
@@ -879,14 +884,19 @@ AbstractServerGameStateRunning::HandleNewSpectator(boost::shared_ptr<ServerGame>
 }

 void
-AbstractServerGameStateRunning::InternalProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
+AbstractServerGameStateRunning::InternalHandleGameManagementMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameManagementMessage &managementMsg)
 {
-	if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_ResetTimeoutMessage) {
+	if (managementMsg.messagetype() == GameManagementMessage::Type_ResetTimeoutMessage) {
 		// Reactivate session.
 		server->AddReactivatePlayer(session->GetPlayerData()->GetUniqueId());
 	}
 }

+void
+AbstractServerGameStateRunning::InternalHandleGameEngineMsg(boost::shared_ptr<ServerGame> /*server*/, boost::shared_ptr<SessionData> /*session*/, const GameEngineMessage &/*engineMsg*/)
+{
+}
+
 //-----------------------------------------------------------------------------

 ServerGameStateHand ServerGameStateHand::s_state;
@@ -921,12 +931,6 @@ ServerGameStateHand::Exit(boost::shared_ptr<ServerGame> server)
 	server->GetStateTimer1().cancel();
 }

-void
-ServerGameStateHand::InternalProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
-{
-	AbstractServerGameStateRunning::InternalProcessPacket(server, session, packet);
-}
-
 void
 ServerGameStateHand::TimerLoop(const boost::system::error_code &ec, boost::shared_ptr<ServerGame> server)
 {
@@ -966,9 +970,13 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 				&& nonFoldPlayers.size() > 1) {
 			// Send cards of all active players to all players (all in).
 			boost::shared_ptr<NetPacket> allIn(new NetPacket);
-			allIn->GetMsg()->set_messagetype(PokerTHMessage::Type_AllInShowCardsMessage);
-			AllInShowCardsMessage *netAllInShow = allIn->GetMsg()->mutable_allinshowcardsmessage();
-			netAllInShow->set_gameid(server->GetId());
+			allIn->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = allIn->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+			GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+			netEngine->set_messagetype(GameEngineMessage::Type_AllInShowCardsMessage);
+			AllInShowCardsMessage *netAllInShow = netEngine->mutable_allinshowcardsmessage();

 			PlayerListConstIterator i = nonFoldPlayers.begin();
 			PlayerListConstIterator end = nonFoldPlayers.end();
@@ -1013,9 +1021,14 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 				throw ServerException(__FILE__, __LINE__, ERR_NET_PLAYER_NOT_ACTIVE, 0);

 			boost::shared_ptr<NetPacket> notification(new NetPacket);
-			notification->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayersTurnMessage);
-			PlayersTurnMessage *netPlayersTurn = notification->GetMsg()->mutable_playersturnmessage();
-			netPlayersTurn->set_gameid(server->GetId());
+			notification->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = notification->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+			GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+			netEngine->set_messagetype(GameEngineMessage::Type_PlayersTurnMessage);
+			PlayersTurnMessage *netPlayersTurn = netEngine->mutable_playersturnmessage();
+
 			netPlayersTurn->set_gamestate(static_cast<NetGameState>(curGame.getCurrentHand()->getCurrentRound()));
 			netPlayersTurn->set_playerid(curPlayer->getMyUniqueID());
 			server->SendToAllPlayers(notification, SessionData::Game | SessionData::Spectating);
@@ -1055,9 +1068,13 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 				// End of Hand, but keep cards hidden.
 				boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
 				boost::shared_ptr<NetPacket> endHand(new NetPacket);
-				endHand->GetMsg()->set_messagetype(PokerTHMessage::Type_EndOfHandHideCardsMessage);
-				EndOfHandHideCardsMessage *netEndHand = endHand->GetMsg()->mutable_endofhandhidecardsmessage();
-				netEndHand->set_gameid(server->GetId());
+				endHand->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+				GameMessage *netGame = endHand->GetMsg()->mutable_gamemessage();
+				netGame->set_gameid(server->GetId());
+				netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+				GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+				netEngine->set_messagetype(GameEngineMessage::Type_EndOfHandHideCardsMessage);
+				EndOfHandHideCardsMessage *netEndHand = netEngine->mutable_endofhandhidecardsmessage();
 				netEndHand->set_playerid(player->getMyUniqueID());
 				netEndHand->set_moneywon(player->getLastMoneyWon());
 				netEndHand->set_playermoney(player->getMyCash());
@@ -1066,9 +1083,13 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
 				// End of Hand - show cards.
 				const PlayerIdList showList(curGame.getCurrentHand()->getBoard()->getPlayerNeedToShowCards());
 				boost::shared_ptr<NetPacket> endHand(new NetPacket);
-				endHand->GetMsg()->set_messagetype(PokerTHMessage::Type_EndOfHandShowCardsMessage);
-				EndOfHandShowCardsMessage *netEndHand = endHand->GetMsg()->mutable_endofhandshowcardsmessage();
-				netEndHand->set_gameid(server->GetId());
+				endHand->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+				GameMessage *netGame = endHand->GetMsg()->mutable_gamemessage();
+				netGame->set_gameid(server->GetId());
+				netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+				GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+				netEngine->set_messagetype(GameEngineMessage::Type_EndOfHandShowCardsMessage);
+				EndOfHandShowCardsMessage *netEndHand = netEngine->mutable_endofhandshowcardsmessage();

 				PlayerIdList::const_iterator i = showList.begin();
 				PlayerIdList::const_iterator end = showList.end();
@@ -1163,9 +1184,13 @@ ServerGameStateHand::TimerNextGame(const boost::system::error_code &ec, boost::s
 {
 	if (!ec && &server->GetState() == this) {
 		boost::shared_ptr<NetPacket> endGame(new NetPacket);
-		endGame->GetMsg()->set_messagetype(PokerTHMessage::Type_EndOfGameMessage);
-		EndOfGameMessage *netEndGame = endGame->GetMsg()->mutable_endofgamemessage();
-		netEndGame->set_gameid(server->GetId());
+		endGame->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+		GameMessage *netGame = endGame->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server->GetId());
+		netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+		GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+		netManage->set_messagetype(GameManagementMessage::Type_EndOfGameMessage);
+		EndOfGameMessage *netEndGame = netManage->mutable_endofgamemessage();
 		netEndGame->set_winnerplayerid(winnerPlayerId);
 		server->SendToAllPlayers(endGame, SessionData::Game | SessionData::Spectating);

@@ -1241,7 +1266,7 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
 			tmpPlayer->getMyHoleCards(cards);

 			boost::shared_ptr<NetPacket> notifyCards = CreateNetPacketHandStart(*server);
-			HandStartMessage *netHandStart = notifyCards->GetMsg()->mutable_handstartmessage();
+			HandStartMessage *netHandStart = notifyCards->GetMsg()->mutable_gamemessage()->mutable_gameenginemessage()->mutable_handstartmessage();
 			string tmpPassword(tmpSession->AuthGetPassword());
 			if (tmpPassword.empty()) { // encrypt only if password is present
 				HandStartMessage::PlainCards *plainCards = netHandStart->mutable_plaincards();
@@ -1287,9 +1312,13 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
 		boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
 		if (tmpPlayer->getMyButton() == BUTTON_SMALL_BLIND) {
 			boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacket);
-			notifySmallBlind->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayersActionDoneMessage);
-			PlayersActionDoneMessage *netSmallBlind = notifySmallBlind->GetMsg()->mutable_playersactiondonemessage();
-			netSmallBlind->set_gameid(server->GetId());
+			notifySmallBlind->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = notifySmallBlind->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+			GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+			netEngine->set_messagetype(GameEngineMessage::Type_PlayersActionDoneMessage);
+			PlayersActionDoneMessage *netSmallBlind = netEngine->mutable_playersactiondonemessage();
 			netSmallBlind->set_gamestate(netStatePreflopSmallBlind);
 			netSmallBlind->set_playerid(tmpPlayer->getMyUniqueID());
 			netSmallBlind->set_playeraction(static_cast<NetPlayerAction>(tmpPlayer->getMyAction()));
@@ -1309,9 +1338,13 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
 		boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
 		if (tmpPlayer->getMyButton() == BUTTON_BIG_BLIND) {
 			boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacket);
-			notifyBigBlind->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayersActionDoneMessage);
-			PlayersActionDoneMessage *netBigBlind = notifyBigBlind->GetMsg()->mutable_playersactiondonemessage();
-			netBigBlind->set_gameid(server->GetId());
+			notifyBigBlind->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = notifyBigBlind->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+			GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+			netEngine->set_messagetype(GameEngineMessage::Type_PlayersActionDoneMessage);
+			PlayersActionDoneMessage *netBigBlind = netEngine->mutable_playersactiondonemessage();
 			netBigBlind->set_gamestate(netStatePreflopBigBlind);
 			netBigBlind->set_playerid(tmpPlayer->getMyUniqueID());
 			netBigBlind->set_playeraction(static_cast<NetPlayerAction>(tmpPlayer->getMyAction()));
@@ -1346,8 +1379,12 @@ ServerGameStateHand::CheckPlayerTimeouts(boost::shared_ptr<ServerGame> server)
 					boost::shared_ptr<SessionData> session = server->GetSessionManager().GetSessionByUniquePlayerId(tmpPlayer->getMyUniqueID());
 					if (session) {
 						boost::shared_ptr<NetPacket> packet(new NetPacket);
-						packet->GetMsg()->set_messagetype(PokerTHMessage::Type_TimeoutWarningMessage);
-						TimeoutWarningMessage *netWarning = packet->GetMsg()->mutable_timeoutwarningmessage();
+						GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+						netGame->set_gameid(server->GetId());
+						netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+						GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+						netManage->set_messagetype(GameManagementMessage::Type_TimeoutWarningMessage);
+						TimeoutWarningMessage *netWarning = netManage->mutable_timeoutwarningmessage();
 						netWarning->set_timeoutreason(TimeoutWarningMessage::timeoutKickAfterAutofold);
 						netWarning->set_remainingseconds(actionTimeout * SERVER_GAME_FORCED_TIMEOUT_FACTOR - tmpPlayer->getTimeSecSinceLastRemoteAction());
 						server->GetLobbyThread().GetSender().Send(session, packet);
@@ -1418,8 +1455,12 @@ ServerGameStateHand::PerformRejoin(boost::shared_ptr<ServerGame> server, boost::
 	if (rejoinPlayer) {
 		// Notify other clients about id change.
 		boost::shared_ptr<NetPacket> packet(new NetPacket);
-		packet->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayerIdChangedMessage);
-		PlayerIdChangedMessage *netIdChanged = packet->GetMsg()->mutable_playeridchangedmessage();
+		GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server->GetId());
+		netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+		GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+		netManage->set_messagetype(GameManagementMessage::Type_PlayerIdChangedMessage);
+		PlayerIdChangedMessage *netIdChanged = netManage->mutable_playeridchangedmessage();
 		netIdChanged->set_oldplayerid(rejoinPlayer->getMyUniqueID());
 		netIdChanged->set_newplayerid(session->GetPlayerData()->GetUniqueId());
 		server->SendToAllButOnePlayers(packet, session->GetId(), SessionData::Game | SessionData::Spectating | SessionData::SpectatorWaiting);
@@ -1445,9 +1486,12 @@ ServerGameStateHand::SendGameData(boost::shared_ptr<ServerGame> server, boost::s
 	Game &curGame = server->GetGame();
 	// Send game start notification to rejoining client.
 	boost::shared_ptr<NetPacket> packet(new NetPacket);
-	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameStartRejoinMessage);
-	GameStartRejoinMessage *netGameStart = packet->GetMsg()->mutable_gamestartrejoinmessage();
-	netGameStart->set_gameid(server->GetId());
+	GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
+	netGame->set_gameid(server->GetId());
+	netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
+	GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
+	netManage->set_messagetype(GameManagementMessage::Type_GameStartRejoinMessage);
+	GameStartRejoinMessage *netGameStart = netManage->mutable_gamestartrejoinmessage();
 	netGameStart->set_startdealerplayerid(curGame.getDealerPosition());
 	netGameStart->set_handnum(curGame.getCurrentHandID());
 	PlayerListIterator player_i = curGame.getSeatsList()->begin();
@@ -1507,13 +1551,14 @@ ServerGameStateWaitPlayerAction::Exit(boost::shared_ptr<ServerGame> server)
 	server->GetStateTimer1().cancel();
 }

-void
-ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
-{
-	AbstractServerGameStateRunning::InternalProcessPacket(server, session, packet);

-	if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_MyActionRequestMessage) {
-		MyActionRequestMessage *netMyAction = packet->GetMsg()->mutable_myactionrequestmessage();
+void
+ServerGameStateWaitPlayerAction::InternalHandleGameEngineMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameEngineMessage &engineMsg)
+{
+	AbstractServerGameStateRunning::InternalHandleGameEngineMsg(server, session, engineMsg);
+
+	if (engineMsg.messagetype() == GameEngineMessage::Type_MyActionRequestMessage) {
+		MyActionRequestMessage netMyAction = engineMsg.myactionrequestmessage();

 		// TODO consider game id.
 		Game &curGame = server->GetGame();
@@ -1523,7 +1568,7 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG

 		// Check whether this is the correct round.
 		PlayerActionCode code = ACTION_CODE_VALID;
-		if (curGame.getCurrentHand()->getCurrentRound() != static_cast<GameState>(netMyAction->gamestate()))
+		if (curGame.getCurrentHand()->getCurrentRound() != static_cast<GameState>(netMyAction.gamestate()))
 			code = ACTION_CODE_INVALID_STATE;

 		// Check whether this is the correct player.
@@ -1534,20 +1579,20 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
 		}

 		// If the client omitted some values, fill them in.
-		if (netMyAction->myaction() == netActionCall && netMyAction->myrelativebet() == 0) {
+		if (netMyAction.myaction() == netActionCall && netMyAction.myrelativebet() == 0) {
 			if (curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() >= tmpPlayer->getMySet() + tmpPlayer->getMyCash())
-				netMyAction->set_myaction(netActionAllIn);
+				netMyAction.set_myaction(netActionAllIn);
 			else
-				netMyAction->set_myrelativebet(curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() - tmpPlayer->getMySet());
+				netMyAction.set_myrelativebet(curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() - tmpPlayer->getMySet());
 		}
-		if (netMyAction->myaction() == netActionAllIn && netMyAction->myrelativebet() == 0)
-			netMyAction->set_myrelativebet(tmpPlayer->getMyCash());
+		if (netMyAction.myaction() == netActionAllIn && netMyAction.myrelativebet() == 0)
+			netMyAction.set_myrelativebet(tmpPlayer->getMyCash());

 		// Check whether the action is valid.
 		if (code == ACTION_CODE_VALID
 				&& (tmpPlayer->checkMyAction(
-						netMyAction->myaction(),
-						netMyAction->myrelativebet(),
+						netMyAction.myaction(),
+						netMyAction.myrelativebet(),
 						curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet(),
 						curGame.getCurrentHand()->getCurrentBeRo()->getMinimumRaise(),
 						curGame.getCurrentHand()->getSmallBlind()) != 0)) {
@@ -1557,17 +1602,21 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
 		if (code == ACTION_CODE_VALID) {
 			tmpPlayer->setIsSessionActive(true);
 			tmpPlayer->markRemoteAction();
-			PerformPlayerAction(*server, tmpPlayer, static_cast<PlayerAction>(netMyAction->myaction()), netMyAction->myrelativebet());
+			PerformPlayerAction(*server, tmpPlayer, static_cast<PlayerAction>(netMyAction.myaction()), netMyAction.myrelativebet());
 			server->SetState(ServerGameStateHand::Instance());
 		} else {
 			// Send reject message.
 			boost::shared_ptr<NetPacket> reject(new NetPacket);
-			reject->GetMsg()->set_messagetype(PokerTHMessage::Type_YourActionRejectedMessage);
-			YourActionRejectedMessage *netActionRejected = reject->GetMsg()->mutable_youractionrejectedmessage();
-			netActionRejected->set_gameid(server->GetId());
-			netActionRejected->set_gamestate(netMyAction->gamestate());
-			netActionRejected->set_youraction(netMyAction->myaction());
-			netActionRejected->set_yourrelativebet(netMyAction->myrelativebet());
+			reject->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+			GameMessage *netGame = reject->GetMsg()->mutable_gamemessage();
+			netGame->set_gameid(server->GetId());
+			netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+			GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+			netEngine->set_messagetype(GameEngineMessage::Type_YourActionRejectedMessage);
+			YourActionRejectedMessage *netActionRejected = netEngine->mutable_youractionrejectedmessage();
+			netActionRejected->set_gamestate(netMyAction.gamestate());
+			netActionRejected->set_youraction(netMyAction.myaction());
+			netActionRejected->set_yourrelativebet(netMyAction.myrelativebet());
 			netActionRejected->set_rejectionreason(static_cast<YourActionRejectedMessage::RejectionReason>(code));
 			server->GetLobbyThread().GetSender().Send(session, reject);
 		}
@@ -1642,16 +1691,21 @@ ServerGameStateWaitNextHand::Exit(boost::shared_ptr<ServerGame> server)
 }

 void
-ServerGameStateWaitNextHand::InternalProcessPacket(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
+ServerGameStateWaitNextHand::InternalHandleGameEngineMsg(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session, const GameEngineMessage &engineMsg)
 {
-	AbstractServerGameStateRunning::InternalProcessPacket(server, session, packet);
+	AbstractServerGameStateRunning::InternalHandleGameEngineMsg(server, session, engineMsg);

-	if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_ShowMyCardsRequestMessage) {
+	if (engineMsg.messagetype() == GameEngineMessage::Type_ShowMyCardsRequestMessage) {
 		Game &curGame = server->GetGame();
 		boost::shared_ptr<NetPacket> show(new NetPacket);
-		show->GetMsg()->set_messagetype(PokerTHMessage::Type_AfterHandShowCardsMessage);
+		show->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
+		GameMessage *netGame = show->GetMsg()->mutable_gamemessage();
+		netGame->set_gameid(server->GetId());
+		netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
+		GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
+		netEngine->set_messagetype(GameEngineMessage::Type_AfterHandShowCardsMessage);
+		AfterHandShowCardsMessage *netShowCards = netEngine->mutable_afterhandshowcardsmessage();

-		AfterHandShowCardsMessage *netShowCards = show->GetMsg()->mutable_afterhandshowcardsmessage();
 		boost::shared_ptr<PlayerInterface> tmpPlayer(curGame.getPlayerByUniqueId(session->GetPlayerData()->GetUniqueId()));
 		if (tmpPlayer) {
 			SetPlayerResult(*netShowCards->mutable_playerresult(), tmpPlayer, curGame.getCurrentHand()->getRoundBeforePostRiver());
@@ -48,7 +48,7 @@ using namespace boost::chrono;
 #endif

 SessionData::SessionData(boost::shared_ptr<boost::asio::ip::tcp::socket> sock, SessionId id, SessionDataCallback &cb, boost::asio::io_service &ioService)
-	: m_socket(sock), m_id(id), m_state(SessionData::Init), m_readyFlag(false), m_wantsLobbyMsg(true),
+	: m_socket(sock), m_id(id), m_state(SessionData::Auth), m_readyFlag(false), m_wantsLobbyMsg(true),
 	  m_activityTimeoutSec(0), m_activityWarningRemainingSec(0), m_initTimeoutTimer(ioService), m_globalTimeoutTimer(ioService),
 	  m_activityTimeoutTimer(ioService), m_callback(cb), m_authSession(NULL), m_curAuthStep(0)
 {
@@ -221,7 +221,7 @@ void
 SessionData::TimerInitTimeout(const boost::system::error_code &ec)
 {
 	if (!ec) {
-		if (GetState() == SessionData::Init) {
+		if (GetState() == SessionData::Auth || GetState() == SessionData::Init) {
 			m_callback.SessionError(shared_from_this(), ERR_NET_SESSION_TIMED_OUT);
 		}
 	}
@@ -100,7 +100,8 @@ SessionManager::GetSessionByPlayerName(const string &playerName) const

 	while (session_i != session_end) {
 		// Check all players which are fully connected.
-		if (session_i->second->GetState() != SessionData::Init) {
+		SessionData::State curState = session_i->second->GetState();
+		if (curState != SessionData::Auth && curState != SessionData::Init) {
 			boost::shared_ptr<PlayerData> tmpPlayer(session_i->second->GetPlayerData());
 			if (!tmpPlayer)
 				throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0);
@@ -126,7 +127,8 @@ SessionManager::GetSessionByUniquePlayerId(unsigned uniqueId, bool initSessions)

 	while (session_i != session_end) {
 		// Check all players which are fully connected.
-		if (initSessions || session_i->second->GetState() != SessionData::Init) {
+		SessionData::State curState = session_i->second->GetState();
+		if (initSessions || (curState != SessionData::Auth && curState != SessionData::Init)) {
 			boost::shared_ptr<PlayerData> tmpPlayer(session_i->second->GetPlayerData());
 			if (tmpPlayer && tmpPlayer->GetUniqueId() == uniqueId) {
 				tmpSession = session_i->second;
@@ -58,7 +58,7 @@ WebReceiveBuffer::HandleMessage(boost::shared_ptr<SessionData> session, const st
 	boost::shared_ptr<NetPacket> tmpPacket;
 	try {
 		tmpPacket = NetPacket::Create(msg.c_str(), msg.size());
-		if (!validator.IsValidPacket(*tmpPacket)) {
+		if (!validator.IsValidMessage(*tmpPacket->GetMsg())) {
 			LOG_ERROR("Session " << session->GetId() << " - Invalid packet: " << tmpPacket->GetMsg()->messagetype());
 			tmpPacket.reset();
 		}