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

More work on new network protocol.

Browse Source
This commit is contained in:
lotodore
2014-08-19 18:19:17 +02:00
parent 88e5f600aa
commit 47093976ca
3 changed files with 760 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/net/clientstate.h
+25 -7
View File
@@ -390,7 +390,7 @@ protected:
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg);
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
};
@@ -410,7 +410,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitGame();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg);
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
};
// State: Synchronize on game start.
@@ -430,7 +433,10 @@ protected:
ClientStateSynchronizeStart();
void TimerLoop(const boost::system::error_code& ec, boost::shared_ptr<ClientThread> client);
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
};
// State: Wait for game start.
@@ -449,7 +455,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitStart();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
};
// State: Wait for start of the next hand.
@@ -468,7 +477,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitHand();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
};
// State: Hand Loop.
@@ -487,7 +499,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateRunHand();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
static void ResetPlayerActions(Game &curGame);
static void ResetPlayerSets(Game &curGame);
@@ -502,7 +517,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> /*client*/) {}
virtual void Exit(boost::shared_ptr<ClientThread> /*client*/) {}
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
protected:
// Protected constructor - this is a singleton.
src/net/common/clientstate.cpp
+152 -106
View File
@@ -1205,7 +1205,7 @@ ClientStateWaitAuthVerify::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitAuthChallenge::InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg)
ClientStateWaitAuthVerify::InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg)
{
if (authMsg.messagetype() == AuthMessage::Type_AuthServerVerificationMessage) {
// Check subtype.
@@ -1319,14 +1319,50 @@ ClientStateWaitJoin::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitJoin::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitJoin::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg)
{
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;
}
client->GetCallback().SignalNetClientNotification(failureCode);
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = lobbyMsg.invitenotifymessage();
if (netInvNotify.playeridwho() == client->GetGuiPlayerId()) {
client->GetCallback().SignalSelfGameInvitation(netInvNotify.gameid(), netInvNotify.playeridbywhom());
}
}
}
void
ClientStateWaitJoin::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
ClientContext &context = client->GetContext();
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_JoinGameAckMessage) {
const JoinGameAckMessage &netJoinAck = tmpPacket->GetMsg()->joingameackmessage();
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(netJoinAck.gameid());
client->SetGameId(gameMsg.gameid());
GameData tmpData;
NetPacket::GetGameData(netJoinAck.gameinfo(), tmpData);
client->SetGameData(tmpData);
@@ -1342,9 +1378,9 @@ ClientStateWaitJoin::InternalHandlePacket(boost::shared_ptr<ClientThread> client
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_JOIN);
client->SetState(ClientStateWaitGame::Instance());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_JoinGameFailedMessage) {
} else if (managementMsg.messagetype() == GameManagementMessage::Type_JoinGameFailedMessage) {
// Failed to join a game.
const JoinGameFailedMessage &netJoinFailed = tmpPacket->GetMsg()->joingamefailedmessage();
const JoinGameFailedMessage &netJoinFailed = managementMsg.joingamefailedmessage();
int failureCode;
switch (netJoinFailed.joingamefailurereason()) {
@@ -1360,21 +1396,9 @@ ClientStateWaitJoin::InternalHandlePacket(boost::shared_ptr<ClientThread> client
case JoinGameFailedMessage::invalidPassword:
failureCode = NTF_NET_JOIN_INVALID_PASSWORD;
break;
case JoinGameFailedMessage::notAllowedAsGuest :
failureCode = NTF_NET_JOIN_GUEST_FORBIDDEN;
break;
case JoinGameFailedMessage::notInvited:
failureCode = NTF_NET_JOIN_NOT_INVITED;
break;
case JoinGameFailedMessage::gameNameInUse :
failureCode = NTF_NET_JOIN_GAME_NAME_IN_USE;
break;
case JoinGameFailedMessage::badGameName :
failureCode = NTF_NET_JOIN_GAME_BAD_NAME;
break;
case JoinGameFailedMessage::invalidSettings :
failureCode = NTF_NET_JOIN_INVALID_SETTINGS;
break;
case JoinGameFailedMessage::ipAddressBlocked:
failureCode = NTF_NET_JOIN_IP_BLOCKED;
break;
@@ -1387,10 +1411,6 @@ ClientStateWaitJoin::InternalHandlePacket(boost::shared_ptr<ClientThread> client
}
client->GetCallback().SignalNetClientNotification(failureCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = tmpPacket->GetMsg()->invitenotifymessage();
if (netInvNotify.playeridwho() == client->GetGuiPlayerId()) {
client->GetCallback().SignalSelfGameInvitation(netInvNotify.gameid(), netInvNotify.playeridbywhom());
}
}
}
@@ -1422,6 +1442,24 @@ ClientStateWaitGame::Exit(boost::shared_ptr<ClientThread> /*client*/)
{
}
void
ClientStateWaitGame::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg)
{
if (lobbyMsg.messagetype() == LobbyMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = lobbyMsg.invitenotifymessage();
client->GetCallback().SignalPlayerGameInvitation(
netInvNotify.gameid(),
netInvNotify.playeridwho(),
netInvNotify.playeridbywhom());
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_RejectInvNotifyMessage) {
const RejectInvNotifyMessage &netRejNotify = lobbyMsg.rejectinvnotifymessage();
client->GetCallback().SignalRejectedGameInvitation(
netRejNotify.gameid(),
netRejNotify.playerid(),
static_cast<DenyGameInvitationReason>(netRejNotify.playerrejectreason()));
}
}
void
ClientStateWaitGame::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
@@ -1432,23 +1470,10 @@ ClientStateWaitGame::InternalHandleGameMsg(boost::shared_ptr<ClientThread> clien
const StartEventMessage &netStartEvent = managementMsg.starteventmessage();
if (netStartEvent.starteventtype() == StartEventMessage::rejoinEvent) {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCREJOIN);
}
else {
} else {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCSTART);
}
client->SetState(ClientStateSynchronizeStart::Instance());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = managementMsg.invitenotifymessage();
client->GetCallback().SignalPlayerGameInvitation(
netInvNotify.gameid(),
netInvNotify.playeridwho(),
netInvNotify.playeridbywhom());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_RejectInvNotifyMessage) {
const RejectInvNotifyMessage &netRejNotify = tmpPacket->GetMsg()->rejectinvnotifymessage();
client->GetCallback().SignalRejectedGameInvitation(
netRejNotify.gameid(),
netRejNotify.playerid(),
static_cast<DenyGameInvitationReason>(netRejNotify.playerrejectreason()));
}
}
}
@@ -1493,9 +1518,13 @@ ClientStateSynchronizeStart::TimerLoop(const boost::system::error_code& ec, boos
if (client->IsSynchronized()) {
// Acknowledge start.
boost::shared_ptr<NetPacket> startAck(new NetPacket);
startAck->GetMsg()->set_messagetype(PokerTHMessage::Type_StartEventAckMessage);
StartEventAckMessage *netStartAck = startAck->GetMsg()->mutable_starteventackmessage();
netStartAck->set_gameid(client->GetGameId());
startAck->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
GameMessage *netGame = startAck->GetMsg()->mutable_gamemessage();
netGame->set_gameid(client->GetGameId());
netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
netManage->set_messagetype(GameManagementMessage::Type_StartEventAckMessage);
/*StartEventAckMessage *netStartAck = */netManage->mutable_starteventackmessage();
client->GetSender().Send(client->GetContext().GetSessionData(), startAck);
// Unsubscribe lobby messages.
@@ -1513,15 +1542,19 @@ ClientStateSynchronizeStart::TimerLoop(const boost::system::error_code& ec, boos
}
void
ClientStateSynchronizeStart::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateSynchronizeStart::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameStartInitialMessage) {
if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
if (managementMsg.messagetype() == GameManagementMessage::Type_GameStartInitialMessage) {
/*const GameStartInitialMessage &netStartInitial = managementMsg.gamestartinitialmessage();*/
// Try to start anyway. Terminating here is very bad because rejoin is not possible then.
// Unsubscribe lobby messages.
client->UnsubscribeLobbyMsg();
client->SetState(ClientStateWaitStart::Instance());
// Forward the game start message to the next state.
client->GetState().HandlePacket(client, tmpPacket);
ClientStateWaitStart::Instance().HandleGameMsg(client, gameMsg);
}
}
}
@@ -1553,16 +1586,18 @@ ClientStateWaitStart::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitStart::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitStart::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameStartInitialMessage
|| tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameStartRejoinMessage) {
if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
if (managementMsg.messagetype() == GameManagementMessage::Type_GameStartInitialMessage
|| managementMsg.messagetype() == GameManagementMessage::Type_GameStartRejoinMessage) {
PlayerIdList tmpPlayerList;
unsigned tmpHandId = 0;
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameStartInitialMessage) {
if (managementMsg.messagetype() == GameManagementMessage::Type_GameStartInitialMessage) {
// Start the network game as client.
const GameStartInitialMessage &netStartModeInitial = tmpPacket->GetMsg()->gamestartinitialmessage();
const GameStartInitialMessage &netStartModeInitial = managementMsg.gamestartinitialmessage();
StartData startData;
startData.startDealerPlayerId = netStartModeInitial.startdealerplayerid();
@@ -1583,8 +1618,8 @@ ClientStateWaitStart::InternalHandlePacket(boost::shared_ptr<ClientThread> clien
} else {
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PLAYER_COUNT, 0);
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameStartRejoinMessage) {
const GameStartRejoinMessage &netStartModeRejoin = tmpPacket->GetMsg()->gamestartrejoinmessage();
} else if (managementMsg.messagetype() == GameManagementMessage::Type_GameStartRejoinMessage) {
const GameStartRejoinMessage &netStartModeRejoin = managementMsg.gamestartrejoinmessage();
StartData startData;
startData.startDealerPlayerId = netStartModeRejoin.startdealerplayerid();
@@ -1622,6 +1657,7 @@ ClientStateWaitStart::InternalHandlePacket(boost::shared_ptr<ClientThread> clien
client->SetState(ClientStateWaitHand::Instance());
}
}
}
//-----------------------------------------------------------------------------
@@ -1651,12 +1687,53 @@ ClientStateWaitHand::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitHand::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_HandStartMessage) {
if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage) {
const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
if (managementMsg.messagetype() == GameManagementMessage::Type_EndOfGameMessage)
{
boost::shared_ptr<Game> curGame = client->GetGame();
if (curGame) {
const EndOfGameMessage &netEndOfGame = managementMsg.endofgamemessage();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netEndOfGame.winnerplayerid());
if (!tmpPlayer)
throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
client->GetGui().logPlayerWinGame(tmpPlayer->getMyName(), curGame->getMyGameID());
// Resubscribe Lobby messages.
client->ResubscribeLobbyMsg();
// Show Lobby dialog.
client->GetCallback().SignalNetClientWaitDialog();
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_END);
client->SetState(ClientStateWaitGame::Instance());
}
} else if (managementMsg.messagetype() == GameManagementMessage::Type_PlayerIdChangedMessage) {
boost::shared_ptr<Game> curGame = client->GetGame();
if (curGame) {
// Perform Id change.
const PlayerIdChangedMessage &idChanged = managementMsg.playeridchangedmessage();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(idChanged.oldplayerid());
if (!tmpPlayer)
throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
tmpPlayer->setMyUniqueID(idChanged.newplayerid());
// This player is now active again.
tmpPlayer->setMyStayOnTableStatus(true);
// Also update the dealer, if necessary.
curGame->replaceDealer(idChanged.oldplayerid(), idChanged.newplayerid());
// Update the player name, if necessary.
PlayerInfo info;
if (client->GetCachedPlayerInfo(idChanged.newplayerid(), info)) {
tmpPlayer->setMyName(info.playerName);
}
}
}
} else if (gameMsg.messagetype() == GameMessage::Type_GameEngineMessage) {
const GameEngineMessage &engineMsg = gameMsg.gameenginemessage();
if (engineMsg.messagetype() == GameEngineMessage::Type_HandStartMessage) {
// Hand was started.
// These are the cards. Good luck.
const HandStartMessage &netHandStart = tmpPacket->GetMsg()->handstartmessage();
const HandStartMessage &netHandStart = engineMsg.handstartmessage();
int myCards[2];
string userPassword(client->GetContext().GetPassword());
if (netHandStart.has_plaincards() && userPassword.empty()) {
@@ -1724,24 +1801,8 @@ ClientStateWaitHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_HAND_START);
client->SetState(ClientStateRunHand::Instance());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_EndOfGameMessage) {
boost::shared_ptr<Game> curGame = client->GetGame();
if (curGame) {
const EndOfGameMessage &netEndOfGame = tmpPacket->GetMsg()->endofgamemessage();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netEndOfGame.winnerplayerid());
if (!tmpPlayer)
throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
client->GetGui().logPlayerWinGame(tmpPlayer->getMyName(), curGame->getMyGameID());
// Resubscribe Lobby messages.
client->ResubscribeLobbyMsg();
// Show Lobby dialog.
client->GetCallback().SignalNetClientWaitDialog();
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_END);
client->SetState(ClientStateWaitGame::Instance());
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AfterHandShowCardsMessage) {
const AfterHandShowCardsMessage &showCards = tmpPacket->GetMsg()->afterhandshowcardsmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_AfterHandShowCardsMessage) {
const AfterHandShowCardsMessage &showCards = engineMsg.afterhandshowcardsmessage();
const PlayerResult &r = showCards.playerresult();
boost::shared_ptr<PlayerInterface> tmpPlayer = client->GetGame()->getPlayerByUniqueId(r.playerid());
@@ -1765,24 +1826,6 @@ ClientStateWaitHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client
client->GetCallback().SignalNetClientPostRiverShowCards(r.playerid());
client->GetClientLog()->logHoleCardsHandName(client->GetGame()->getActivePlayerList(), tmpPlayer, true);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_PlayerIdChangedMessage) {
boost::shared_ptr<Game> curGame = client->GetGame();
if (curGame) {
// Perform Id change.
const PlayerIdChangedMessage &idChanged = tmpPacket->GetMsg()->playeridchangedmessage();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(idChanged.oldplayerid());
if (!tmpPlayer)
throw ClientException(__FILE__, __LINE__, ERR_NET_UNKNOWN_PLAYER_ID, 0);
tmpPlayer->setMyUniqueID(idChanged.newplayerid());
// This player is now active again.
tmpPlayer->setMyStayOnTableStatus(true);
// Also update the dealer, if necessary.
curGame->replaceDealer(idChanged.oldplayerid(), idChanged.newplayerid());
// Update the player name, if necessary.
PlayerInfo info;
if (client->GetCachedPlayerInfo(idChanged.newplayerid(), info)) {
tmpPlayer->setMyName(info.playerName);
}
}
}
}
@@ -1815,11 +1858,13 @@ ClientStateRunHand::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateRunHand::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
boost::shared_ptr<Game> curGame = client->GetGame();
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_PlayersActionDoneMessage) {
const PlayersActionDoneMessage &netActionDone = tmpPacket->GetMsg()->playersactiondonemessage();
if (gameMsg.messagetype() == GameMessage::Type_GameEngineMessage) {
const GameEngineMessage &engineMsg = gameMsg.gameenginemessage();
if (engineMsg.messagetype() == GameEngineMessage::Type_PlayersActionDoneMessage) {
const PlayersActionDoneMessage &netActionDone = engineMsg.playersactiondonemessage();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netActionDone.playerid());
if (!tmpPlayer)
@@ -1895,8 +1940,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
client->GetGui().refreshCash();
client->GetGui().refreshButton();
client->GetGui().updateMyButtonsState();
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_PlayersTurnMessage) {
const PlayersTurnMessage &netPlayersTurn = tmpPacket->GetMsg()->playersturnmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_PlayersTurnMessage) {
const PlayersTurnMessage &netPlayersTurn = engineMsg.playersturnmessage();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame->getPlayerByUniqueId(netPlayersTurn.playerid());
if (!tmpPlayer)
@@ -1929,8 +1974,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
if (tmpPlayer->getMyID() == 0) // Is this the GUI player?
client->GetGui().meInAction();
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_DealFlopCardsMessage) {
const DealFlopCardsMessage &netDealFlop = tmpPacket->GetMsg()->dealflopcardsmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_DealFlopCardsMessage) {
const DealFlopCardsMessage &netDealFlop = engineMsg.dealflopcardsmessage();
int tmpCards[5];
tmpCards[0] = static_cast<int>(netDealFlop.flopcard1());
@@ -1948,8 +1993,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
client->GetGui().refreshPot();
client->GetGui().refreshSet();
client->GetGui().dealBeRoCards(1);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_DealTurnCardMessage) {
const DealTurnCardMessage &netDealTurn = tmpPacket->GetMsg()->dealturncardmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_DealTurnCardMessage) {
const DealTurnCardMessage &netDealTurn = engineMsg.dealturncardmessage();
int tmpCards[5];
curGame->getCurrentHand()->getBoard()->getMyCards(tmpCards);
@@ -1965,8 +2010,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
client->GetGui().refreshPot();
client->GetGui().refreshSet();
client->GetGui().dealBeRoCards(2);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_DealRiverCardMessage) {
const DealRiverCardMessage &netDealRiver = tmpPacket->GetMsg()->dealrivercardmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_DealRiverCardMessage) {
const DealRiverCardMessage &netDealRiver = engineMsg.dealrivercardmessage();
int tmpCards[5];
curGame->getCurrentHand()->getBoard()->getMyCards(tmpCards);
@@ -1982,8 +2027,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
client->GetGui().refreshPot();
client->GetGui().refreshSet();
client->GetGui().dealBeRoCards(3);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AllInShowCardsMessage) {
const AllInShowCardsMessage &netAllInShow = tmpPacket->GetMsg()->allinshowcardsmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_AllInShowCardsMessage) {
const AllInShowCardsMessage &netAllInShow = engineMsg.allinshowcardsmessage();
curGame->getCurrentHand()->setAllInCondition(true);
@@ -2008,8 +2053,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
curGame->getActivePlayerList()
);
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_EndOfHandHideCardsMessage) {
const EndOfHandHideCardsMessage &hideCards = tmpPacket->GetMsg()->endofhandhidecardsmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_EndOfHandHideCardsMessage) {
const EndOfHandHideCardsMessage &hideCards = engineMsg.endofhandhidecardsmessage();
curGame->getCurrentHand()->getBoard()->collectPot();
// Reset player sets
ResetPlayerSets(*curGame);
@@ -2044,8 +2089,8 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
client->GetClientLog()->logPlayerSitsOut(curGame->getActivePlayerList());
client->GetClientLog()->logGameWinner(curGame->getActivePlayerList());
client->GetClientLog()->logAfterHand();
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_EndOfHandShowCardsMessage) {
const EndOfHandShowCardsMessage &showCards = tmpPacket->GetMsg()->endofhandshowcardsmessage();
} else if (engineMsg.messagetype() == GameEngineMessage::Type_EndOfHandShowCardsMessage) {
const EndOfHandShowCardsMessage &showCards = engineMsg.endofhandshowcardsmessage();
curGame->getCurrentHand()->getBoard()->collectPot();
// Reset player sets
@@ -2111,6 +2156,7 @@ ClientStateRunHand::InternalHandlePacket(boost::shared_ptr<ClientThread> client,
client->GetClientLog()->logGameWinner(curGame->getActivePlayerList());
client->GetClientLog()->logAfterHand();
}
}
// Synchronize with GUI.
client->GetGui().waitForGuiUpdateDone();
src/net/common/clientthread.cpp
+151 -64
View File
@@ -128,9 +128,13 @@ void
ClientThread::SendKickPlayer(unsigned playerId)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_KickPlayerRequestMessage);
KickPlayerRequestMessage *netKick = packet->GetMsg()->mutable_kickplayerrequestmessage();
netKick->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_GameManagementMessage);
GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
netManage->set_messagetype(GameManagementMessage::Type_KickPlayerRequestMessage);
KickPlayerRequestMessage *netKick = netManage->mutable_kickplayerrequestmessage();
netKick->set_playerid(playerId);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -139,9 +143,13 @@ void
ClientThread::SendLeaveCurrentGame()
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LeaveGameRequestMessage);
LeaveGameRequestMessage *netLeave = packet->GetMsg()->mutable_leavegamerequestmessage();
netLeave->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_GameManagementMessage);
GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
netManage->set_messagetype(GameManagementMessage::Type_LeaveGameRequestMessage);
/*LeaveGameRequestMessage *netLeave = */netManage->mutable_leavegamerequestmessage();
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -151,10 +159,14 @@ ClientThread::SendStartEvent(bool fillUpWithCpuPlayers)
// Warning: This function is called in the context of the GUI thread.
// Create a network packet for the server start event.
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(GetGameId());
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(GetGameId());
netStartEvent->set_fillwithcomputerplayers(fillUpWithCpuPlayers);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -169,9 +181,13 @@ ClientThread::SendPlayerAction()
m_pingData.StartPing();
}
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_MyActionRequestMessage);
MyActionRequestMessage *netMyAction = packet->GetMsg()->mutable_myactionrequestmessage();
netMyAction->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);
GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
netEngine->set_messagetype(GameEngineMessage::Type_MyActionRequestMessage);
MyActionRequestMessage *netMyAction = netEngine->mutable_myactionrequestmessage();
boost::shared_ptr<PlayerInterface> myPlayer = GetGame()->getSeatsList()->front();
netMyAction->set_handnum(GetGame()->getCurrentHandID());
netMyAction->set_gamestate(static_cast<NetGameState>(GetGame()->getCurrentHand()->getCurrentRound()));
@@ -191,9 +207,13 @@ ClientThread::SendGameChatMessage(const std::string &msg)
// Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the chat message.
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ChatRequestMessage);
ChatRequestMessage *netChat = packet->GetMsg()->mutable_chatrequestmessage();
netChat->set_targetgameid(GetGameId());
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
netGame->set_gameid(GetGameId());
netGame->set_messagetype(GameMessage::Type_GameManagementMessage);
GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
netManage->set_messagetype(GameManagementMessage::Type_ChatRequestMessage);
ChatRequestMessage *netChat = netManage->mutable_chatrequestmessage();
netChat->set_chattext(msg);
// Just dump the packet.
@@ -206,8 +226,10 @@ ClientThread::SendLobbyChatMessage(const std::string &msg)
// Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the chat message.
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ChatRequestMessage);
ChatRequestMessage *netChat = packet->GetMsg()->mutable_chatrequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_ChatRequestMessage);
ChatRequestMessage *netChat = netLobby->mutable_chatrequestmessage();
netChat->set_chattext(msg);
// Just dump the packet.
@@ -220,8 +242,10 @@ ClientThread::SendPrivateChatMessage(unsigned targetPlayerId, const std::string
// Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the chat message.
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ChatRequestMessage);
ChatRequestMessage *netChat = packet->GetMsg()->mutable_chatrequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_ChatRequestMessage);
ChatRequestMessage *netChat = netLobby->mutable_chatrequestmessage();
netChat->set_targetplayerid(targetPlayerId);
netChat->set_chattext(msg);
@@ -235,9 +259,13 @@ 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_JoinExistingGameMessage);
JoinExistingGameMessage *netJoinGame = packet->GetMsg()->mutable_joinexistinggamemessage();
netJoinGame->set_gameid(1);
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();
netJoinGame->set_autoleave(autoLeave);
if (!password.empty()) {
@@ -252,9 +280,13 @@ 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_JoinExistingGameMessage);
JoinExistingGameMessage *netJoinGame = packet->GetMsg()->mutable_joinexistinggamemessage();
netJoinGame->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_JoinGameMessage);
JoinGameMessage *netJoinGame = netManage->mutable_joingamemessage();
netJoinGame->set_autoleave(autoLeave);
if (!password.empty()) {
@@ -269,9 +301,13 @@ 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_RejoinExistingGameMessage);
RejoinExistingGameMessage *netJoinGame = packet->GetMsg()->mutable_rejoinexistinggamemessage();
netJoinGame->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_RejoinGameMessage);
RejoinGameMessage *netJoinGame = netManage->mutable_rejoingamemessage();
netJoinGame->set_autoleave(autoLeave);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
@@ -283,15 +319,17 @@ ClientThread::SendCreateGame(const GameData &gameData, const std::string &name,
// Warning: This function is called in the context of the GUI thread.
// Create a network packet to request creating a new game.
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_JoinNewGameMessage);
JoinNewGameMessage *netJoinGame = packet->GetMsg()->mutable_joinnewgamemessage();
netJoinGame->set_autoleave(autoLeave);
NetGameInfo *gameInfo = netJoinGame->mutable_gameinfo();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_CreateGameMessage);
CreateGameMessage *netCreateGame = netLobby->mutable_creategamemessage();
netCreateGame->set_autoleave(autoLeave);
NetGameInfo *gameInfo = netCreateGame->mutable_gameinfo();
NetPacket::SetGameData(gameData, *gameInfo);
gameInfo->set_gamename(name);
if (!password.empty()) {
netJoinGame->set_password(password);
netCreateGame->set_password(password);
}
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -300,8 +338,10 @@ void
ClientThread::SendResetTimeout()
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ResetTimeoutMessage);
packet->GetMsg()->mutable_resettimeoutmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_ResetTimeoutMessage);
netLobby->mutable_resettimeoutmessage();
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -309,9 +349,13 @@ void
ClientThread::SendAskKickPlayer(unsigned playerId)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AskKickPlayerMessage);
AskKickPlayerMessage *netAsk = packet->GetMsg()->mutable_askkickplayermessage();
netAsk->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_GameManagementMessage);
GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
netManage->set_messagetype(GameManagementMessage::Type_AskKickPlayerMessage);
AskKickPlayerMessage *netAsk = netManage->mutable_askkickplayermessage();
netAsk->set_playerid(playerId);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -320,9 +364,13 @@ void
ClientThread::SendVoteKick(bool doKick)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_VoteKickRequestMessage);
VoteKickRequestMessage *netVote = packet->GetMsg()->mutable_votekickrequestmessage();
netVote->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_GameManagementMessage);
GameManagementMessage *netManage = netGame->mutable_gamemanagementmessage();
netManage->set_messagetype(GameManagementMessage::Type_VoteKickRequestMessage);
VoteKickRequestMessage *netVote = netManage->mutable_votekickrequestmessage();
{
boost::mutex::scoped_lock lock(m_curPetitionIdMutex);
netVote->set_petitionid(m_curPetitionId);
@@ -335,8 +383,13 @@ void
ClientThread::SendShowMyCards()
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ShowMyCardsRequestMessage);
packet->GetMsg()->mutable_showmycardsrequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameMessage);
GameMessage *netGame = packet->GetMsg()->mutable_gamemessage();
netGame->set_gameid(GetGameId());
netGame->set_messagetype(GameMessage::Type_GameEngineMessage);
GameEngineMessage *netEngine = netGame->mutable_gameenginemessage();
netEngine->set_messagetype(GameEngineMessage::Type_ShowMyCardsRequestMessage);
netEngine->mutable_showmycardsrequestmessage();
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -344,8 +397,10 @@ void
ClientThread::SendInvitePlayerToCurrentGame(unsigned playerId)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_InvitePlayerToGameMessage);
InvitePlayerToGameMessage *netInvite = packet->GetMsg()->mutable_inviteplayertogamemessage();
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());
netInvite->set_playerid(playerId);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
@@ -355,8 +410,10 @@ void
ClientThread::SendRejectGameInvitation(unsigned gameId, DenyGameInvitationReason reason)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_RejectGameInvitationMessage);
RejectGameInvitationMessage *netReject = packet->GetMsg()->mutable_rejectgameinvitationmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_RejectGameInvitationMessage);
RejectGameInvitationMessage *netReject = netLobby->mutable_rejectgameinvitationmessage();
netReject->set_gameid(gameId);
netReject->set_myrejectreason(static_cast<RejectGameInvitationMessage::RejectGameInvReason>(reason));
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
@@ -366,8 +423,10 @@ void
ClientThread::SendReportAvatar(unsigned reportedPlayerId, const std::string &avatarHash)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ReportAvatarMessage);
ReportAvatarMessage *netReport = packet->GetMsg()->mutable_reportavatarmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_ReportAvatarMessage);
ReportAvatarMessage *netReport = netLobby->mutable_reportavatarmessage();
netReport->set_reportedplayerid(reportedPlayerId);
MD5Buf tmpMD5;
if (tmpMD5.FromString(avatarHash) && !tmpMD5.IsZero()) {
@@ -381,8 +440,10 @@ void
ClientThread::SendReportGameName(unsigned reportedGameId)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_ReportGameMessage);
ReportGameMessage *netReport = packet->GetMsg()->mutable_reportgamemessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_ReportGameMessage);
ReportGameMessage *netReport = netLobby->mutable_reportgamemessage();
netReport->set_reportedgameid(reportedGameId);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -391,8 +452,10 @@ void
ClientThread::SendAdminRemoveGame(unsigned removeGameId)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AdminRemoveGameMessage);
AdminRemoveGameMessage *netRemove = packet->GetMsg()->mutable_adminremovegamemessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AdminRemoveGameMessage);
AdminRemoveGameMessage *netRemove = netLobby->mutable_adminremovegamemessage();
netRemove->set_removegameid(removeGameId);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -401,8 +464,10 @@ void
ClientThread::SendAdminBanPlayer(unsigned playerId)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AdminBanPlayerMessage);
AdminBanPlayerMessage *netBan = packet->GetMsg()->mutable_adminbanplayermessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AdminBanPlayerMessage);
AdminBanPlayerMessage *netBan = netLobby->mutable_adminbanplayermessage();
netBan->set_banplayerid(playerId);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
@@ -422,7 +487,21 @@ ClientThread::CloseSession(boost::shared_ptr<SessionData> /*session*/)
void
ClientThread::HandlePacket(boost::shared_ptr<SessionData> /*session*/, boost::shared_ptr<NetPacket> packet)
{
GetState().HandlePacket(shared_from_this(), 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;
}
}
void
@@ -700,8 +779,10 @@ void
ClientThread::RequestPlayerInfo(const list<unsigned> &idList, bool requestAvatar)
{
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayerInfoRequestMessage);
PlayerInfoRequestMessage *netPlayerInfo = packet->GetMsg()->mutable_playerinforequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_PlayerInfoRequestMessage);
PlayerInfoRequestMessage *netPlayerInfo = netLobby->mutable_playerinforequestmessage();
BOOST_FOREACH(unsigned playerId, idList) {
if (find(m_playerInfoRequestList.begin(), m_playerInfoRequestList.end(), playerId) == m_playerInfoRequestList.end()) {
netPlayerInfo->add_playerid(playerId);
@@ -812,8 +893,10 @@ ClientThread::RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info)
id, avatarServerAddress + serverFileName, GetContext().GetCacheDir() + TEMP_AVATAR_FILENAME);
} else {
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarRequestMessage);
AvatarRequestMessage *netAvatar = packet->GetMsg()->mutable_avatarrequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarRequestMessage);
AvatarRequestMessage *netAvatar = netLobby->mutable_avatarrequestmessage();
netAvatar->set_requestid(id);
netAvatar->set_avatarhash(info.avatar.GetData(), MD5_DATA_SIZE);
GetSender().Send(GetContext().GetSessionData(), packet);
@@ -929,8 +1012,10 @@ ClientThread::UnsubscribeLobbyMsg()
if (GetContext().GetSubscribeLobbyMsg()) {
// Send unsubscribe request.
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_SubscriptionRequestMessage);
SubscriptionRequestMessage *netRequest = packet->GetMsg()->mutable_subscriptionrequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_SubscriptionRequestMessage);
SubscriptionRequestMessage *netRequest = netLobby->mutable_subscriptionrequestmessage();
netRequest->set_subscriptionaction(SubscriptionRequestMessage::unsubscribeGameList);
GetSender().Send(GetContext().GetSessionData(), packet);
GetContext().SetSubscribeLobbyMsg(false);
@@ -945,8 +1030,10 @@ ClientThread::ResubscribeLobbyMsg()
ClearGameInfoMap();
// Send resubscribe request.
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_SubscriptionRequestMessage);
SubscriptionRequestMessage *netRequest = packet->GetMsg()->mutable_subscriptionrequestmessage();
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = packet->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_SubscriptionRequestMessage);
SubscriptionRequestMessage *netRequest = netLobby->mutable_subscriptionrequestmessage();
netRequest->set_subscriptionaction(SubscriptionRequestMessage::resubscribeGameList);
GetSender().Send(GetContext().GetSessionData(), packet);
GetContext().SetSubscribeLobbyMsg(true);