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

Completely rewriting all NetPacket stuff to use ASN.1. Finally this big chunk of work is completed. Compiles and links fine, but still partly non-functional.

Browse Source 
PLEASE NOTE: This is NOT COMPATIBLE to 0.7.x, because it is a new network protocol.
This commit is contained in:
lotodore
2009-08-02 15:11:40 +00:00
parent d7367788a7
commit 945c4a102a
24 changed files with 1517 additions and 8265 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pokerth_server.pro
+1
View File
@@ -31,6 +31,7 @@ INCLUDEPATH += . \
src/engine/network_engine \ src/engine/network_engine \
src/config \ src/config \
src/third_party/tinyxml \ src/third_party/tinyxml \
src/third_party/asn1 \
src/core \ src/core \
DEPENDPATH += . \ DEPENDPATH += . \
src/core/avatarmanager.h
+2
View File
@@ -27,6 +27,8 @@
#include <map> #include <map>
#include <list> #include <list>
#include <playerdata.h>
#include <core/crypthelper.h>
#include <net/netpacket.h> #include <net/netpacket.h>
#define MIN_AVATAR_FILE_SIZE 32 #define MIN_AVATAR_FILE_SIZE 32
src/core/common/avatarmanager.cpp
+24 -17
View File
@@ -194,28 +194,34 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
boost::shared_ptr<AvatarFileState> tmpState = OpenAvatarFileForChunkRead(fileName, fileSize, fileType); boost::shared_ptr<AvatarFileState> tmpState = OpenAvatarFileForChunkRead(fileName, fileSize, fileType);
if (tmpState.get() && fileSize && fileType != AVATAR_FILE_TYPE_UNKNOWN) if (tmpState.get() && fileSize && fileType != AVATAR_FILE_TYPE_UNKNOWN)
{ {
boost::shared_ptr<NetPacket> avatarHeader(new NetPacketAvatarHeader); boost::shared_ptr<NetPacket> avatarHeader(new NetPacket(NetPacket::Alloc));
NetPacketAvatarHeader::Data avatarHeaderData; avatarHeader->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
avatarHeaderData.requestId = requestId; AvatarReplyMessage_t *netHeader = &avatarHeader->GetMsg()->choice.avatarReplyMessage;
avatarHeaderData.avatarFileSize = fileSize; netHeader->requestId = requestId;
avatarHeaderData.avatarFileType = fileType; netHeader->avatarResult.present = avatarResult_PR_avatarHeader;
static_cast<NetPacketAvatarHeader *>(avatarHeader.get())->SetData(avatarHeaderData); netHeader->avatarResult.choice.avatarHeader.avatarType = fileType;
netHeader->avatarResult.choice.avatarHeader.avatarSize = fileSize;
packets.push_back(avatarHeader); packets.push_back(avatarHeader);
unsigned numBytes = 0; unsigned numBytes = 0;
unsigned totalBytesRead = 0; unsigned totalBytesRead = 0;
vector<unsigned char> tmpData(MAX_FILE_DATA_SIZE);
do do
{ {
boost::shared_ptr<NetPacketAvatarFile> avatarFile(new NetPacketAvatarFile); numBytes = ChunkReadAvatarFile(tmpState, &tmpData[0], MAX_FILE_DATA_SIZE);
NetPacketAvatarFile::Data avatarFileData;
avatarFileData.fileData.resize(MAX_FILE_DATA_SIZE);
numBytes = ChunkReadAvatarFile(tmpState, &avatarFileData.fileData[0], MAX_FILE_DATA_SIZE);
if (numBytes) if (numBytes)
{ {
avatarFileData.fileData.resize(numBytes);
avatarFileData.requestId = requestId;
totalBytesRead += numBytes; totalBytesRead += numBytes;
static_cast<NetPacketAvatarFile *>(avatarFile.get())->SetData(avatarFileData);
boost::shared_ptr<NetPacket> avatarFile(new NetPacket(NetPacket::Alloc));
avatarFile->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
AvatarReplyMessage_t *netFile = &avatarFile->GetMsg()->choice.avatarReplyMessage;
netFile->requestId = requestId;
netFile->avatarResult.present = avatarResult_PR_avatarData;
OCTET_STRING_fromBuf(
&netFile->avatarResult.choice.avatarData.avatarBlock,
(const char *)&tmpData[0],
numBytes);
packets.push_back(avatarFile); packets.push_back(avatarFile);
} }
} while (numBytes); } while (numBytes);
@@ -224,10 +230,11 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
retVal = ERR_NET_WRONG_AVATAR_SIZE; retVal = ERR_NET_WRONG_AVATAR_SIZE;
else else
{ {
boost::shared_ptr<NetPacket> avatarEnd(new NetPacketAvatarEnd); boost::shared_ptr<NetPacket> avatarEnd(new NetPacket(NetPacket::Alloc));
NetPacketAvatarEnd::Data avatarEndData; avatarEnd->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
avatarEndData.requestId = requestId; AvatarReplyMessage_t *netEnd = &avatarEnd->GetMsg()->choice.avatarReplyMessage;
static_cast<NetPacketAvatarEnd *>(avatarEnd.get())->SetData(avatarEndData); netEnd->requestId = requestId;
netEnd->avatarResult.present = avatarResult_PR_avatarEnd;
packets.push_back(avatarEnd); packets.push_back(avatarEnd);
retVal = 0; retVal = 0;
} }
src/game_defs.h
+2 -5
View File
@@ -75,8 +75,7 @@ enum DenyKickPlayerReason
KICK_DENIED_TOO_FEW_PLAYERS, KICK_DENIED_TOO_FEW_PLAYERS,
KICK_DENIED_TEMPORARY, KICK_DENIED_TEMPORARY,
KICK_DENIED_OTHER_IN_PROGRESS, KICK_DENIED_OTHER_IN_PROGRESS,
KICK_DENIED_INVALID_PLAYER_ID, KICK_DENIED_INVALID_PLAYER_ID
KICK_DENIED_OTHER_REASON
}; };
enum KickVote enum KickVote
@@ -88,9 +87,7 @@ enum KickVote
enum DenyVoteReason enum DenyVoteReason
{ {
VOTE_DENIED_INVALID_PETITION = 0, VOTE_DENIED_INVALID_PETITION = 0,
VOTE_DENIED_ALREADY_VOTED, VOTE_DENIED_ALREADY_VOTED
VOTE_DENIED_IMPOSSIBLE,
VOTE_DENIED_OTHER_REASON
}; };
enum EndPetitionReason enum EndPetitionReason
src/net/clientthread.h
+6 -6
View File
@@ -98,7 +98,7 @@ protected:
typedef std::map<unsigned, GameInfo> GameInfoMap; typedef std::map<unsigned, GameInfo> GameInfoMap;
typedef std::list<boost::shared_ptr<NetPacket> > NetPacketList; typedef std::list<boost::shared_ptr<NetPacket> > NetPacketList;
typedef std::map<unsigned, PlayerInfo> PlayerInfoMap; typedef std::map<unsigned, PlayerInfo> PlayerInfoMap;
typedef std::map<unsigned, boost::shared_ptr<AvatarData> > AvatarDataMap; typedef std::map<unsigned, boost::shared_ptr<AvatarFile> > AvatarFileMap;
typedef std::map<unsigned, ServerInfo> ServerInfoMap; typedef std::map<unsigned, ServerInfo> ServerInfoMap;
// Main function of the thread. // Main function of the thread.
@@ -117,10 +117,10 @@ protected:
void SetNewGameAdmin(unsigned id); void SetNewGameAdmin(unsigned id);
void RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info); void RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info);
void AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFileType type); void AddTempAvatarFile(unsigned playerId, unsigned avatarSize, AvatarFileType type);
void StoreInTempAvatarData(unsigned playerId, const std::vector<unsigned char> &data); void StoreInTempAvatarFile(unsigned playerId, const std::vector<unsigned char> &data);
void CompleteTempAvatarData(unsigned playerId); void CompleteTempAvatarFile(unsigned playerId);
void PassAvatarDataToManager(unsigned playerId, boost::shared_ptr<AvatarData> avatarData); void PassAvatarFileToManager(unsigned playerId, boost::shared_ptr<AvatarFile> AvatarFile);
void SetUnknownAvatar(unsigned playerId); void SetUnknownAvatar(unsigned playerId);
void TimerCheckAvatarDownloads(const boost::system::error_code& ec); void TimerCheckAvatarDownloads(const boost::system::error_code& ec);
@@ -234,7 +234,7 @@ private:
unsigned m_curPetitionId; unsigned m_curPetitionId;
mutable boost::mutex m_curPetitionIdMutex; mutable boost::mutex m_curPetitionIdMutex;
AvatarDataMap m_tempAvatarMap; AvatarFileMap m_tempAvatarMap;
unsigned m_curGameNum; unsigned m_curGameNum;
unsigned m_guiPlayerId; unsigned m_guiPlayerId;
src/net/common/clientcontext.cpp
+1
View File
@@ -17,6 +17,7 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include <boost/asio.hpp>
#include <net/clientcontext.h> #include <net/clientcontext.h>
src/net/common/clientstate.cpp
+481 -375
View File
File diff suppressed because it is too large Load Diff
src/net/common/clientthread.cpp
+128 -119
View File
@@ -119,18 +119,20 @@ ClientThread::SignalTermination()
void void
ClientThread::SendKickPlayer(unsigned playerId) ClientThread::SendKickPlayer(unsigned playerId)
{ {
boost::shared_ptr<NetPacket> request(new NetPacketKickPlayer); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketKickPlayer::Data requestData; packet->GetMsg()->present = PokerTHMessage_PR_kickPlayerRequestMessage;
requestData.playerId = playerId; KickPlayerRequestMessage_t *netKick = &packet->GetMsg()->choice.kickPlayerRequestMessage;
static_cast<NetPacketKickPlayer *>(request.get())->SetData(requestData); netKick->gameId = GetGameId();
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), request)); netKick->playerId = playerId;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
ClientThread::SendLeaveCurrentGame() ClientThread::SendLeaveCurrentGame()
{ {
boost::shared_ptr<NetPacket> request(new NetPacketLeaveCurrentGame); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), request)); packet->GetMsg()->present = PokerTHMessage_PR_leaveGameRequestMessage;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
@@ -138,17 +140,12 @@ ClientThread::SendStartEvent(bool fillUpWithCpuPlayers)
{ {
// Warning: This function is called in the context of the GUI thread. // Warning: This function is called in the context of the GUI thread.
// Create a network packet for the server start event. // Create a network packet for the server start event.
boost::shared_ptr<NetPacket> start(new NetPacketStartEvent); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketStartEvent::Data startData; packet->GetMsg()->present = PokerTHMessage_PR_startEventMessage;
startData.fillUpWithCpuPlayers = fillUpWithCpuPlayers; StartEventMessage_t *netStartEvent = &packet->GetMsg()->choice.startEventMessage;
try netStartEvent->gameId = GetGameId();
{ netStartEvent->fillWithComputerPlayers = fillUpWithCpuPlayers;
static_cast<NetPacketStartEvent *>(start.get())->SetData(startData); m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), start));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendStartEvent: " << e.what());
}
} }
void void
@@ -156,25 +153,20 @@ ClientThread::SendPlayerAction()
{ {
// Warning: This function is called in the context of the GUI thread. // Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the current player action. // Create a network packet containing the current player action.
boost::shared_ptr<NetPacket> action(new NetPacketPlayersAction); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketPlayersAction::Data actionData; packet->GetMsg()->present = PokerTHMessage_PR_myActionRequestMessage;
MyActionRequestMessage_t *netMyAction = &packet->GetMsg()->choice.myActionRequestMessage;
netMyAction->gameId = GetGameId();
boost::shared_ptr<PlayerInterface> myPlayer = GetGame()->getSeatsList()->front(); boost::shared_ptr<PlayerInterface> myPlayer = GetGame()->getSeatsList()->front();
actionData.gameState = static_cast<GameState>(GetGame()->getCurrentHand()->getCurrentRound()); netMyAction->gameState = GetGame()->getCurrentHand()->getCurrentRound();
actionData.playerAction = static_cast<PlayerAction>(myPlayer->getMyAction()); netMyAction->myAction = myPlayer->getMyAction();
// Only send last bet if not fold/checked. // Only send last bet if not fold/checked.
if (actionData.playerAction != PLAYER_ACTION_FOLD && actionData.playerAction != PLAYER_ACTION_CHECK) if (myPlayer->getMyAction() != PLAYER_ACTION_FOLD && myPlayer->getMyAction() != PLAYER_ACTION_CHECK)
actionData.playerBet = myPlayer->getMyLastRelativeSet(); netMyAction->myRelativeBet = myPlayer->getMyLastRelativeSet();
else else
actionData.playerBet = 0; netMyAction->myRelativeBet = 0;
try // Just dump the packet.
{ m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
static_cast<NetPacketPlayersAction *>(action.get())->SetData(actionData);
// Just dump the packet.
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), action));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendPlayerAction: " << e.what());
}
} }
void void
@@ -182,18 +174,16 @@ ClientThread::SendChatMessage(const std::string &msg)
{ {
// Warning: This function is called in the context of the GUI thread. // Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the chat message. // Create a network packet containing the chat message.
boost::shared_ptr<NetPacket> chat(new NetPacketSendChatText); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketSendChatText::Data chatData; packet->GetMsg()->present = PokerTHMessage_PR_chatRequestMessage;
chatData.text = msg; ChatRequestMessage_t *netChat = &packet->GetMsg()->choice.chatRequestMessage;
try netChat->gameId = GetGameId();
{ OCTET_STRING_fromBuf(&netChat->chatText,
static_cast<NetPacketSendChatText *>(chat.get())->SetData(chatData); msg.c_str(),
// Just dump the packet. msg.length());
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), chat));
} catch (const NetException &e) // Just dump the packet.
{ m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
LOG_ERROR("ClientThread::SendChatMessage: " << e.what());
}
} }
void void
@@ -201,18 +191,21 @@ ClientThread::SendJoinFirstGame(const std::string &password)
{ {
// Warning: This function is called in the context of the GUI thread. // Warning: This function is called in the context of the GUI thread.
// Create a network packet to request joining a game. // Create a network packet to request joining a game.
boost::shared_ptr<NetPacket> join(new NetPacketJoinGame); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketJoinGame::Data joinData; packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
joinData.gameId = 1; JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
joinData.password = password; if (!password.empty())
try
{ {
static_cast<NetPacketJoinGame *>(join.get())->SetData(joinData); netJoinGame->password = OCTET_STRING_new_fromBuf(
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), join)); &asn_DEF_UTF8String,
} catch (const NetException &e) password.c_str(),
{ password.length());
LOG_ERROR("ClientThread::SendJoinFirstGame: " << e.what());
} }
netJoinGame->joinGameAction.present = joinGameAction_PR_joinExistingGame;
JoinExistingGame_t *joinExisting = &netJoinGame->joinGameAction.choice.joinExistingGame;
joinExisting->gameId = 1;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
@@ -220,18 +213,21 @@ ClientThread::SendJoinGame(unsigned gameId, const std::string &password)
{ {
// Warning: This function is called in the context of the GUI thread. // Warning: This function is called in the context of the GUI thread.
// Create a network packet to request joining a game. // Create a network packet to request joining a game.
boost::shared_ptr<NetPacket> join(new NetPacketJoinGame); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketJoinGame::Data joinData; packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
joinData.password = password; JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
joinData.gameId = gameId; if (!password.empty())
try
{ {
static_cast<NetPacketJoinGame *>(join.get())->SetData(joinData); netJoinGame->password = OCTET_STRING_new_fromBuf(
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), join)); &asn_DEF_UTF8String,
} catch (const NetException &e) password.c_str(),
{ password.length());
LOG_ERROR("ClientThread::SendJoinGame: " << e.what());
} }
netJoinGame->joinGameAction.present = joinGameAction_PR_joinExistingGame;
JoinExistingGame_t *joinExisting = &netJoinGame->joinGameAction.choice.joinExistingGame;
joinExisting->gameId = gameId;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
@@ -239,50 +235,56 @@ ClientThread::SendCreateGame(const GameData &gameData, const std::string &name,
{ {
// Warning: This function is called in the context of the GUI thread. // Warning: This function is called in the context of the GUI thread.
// Create a network packet to request creating a new game. // Create a network packet to request creating a new game.
boost::shared_ptr<NetPacket> create(new NetPacketCreateGame); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketCreateGame::Data createData; packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
createData.gameData = gameData; JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
createData.gameName = name; if (!password.empty())
createData.password = password;
try
{ {
static_cast<NetPacketCreateGame *>(create.get())->SetData(createData); netJoinGame->password = OCTET_STRING_new_fromBuf(
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), create)); &asn_DEF_UTF8String,
} catch (const NetException &e) password.c_str(),
{ password.length());
LOG_ERROR("ClientThread::SendCreateGame: " << e.what());
} }
netJoinGame->joinGameAction.present = joinGameAction_PR_joinNewGame;
JoinNewGame_t *joinNew = &netJoinGame->joinGameAction.choice.joinNewGame;
NetPacket::SetGameData(gameData, &joinNew->gameInfo);
OCTET_STRING_fromBuf(&joinNew->gameInfo.gameName,
name.c_str(),
name.length());
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
ClientThread::SendResetTimeout() ClientThread::SendResetTimeout()
{ {
boost::shared_ptr<NetPacket> reset(new NetPacketResetTimeout); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), reset)); packet->GetMsg()->present = PokerTHMessage_PR_resetTimeoutMessage;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
ClientThread::SendAskKickPlayer(unsigned playerId) ClientThread::SendAskKickPlayer(unsigned playerId)
{ {
boost::shared_ptr<NetPacket> ask(new NetPacketAskKickPlayer); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketAskKickPlayer::Data askData; packet->GetMsg()->present = PokerTHMessage_PR_askKickPlayerMessage;
askData.playerId = playerId; AskKickPlayerMessage_t *netAsk = &packet->GetMsg()->choice.askKickPlayerMessage;
static_cast<NetPacketAskKickPlayer *>(ask.get())->SetData(askData); netAsk->playerId = playerId;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), ask)); m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
} }
void void
ClientThread::SendVoteKick(bool doKick) ClientThread::SendVoteKick(bool doKick)
{ {
boost::shared_ptr<NetPacket> vote(new NetPacketVoteKickPlayer); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketVoteKickPlayer::Data voteData; packet->GetMsg()->present = PokerTHMessage_PR_voteKickRequestMessage;
VoteKickRequestMessage_t *netVote = &packet->GetMsg()->choice.voteKickRequestMessage;
{ {
boost::mutex::scoped_lock lock(m_curPetitionIdMutex); boost::mutex::scoped_lock lock(m_curPetitionIdMutex);
voteData.petitionId = m_curPetitionId; netVote->petitionId = m_curPetitionId;
} }
voteData.vote = doKick ? KICK_VOTE_IN_FAVOUR : KICK_VOTE_AGAINST; netVote->voteKick = doKick;
static_cast<NetPacketVoteKickPlayer *>(vote.get())->SetData(voteData); m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), vote));
} }
void void
@@ -523,11 +525,11 @@ ClientThread::RequestPlayerInfo(unsigned id, bool requestAvatar)
{ {
if (find(m_playerInfoRequestList.begin(), m_playerInfoRequestList.end(), id) == m_playerInfoRequestList.end()) if (find(m_playerInfoRequestList.begin(), m_playerInfoRequestList.end(), id) == m_playerInfoRequestList.end())
{ {
boost::shared_ptr<NetPacket> req(new NetPacketRetrievePlayerInfo); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketRetrievePlayerInfo::Data reqData; packet->GetMsg()->present = PokerTHMessage_PR_playerInfoRequestMessage;
reqData.playerId = id; PlayerInfoRequestMessage_t *netPlayerInfo = &packet->GetMsg()->choice.playerInfoRequestMessage;
static_cast<NetPacketRetrievePlayerInfo *>(req.get())->SetData(reqData); netPlayerInfo->playerId = id;
GetSender().Send(GetContext().GetSessionData(), req); GetSender().Send(GetContext().GetSessionData(), packet);
m_playerInfoRequestList.push_back(id); m_playerInfoRequestList.push_back(id);
@@ -637,21 +639,23 @@ ClientThread::RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info)
} }
else else
{ {
boost::shared_ptr<NetPacket> retrieveAvatar(new NetPacketRetrieveAvatar); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketRetrieveAvatar::Data retrieveAvatarData; packet->GetMsg()->present = PokerTHMessage_PR_avatarRequestMessage;
retrieveAvatarData.requestId = id; AvatarRequestMessage_t *netAvatar = &packet->GetMsg()->choice.avatarRequestMessage;
retrieveAvatarData.avatar = info.avatar; netAvatar->requestId = id;
static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData); OCTET_STRING_fromBuf(&netAvatar->avatar,
GetSender().Send(GetContext().GetSessionData(), retrieveAvatar); (const char *)info.avatar.data,
MD5_DATA_SIZE);
GetSender().Send(GetContext().GetSessionData(), packet);
} }
} }
} }
} }
void void
ClientThread::AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFileType type) ClientThread::AddTempAvatarFile(unsigned playerId, unsigned avatarSize, AvatarFileType type)
{ {
boost::shared_ptr<AvatarData> tmpAvatar(new AvatarData); boost::shared_ptr<AvatarFile> tmpAvatar(new AvatarFile);
tmpAvatar->fileData.reserve(avatarSize); tmpAvatar->fileData.reserve(avatarSize);
tmpAvatar->fileType = type; tmpAvatar->fileType = type;
tmpAvatar->reportedSize = avatarSize; tmpAvatar->reportedSize = avatarSize;
@@ -660,9 +664,9 @@ ClientThread::AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFi
} }
void void
ClientThread::StoreInTempAvatarData(unsigned playerId, const vector<unsigned char> &data) ClientThread::StoreInTempAvatarFile(unsigned playerId, const vector<unsigned char> &data)
{ {
AvatarDataMap::iterator pos = m_tempAvatarMap.find(playerId); AvatarFileMap::iterator pos = m_tempAvatarMap.find(playerId);
if (pos == m_tempAvatarMap.end()) if (pos == m_tempAvatarMap.end())
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0); throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0);
// We trust the server (concerning size of the data). // We trust the server (concerning size of the data).
@@ -670,33 +674,33 @@ ClientThread::StoreInTempAvatarData(unsigned playerId, const vector<unsigned cha
} }
void void
ClientThread::CompleteTempAvatarData(unsigned playerId) ClientThread::CompleteTempAvatarFile(unsigned playerId)
{ {
AvatarDataMap::iterator pos = m_tempAvatarMap.find(playerId); AvatarFileMap::iterator pos = m_tempAvatarMap.find(playerId);
if (pos == m_tempAvatarMap.end()) if (pos == m_tempAvatarMap.end())
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0); throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0);
boost::shared_ptr<AvatarData> tmpAvatar = pos->second; boost::shared_ptr<AvatarFile> tmpAvatar = pos->second;
unsigned avatarSize = (unsigned)tmpAvatar->fileData.size(); unsigned avatarSize = (unsigned)tmpAvatar->fileData.size();
if (avatarSize != tmpAvatar->reportedSize) if (avatarSize != tmpAvatar->reportedSize)
LOG_ERROR("Client received invalid avatar file size!"); LOG_ERROR("Client received invalid avatar file size!");
else else
PassAvatarDataToManager(playerId, tmpAvatar); PassAvatarFileToManager(playerId, tmpAvatar);
// Free memory. // Free memory.
m_tempAvatarMap.erase(pos); m_tempAvatarMap.erase(pos);
} }
void void
ClientThread::PassAvatarDataToManager(unsigned playerId, boost::shared_ptr<AvatarData> avatarData) ClientThread::PassAvatarFileToManager(unsigned playerId, boost::shared_ptr<AvatarFile> AvatarFile)
{ {
PlayerInfo tmpPlayerInfo; PlayerInfo tmpPlayerInfo;
if (!GetCachedPlayerInfo(playerId, tmpPlayerInfo)) if (!GetCachedPlayerInfo(playerId, tmpPlayerInfo))
LOG_ERROR("Client received invalid player id!"); LOG_ERROR("Client received invalid player id!");
else else
{ {
if (avatarData->fileType == AVATAR_FILE_TYPE_UNKNOWN) if (AvatarFile->fileType == AVATAR_FILE_TYPE_UNKNOWN)
avatarData->fileType = tmpPlayerInfo.avatarType; AvatarFile->fileType = tmpPlayerInfo.avatarType;
if (!GetAvatarManager().StoreAvatarInCache(tmpPlayerInfo.avatar, avatarData->fileType, &avatarData->fileData[0], avatarData->reportedSize, false)) if (!GetAvatarManager().StoreAvatarInCache(tmpPlayerInfo.avatar, AvatarFile->fileType, &AvatarFile->fileData[0], AvatarFile->reportedSize, false))
LOG_ERROR("Failed to store avatar in cache directory."); LOG_ERROR("Failed to store avatar in cache directory.");
// Update player info, but never re-request avatar. // Update player info, but never re-request avatar.
@@ -726,10 +730,10 @@ ClientThread::TimerCheckAvatarDownloads(const boost::system::error_code& ec)
if (m_avatarDownloader && m_avatarDownloader->HasDownloadResult()) if (m_avatarDownloader && m_avatarDownloader->HasDownloadResult())
{ {
unsigned playerId; unsigned playerId;
boost::shared_ptr<AvatarData> tmpAvatar(new AvatarData); boost::shared_ptr<AvatarFile> tmpAvatar(new AvatarFile);
m_avatarDownloader->GetDownloadResult(playerId, tmpAvatar->fileData); m_avatarDownloader->GetDownloadResult(playerId, tmpAvatar->fileData);
tmpAvatar->reportedSize = tmpAvatar->fileData.size(); tmpAvatar->reportedSize = tmpAvatar->fileData.size();
PassAvatarDataToManager(playerId, tmpAvatar); PassAvatarFileToManager(playerId, tmpAvatar);
} }
m_avatarTimer.expires_from_now( m_avatarTimer.expires_from_now(
boost::posix_time::milliseconds(CLIENT_AVATAR_LOOP_MSEC)); boost::posix_time::milliseconds(CLIENT_AVATAR_LOOP_MSEC));
@@ -745,8 +749,11 @@ ClientThread::UnsubscribeLobbyMsg()
if (GetContext().GetSubscribeLobbyMsg()) if (GetContext().GetSubscribeLobbyMsg())
{ {
// Send unsubscribe request. // Send unsubscribe request.
boost::shared_ptr<NetPacket> unsubscr(new NetPacketUnsubscribeGameList); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
GetSender().Send(GetContext().GetSessionData(), unsubscr); packet->GetMsg()->present = PokerTHMessage_PR_subscriptionRequestMessage;
SubscriptionRequestMessage_t *netRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
netRequest->subscriptionAction = subscriptionAction_unsubscribeGameList;
GetSender().Send(GetContext().GetSessionData(), packet);
GetContext().SetSubscribeLobbyMsg(false); GetContext().SetSubscribeLobbyMsg(false);
} }
} }
@@ -759,8 +766,10 @@ ClientThread::ResubscribeLobbyMsg()
// Clear game info map as it is outdated. // Clear game info map as it is outdated.
ClearGameInfoMap(); ClearGameInfoMap();
// Send resubscribe request. // Send resubscribe request.
boost::shared_ptr<NetPacket> resubscr(new NetPacketResubscribeGameList); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
GetSender().Send(GetContext().GetSessionData(), resubscr); packet->GetMsg()->present = PokerTHMessage_PR_subscriptionRequestMessage;
SubscriptionRequestMessage_t *netRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
netRequest->subscriptionAction = subscriptionAction_resubscribeGameList;
GetContext().SetSubscribeLobbyMsg(true); GetContext().SetSubscribeLobbyMsg(true);
} }
} }
src/net/common/netpacket.cpp
+147 -5714
View File
File diff suppressed because it is too large Load Diff
src/net/common/receiverhelper.cpp
+1 -1
View File
@@ -47,7 +47,7 @@ ReceiverHelper::ScanPackets(ReceiveBuffer &buf)
// This is necessary, because we use TCP. // This is necessary, because we use TCP.
// Packets may be received in multiple chunks or // Packets may be received in multiple chunks or
// several packets may be received at once. // several packets may be received at once.
if (buf.recvBufUsed >= MIN_PACKET_SIZE) if (buf.recvBufUsed)
{ {
try try
{ {
src/net/common/senderhelper.cpp
+49 -7
View File
@@ -17,8 +17,9 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>\ #include <boost/enable_shared_from_this.hpp>
#include <net/senderhelper.h> #include <net/senderhelper.h>
#include <net/sendercallback.h> #include <net/sendercallback.h>
@@ -37,8 +38,37 @@ using boost::asio::ip::tcp;
#define SEND_QUEUE_SIZE 10000000 #define SEND_QUEUE_SIZE 10000000
#define SEND_LOG_INTERVAL_SEC 60 #define SEND_LOG_INTERVAL_SEC 60
class EncodedPacket
{
public:
EncodedPacket(const unsigned char *data, unsigned size)
: m_size(size)
{
m_data = new unsigned char[size];
memcpy(m_data, data, size);
}
typedef std::list<boost::shared_ptr<NetPacket> > SendDataList; ~EncodedPacket()
{
delete[] m_data;
}
unsigned GetSize() const
{
return m_size;
}
const unsigned char *GetData() const
{
return m_data;
}
private:
unsigned m_size;
unsigned char *m_data;
};
typedef std::list<boost::shared_ptr<EncodedPacket> > SendDataList;
class SendDataManager : public boost::enable_shared_from_this<SendDataManager> class SendDataManager : public boost::enable_shared_from_this<SendDataManager>
{ {
@@ -87,7 +117,7 @@ SendDataManager::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::soc
SendDataList::iterator end = list.end(); SendDataList::iterator end = list.end();
while (i != end) while (i != end)
{ {
bufSize += (*i)->GetLen(); bufSize += (*i)->GetSize();
++i; ++i;
} }
if (bufSize) if (bufSize)
@@ -97,8 +127,8 @@ SendDataManager::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::soc
end = list.end(); end = list.end();
while (i != end) while (i != end)
{ {
memcpy(sendBuf + bufPos, (*i)->GetRawData(), (*i)->GetLen()); memcpy(sendBuf + bufPos, (*i)->GetData(), (*i)->GetSize());
bufPos += (*i)->GetLen(); bufPos += (*i)->GetSize();
++i; ++i;
} }
list.clear(); list.clear();
@@ -144,7 +174,7 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, boost::shared_ptr<Net
boost::mutex::scoped_lock lock(tmpManager->dataMutex); boost::mutex::scoped_lock lock(tmpManager->dataMutex);
if (tmpManager->list.size() < SEND_QUEUE_SIZE) if (tmpManager->list.size() < SEND_QUEUE_SIZE)
{ {
tmpManager->list.push_back(packet); InternalStorePacket(*tmpManager, packet);
} }
} }
{ {
@@ -178,7 +208,7 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, const NetPacketList &
while (i != end) while (i != end)
{ {
if (*i) if (*i)
tmpManager->list.push_back(*i); InternalStorePacket(*tmpManager, *i);
++i; ++i;
} }
} }
@@ -200,3 +230,15 @@ SenderHelper::SignalSessionTerminated(unsigned sessionId)
m_sendQueueMap.erase(pos); m_sendQueueMap.erase(pos);
} }
void
SenderHelper::InternalStorePacket(SendDataManager &tmpManager, boost::shared_ptr<NetPacket> packet)
{
unsigned char buf[MAX_PACKET_SIZE];
asn_enc_rval_t e;
e = der_encode_to_buffer(&asn_DEF_PokerTHMessage, packet->GetMsg(), buf, MAX_PACKET_SIZE);
if (e.encoded == -1)
LOG_ERROR("Failed to encode NetPacket: " << packet->GetMsg()->present);
else
tmpManager.list.push_back(boost::shared_ptr<EncodedPacket>(new EncodedPacket(buf, e.encoded)));
}
src/net/common/servergame.cpp
+73 -53
View File
@@ -17,6 +17,9 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <net/servergame.h> #include <net/servergame.h>
#include <net/servergamestate.h> #include <net/servergamestate.h>
#include <net/serverlobbythread.h> #include <net/serverlobbythread.h>
@@ -29,8 +32,6 @@
#include <localenginefactory.h> #include <localenginefactory.h>
#include <tools.h> #include <tools.h>
#include <boost/bind.hpp>
#define SERVER_CHECK_VOTE_KICK_INTERVAL_MSEC 500 #define SERVER_CHECK_VOTE_KICK_INTERVAL_MSEC 500
#define SERVER_KICK_TIMEOUT_ADD_DELAY_SEC 2 #define SERVER_KICK_TIMEOUT_ADD_DELAY_SEC 2
@@ -181,16 +182,15 @@ ServerGame::TimerVoteKick(const boost::system::error_code &ec)
} }
if (abortPetition) if (abortPetition)
{ {
boost::shared_ptr<NetPacket> endPetition(new NetPacketEndKickPlayerPetition); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketEndKickPlayerPetition::Data endPetitionData; packet->GetMsg()->present = PokerTHMessage_PR_endKickPetitionMessage;
endPetitionData.petitionId = m_voteKickData->petitionId; EndKickPetitionMessage_t *netEndPetition = &packet->GetMsg()->choice.endKickPetitionMessage;
endPetitionData.numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking; netEndPetition->petitionId = m_voteKickData->petitionId;
endPetitionData.numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking; netEndPetition->numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
endPetitionData.playerKicked = doKick; netEndPetition->numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
endPetitionData.endReason = reason; netEndPetition->resultPlayerKicked = doKick;
netEndPetition->petitionEndReason = reason;
static_cast<NetPacketEndKickPlayerPetition *>(endPetition.get())->SetData(endPetitionData); SendToAllPlayers(packet, SessionData::Game);
SendToAllPlayers(endPetition, SessionData::Game);
// Perform kick. // Perform kick.
if (doKick) if (doKick)
@@ -300,16 +300,15 @@ ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, uns
m_voteKickData->numVotesInFavourOfKicking = 1; m_voteKickData->numVotesInFavourOfKicking = 1;
m_voteKickData->votedPlayerIds.push_back(playerIdByWhom); m_voteKickData->votedPlayerIds.push_back(playerIdByWhom);
boost::shared_ptr<NetPacket> startPetition(new NetPacketStartKickPlayerPetition); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketStartKickPlayerPetition::Data startPetitionData; packet->GetMsg()->present = PokerTHMessage_PR_startKickPetitionMessage;
startPetitionData.petitionId = m_voteKickData->petitionId; StartKickPetitionMessage_t *netStartPetition = &packet->GetMsg()->choice.startKickPetitionMessage;
startPetitionData.proposingPlayerId = playerIdByWhom; netStartPetition->petitionId = m_voteKickData->petitionId;
startPetitionData.kickPlayerId = m_voteKickData->kickPlayerId; netStartPetition->proposingPlayerId = playerIdByWhom;
startPetitionData.kickTimeoutSec = timeoutSec; netStartPetition->kickPlayerId = m_voteKickData->kickPlayerId;
startPetitionData.numVotesNeededToKick = m_voteKickData->numVotesToKick; netStartPetition->kickTimeoutSec = timeoutSec;
netStartPetition->numVotesNeededToKick = m_voteKickData->numVotesToKick;
static_cast<NetPacketStartKickPlayerPetition *>(startPetition.get())->SetData(startPetitionData); SendToAllPlayers(packet, SessionData::Game);
SendToAllPlayers(startPetition, SessionData::Game);
} }
else else
InternalDenyAskVoteKick(byWhom, playerIdWho, KICK_DENIED_OTHER_IN_PROGRESS); InternalDenyAskVoteKick(byWhom, playerIdWho, KICK_DENIED_OTHER_IN_PROGRESS);
@@ -327,12 +326,12 @@ ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, uns
void void
ServerGame::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, DenyKickPlayerReason reason) ServerGame::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, DenyKickPlayerReason reason)
{ {
boost::shared_ptr<NetPacket> denyPetition(new NetPacketAskKickPlayerDenied); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketAskKickPlayerDenied::Data denyPetitionData; packet->GetMsg()->present = PokerTHMessage_PR_askKickDeniedMessage;
denyPetitionData.playerId = playerIdWho; AskKickDeniedMessage_t *netKickDenied = &packet->GetMsg()->choice.askKickDeniedMessage;
denyPetitionData.denyReason = reason; netKickDenied->playerId = playerIdWho;
static_cast<NetPacketAskKickPlayerDenied *>(denyPetition.get())->SetData(denyPetitionData); netKickDenied->kickDeniedReason = reason;
GetLobbyThread().GetSender().Send(byWhom.sessionData, denyPetition); GetLobbyThread().GetSender().Send(byWhom.sessionData, packet);
} }
void void
@@ -353,15 +352,14 @@ ServerGame::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVot
else else
m_voteKickData->numVotesAgainstKicking++; m_voteKickData->numVotesAgainstKicking++;
// Send update notification. // Send update notification.
boost::shared_ptr<NetPacket> updatePetition(new NetPacketKickPlayerPetitionUpdate); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketKickPlayerPetitionUpdate::Data updatePetitionData; packet->GetMsg()->present = PokerTHMessage_PR_kickPetitionUpdateMessage;
updatePetitionData.petitionId = m_voteKickData->petitionId; KickPetitionUpdateMessage_t *netKickUpdate = &packet->GetMsg()->choice.kickPetitionUpdateMessage;
updatePetitionData.numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking; netKickUpdate->petitionId = m_voteKickData->petitionId;
updatePetitionData.numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking; netKickUpdate->numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
updatePetitionData.numVotesNeededToKick = m_voteKickData->numVotesToKick; netKickUpdate->numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
netKickUpdate->numVotesNeededToKick = m_voteKickData->numVotesToKick;
static_cast<NetPacketKickPlayerPetitionUpdate *>(updatePetition.get())->SetData(updatePetitionData); SendToAllPlayers(packet, SessionData::Game);
SendToAllPlayers(updatePetition, SessionData::Game);
} }
else else
InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_ALREADY_VOTED); InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_ALREADY_VOTED);
@@ -370,18 +368,21 @@ ServerGame::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVot
InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_INVALID_PETITION); InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_INVALID_PETITION);
} }
else else
InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_IMPOSSIBLE); InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_INVALID_PETITION);
} }
void void
ServerGame::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionId, DenyVoteReason reason) ServerGame::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionId, DenyVoteReason reason)
{ {
boost::shared_ptr<NetPacket> denyVote(new NetPacketVoteKickPlayerDenied); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketVoteKickPlayerDenied::Data denyVoteData; packet->GetMsg()->present = PokerTHMessage_PR_voteKickReplyMessage;
denyVoteData.petitionId = petitionId; VoteKickReplyMessage_t *netVoteReply = &packet->GetMsg()->choice.voteKickReplyMessage;
denyVoteData.denyReason = reason; netVoteReply->petitionId = petitionId;
static_cast<NetPacketVoteKickPlayerDenied *>(denyVote.get())->SetData(denyVoteData); netVoteReply->voteKickReplyType.present = voteKickReplyType_PR_voteKickDenied;
GetLobbyThread().GetSender().Send(byWhom.sessionData, denyVote);
VoteKickDenied_t *kickDenied = &netVoteReply->voteKickReplyType.choice.voteKickDenied;
kickDenied->voteKickDeniedReason = reason;
GetLobbyThread().GetSender().Send(byWhom.sessionData, packet);
} }
PlayerDataList PlayerDataList
@@ -557,10 +558,14 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
// Notify game state on admin change // Notify game state on admin change
GetState().NotifyGameAdminChanged(shared_from_this()); GetState().NotifyGameAdminChanged(shared_from_this());
// Send "Game Admin Changed" to clients. // Send "Game Admin Changed" to clients.
boost::shared_ptr<NetPacket> adminChanged(new NetPacketGameAdminChanged); boost::shared_ptr<NetPacket> adminChanged(new NetPacket(NetPacket::Alloc));
NetPacketGameAdminChanged::Data adminChangedData; adminChanged->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
adminChangedData.playerId = newAdmin->GetUniqueId(); // Choose next player as admin. GamePlayerMessage_t *netGameAdmin = &adminChanged->GetMsg()->choice.gamePlayerMessage;
static_cast<NetPacketGameAdminChanged *>(adminChanged.get())->SetData(adminChangedData); netGameAdmin->gameId = GetId();
netGameAdmin->gamePlayerNotification.present = gamePlayerNotification_PR_gameAdminChanged;
GameAdminChanged_t *gameAdmin = &netGameAdmin->gamePlayerNotification.choice.gameAdminChanged;
gameAdmin->newAdminPlayerId = newAdmin->GetUniqueId(); // Choose next player as admin.
GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), adminChanged, SessionData::Game); GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), adminChanged, SessionData::Game);
GetLobbyThread().NotifyGameAdminChanged(GetId(), newAdmin->GetUniqueId()); GetLobbyThread().NotifyGameAdminChanged(GetId(), newAdmin->GetUniqueId());
@@ -570,11 +575,26 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
player->SetRights(PLAYER_RIGHTS_NORMAL); player->SetRights(PLAYER_RIGHTS_NORMAL);
// Send "Player Left" to clients. // Send "Player Left" to clients.
boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacketPlayerLeft); boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacket(NetPacket::Alloc));
NetPacketPlayerLeft::Data thisPlayerLeftData; thisPlayerLeft->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
thisPlayerLeftData.playerId = player->GetUniqueId(); GamePlayerMessage_t *netPlayerLeft = &thisPlayerLeft->GetMsg()->choice.gamePlayerMessage;
thisPlayerLeftData.removeReason = reason; netPlayerLeft->gameId = GetId();
static_cast<NetPacketPlayerLeft *>(thisPlayerLeft.get())->SetData(thisPlayerLeftData);
netPlayerLeft->gamePlayerNotification.present = gamePlayerNotification_PR_gamePlayerLeft;
GamePlayerLeft_t *gamePlayer = &netPlayerLeft->gamePlayerNotification.choice.gamePlayerLeft;
gamePlayer->playerId = player->GetUniqueId();
switch (reason)
{
case NTF_NET_REMOVED_ON_REQUEST :
gamePlayer->gamePlayerLeftReason = gamePlayerLeftReason_leftOnRequest;
break;
case NTF_NET_REMOVED_KICKED :
gamePlayer->gamePlayerLeftReason = gamePlayerLeftReason_leftKicked;
break;
default :
gamePlayer->gamePlayerLeftReason = gamePlayerLeftReason_leftError;
break;
}
GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), thisPlayerLeft, SessionData::Game); GetSessionManager().SendToAllSessions(GetLobbyThread().GetSender(), thisPlayerLeft, SessionData::Game);
GetLobbyThread().NotifyPlayerLeftGame(GetId(), player->GetUniqueId()); GetLobbyThread().NotifyPlayerLeftGame(GetId(), player->GetUniqueId());
src/net/common/servergamestate.cpp
+219 -201
View File
@@ -73,55 +73,58 @@ static void SendPlayerAction(ServerGame &server, boost::shared_ptr<PlayerInterfa
{ {
if (!player.get()) if (!player.get())
throw ServerException(__FILE__, __LINE__, ERR_NET_NO_CURRENT_PLAYER, 0); throw ServerException(__FILE__, __LINE__, ERR_NET_NO_CURRENT_PLAYER, 0);
boost::shared_ptr<NetPacket> notifyActionDone(new NetPacketPlayersActionDone);
NetPacketPlayersActionDone::Data actionDoneData; boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
actionDoneData.gameState = server.GetCurRound(); packet->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
actionDoneData.playerId = player->getMyUniqueID(); PlayersActionDoneMessage_t *netActionDone = &packet->GetMsg()->choice.playersActionDoneMessage;
actionDoneData.playerAction = static_cast<PlayerAction>(player->getMyAction());
actionDoneData.totalPlayerBet = player->getMySet(); netActionDone->gameId = server.GetId();
actionDoneData.playerMoney = player->getMyCash(); netActionDone->gameState = server.GetCurRound();
actionDoneData.highestSet = server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet(); netActionDone->highestSet = server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
actionDoneData.minimumRaise = server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise(); netActionDone->minimumRaise = server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
static_cast<NetPacketPlayersActionDone *>(notifyActionDone.get())->SetData(actionDoneData); netActionDone->playerAction = static_cast<PlayerAction>(player->getMyAction());
server.SendToAllPlayers(notifyActionDone, SessionData::Game); netActionDone->playerId = player->getMyUniqueID();
netActionDone->playerMoney = player->getMyCash();
netActionDone->totalPlayerBet = player->getMySet();
server.SendToAllPlayers(packet, SessionData::Game);
} }
static void SendNewRoundCards(ServerGame &server, Game &curGame, int state) static void SendNewRoundCards(ServerGame &server, Game &curGame, int state)
{ {
int cards[5];
curGame.getCurrentHand()->getBoard()->getMyCards(cards);
switch(state) { switch(state) {
case GAME_STATE_PREFLOP: { case GAME_STATE_PREFLOP: {
// nothing to do // nothing to do
} break; } break;
case GAME_STATE_FLOP: { case GAME_STATE_FLOP: {
// deal flop cards // deal flop cards
int cards[5]; boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
curGame.getCurrentHand()->getBoard()->getMyCards(cards); packet->GetMsg()->present = PokerTHMessage_PR_dealFlopCardsMessage;
boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealFlopCards); DealFlopCardsMessage_t *netDealFlop = &packet->GetMsg()->choice.dealFlopCardsMessage;
NetPacketDealFlopCards::Data notifyCardsData; netDealFlop->gameId = server.GetId();
for (int num = 0; num < 3; num++) netDealFlop->flopCard1 = cards[0];
notifyCardsData.flopCards[num] = static_cast<u_int16_t>(cards[num]); netDealFlop->flopCard2 = cards[1];
static_cast<NetPacketDealFlopCards *>(notifyCards.get())->SetData(notifyCardsData); netDealFlop->flopCard3 = cards[2];
server.SendToAllPlayers(notifyCards, SessionData::Game); server.SendToAllPlayers(packet, SessionData::Game);
} break; } break;
case GAME_STATE_TURN: { case GAME_STATE_TURN: {
// deal turn card // deal turn card
int cards[5]; boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
curGame.getCurrentHand()->getBoard()->getMyCards(cards); packet->GetMsg()->present = PokerTHMessage_PR_dealTurnCardMessage;
boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealTurnCard); DealTurnCardMessage_t *netDealTurn = &packet->GetMsg()->choice.dealTurnCardMessage;
NetPacketDealTurnCard::Data notifyCardsData; netDealTurn->gameId = server.GetId();
notifyCardsData.turnCard = static_cast<u_int16_t>(cards[3]); netDealTurn->turnCard = cards[3];
static_cast<NetPacketDealTurnCard *>(notifyCards.get())->SetData(notifyCardsData); server.SendToAllPlayers(packet, SessionData::Game);
server.SendToAllPlayers(notifyCards, SessionData::Game);
} break; } break;
case GAME_STATE_RIVER: { case GAME_STATE_RIVER: {
// deal river card // deal river card
int cards[5]; boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
curGame.getCurrentHand()->getBoard()->getMyCards(cards); packet->GetMsg()->present = PokerTHMessage_PR_dealRiverCardMessage;
boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealRiverCard); DealRiverCardMessage_t *netDealRiver = &packet->GetMsg()->choice.dealRiverCardMessage;
NetPacketDealRiverCard::Data notifyCardsData; netDealRiver->gameId = server.GetId();
notifyCardsData.riverCard = static_cast<u_int16_t>(cards[4]); netDealRiver->riverCard = cards[4];
static_cast<NetPacketDealRiverCard *>(notifyCards.get())->SetData(notifyCardsData); server.SendToAllPlayers(packet, SessionData::Game);
server.SendToAllPlayers(notifyCards, SessionData::Game);
} break; } break;
default: { default: {
// //
@@ -186,81 +189,76 @@ AbstractServerGameStateReceiving::ProcessPacket(boost::shared_ptr<ServerGame> se
{ {
if (packet->IsClientActivity()) if (packet->IsClientActivity())
session.sessionData->ResetActivityTimer(); session.sessionData->ResetActivityTimer();
if (packet->ToNetPacketRetrievePlayerInfo()) if (packet->GetMsg()->present == PokerTHMessage_PR_playerInfoRequestMessage)
{ {
// Delegate to Lobby. // Delegate to Lobby.
server->GetLobbyThread().HandleGameRetrievePlayerInfo(session, *packet->ToNetPacketRetrievePlayerInfo()); server->GetLobbyThread().HandleGameRetrievePlayerInfo(session, packet->GetMsg()->choice.playerInfoRequestMessage);
} }
else if (packet->ToNetPacketRetrieveAvatar()) else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarRequestMessage)
{ {
// Delegate to Lobby. // Delegate to Lobby.
server->GetLobbyThread().HandleGameRetrieveAvatar(session, *packet->ToNetPacketRetrieveAvatar()); server->GetLobbyThread().HandleGameRetrieveAvatar(session, packet->GetMsg()->choice.avatarRequestMessage);
} }
else if (packet->ToNetPacketLeaveCurrentGame()) else if (packet->GetMsg()->present == PokerTHMessage_PR_leaveGameRequestMessage)
{ {
server->MoveSessionToLobby(session, NTF_NET_REMOVED_ON_REQUEST); server->MoveSessionToLobby(session, NTF_NET_REMOVED_ON_REQUEST);
} }
else if (packet->ToNetPacketKickPlayer()) else if (packet->GetMsg()->present == PokerTHMessage_PR_kickPlayerRequestMessage)
{ {
// Only admins are allowed to kick, and only in the lobby. // Only admins are allowed to kick, and only in the lobby.
// After leaving the lobby, a vote needs to be initiated to kick. // After leaving the lobby, a vote needs to be initiated to kick.
if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN && !server->IsRunning()) KickPlayerRequestMessage_t *netKickRequest = &packet->GetMsg()->choice.kickPlayerRequestMessage;
if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN && !server->IsRunning() && netKickRequest->gameId == server->GetId())
{ {
NetPacketKickPlayer::Data kickPlayerData; server->InternalKickPlayer(netKickRequest->playerId);
packet->ToNetPacketKickPlayer()->GetData(kickPlayerData);
server->InternalKickPlayer(kickPlayerData.playerId);
} }
} }
else if (packet->ToNetPacketAskKickPlayer()) else if (packet->GetMsg()->present == PokerTHMessage_PR_askKickPlayerMessage)
{ {
if (session.playerData) if (session.playerData)
{ {
NetPacketAskKickPlayer::Data askKickData; AskKickPlayerMessage_t *netAskKick = &packet->GetMsg()->choice.askKickPlayerMessage;
packet->ToNetPacketAskKickPlayer()->GetData(askKickData); server->InternalAskVoteKick(session, netAskKick->playerId, SERVER_VOTE_KICK_TIMEOUT_SEC);
server->InternalAskVoteKick(session, askKickData.playerId, SERVER_VOTE_KICK_TIMEOUT_SEC);
} }
} }
else if (packet->ToNetPacketVoteKickPlayer()) else if (packet->GetMsg()->present == PokerTHMessage_PR_voteKickRequestMessage)
{ {
if (session.playerData) if (session.playerData)
{ {
NetPacketVoteKickPlayer::Data voteData; VoteKickRequestMessage_t *netVoteKick = &packet->GetMsg()->choice.voteKickRequestMessage;
packet->ToNetPacketVoteKickPlayer()->GetData(voteData); server->InternalVoteKick(session, netVoteKick->petitionId, netVoteKick->voteKick ? KICK_VOTE_AGAINST : KICK_VOTE_IN_FAVOUR);
server->InternalVoteKick(session, voteData.petitionId, voteData.vote);
} }
} }
// Chat text is always allowed. // Chat text is always allowed.
else if (packet->ToNetPacketSendChatText()) else if (packet->GetMsg()->present == PokerTHMessage_PR_chatRequestMessage)
{ {
if (session.playerData) // Only forward if this player is known. if (session.playerData) // Only forward if this player is known.
{ {
// Forward chat text to all players. // Forward chat text to all players.
// TODO: Some limitation needed. // TODO: Some limitation needed.
NetPacketSendChatText::Data inChatData; ChatRequestMessage_t *netChatRequest = &packet->GetMsg()->choice.chatRequestMessage;
packet->ToNetPacketSendChatText()->GetData(inChatData); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_chatMessage;
boost::shared_ptr<NetPacket> outChat(new NetPacketChatText); ChatMessage_t *netChat = &packet->GetMsg()->choice.chatMessage;
NetPacketChatText::Data outChatData; netChat->gameId = server->GetId();
outChatData.playerId = session.playerData->GetUniqueId(); netChat->playerId = session.playerData->GetUniqueId();
outChatData.text = inChatData.text; OCTET_STRING_fromBuf(
static_cast<NetPacketChatText *>(outChat.get())->SetData(outChatData); &netChat->chatText,
server->SendToAllPlayers(outChat, SessionData::Game); (char *)netChatRequest->chatText.buf,
netChatRequest->chatText.size);
server->SendToAllPlayers(packet, SessionData::Game);
} }
} }
else if (packet->ToNetPacketUnsubscribeGameList()) else if (packet->GetMsg()->present == PokerTHMessage_PR_subscriptionRequestMessage)
{ {
// We can do this directly in this thread. SubscriptionRequestMessage_t *netSubscription = &packet->GetMsg()->choice.subscriptionRequestMessage;
session.sessionData->ResetWantsLobbyMsg(); if (netSubscription->subscriptionAction == subscriptionAction_resubscribeGameList)
} {
else if (packet->ToNetPacketResubscribeGameList()) if (!session.sessionData->WantsLobbyMsg())
{ server->GetLobbyThread().ResubscribeLobbyMsg(session);
// This needs to be performed in the lobby thread, }
// because a new game list needs to be sent. else
if (!session.sessionData->WantsLobbyMsg()) session.sessionData->ResetWantsLobbyMsg();
server->GetLobbyThread().ResubscribeLobbyMsg(session);
} }
else else
{ {
@@ -332,13 +330,19 @@ ServerGameStateInit::HandleNewSession(boost::shared_ptr<ServerGame> server, Sess
} }
// Send ack to client. // Send ack to client.
boost::shared_ptr<NetPacket> joinGameAck(new NetPacketJoinGameAck); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketJoinGameAck::Data joinGameAckData; packet->GetMsg()->present = PokerTHMessage_PR_joinGameReplyMessage;
joinGameAckData.gameId = server->GetId(); JoinGameReplyMessage_t *netJoinReply = &packet->GetMsg()->choice.joinGameReplyMessage;
joinGameAckData.prights = session.playerData->GetRights(); netJoinReply->gameId = server->GetId();
joinGameAckData.gameData = server->GetGameData(); netJoinReply->joinGameResult.present = joinGameResult_PR_joinGameAck;
static_cast<NetPacketJoinGameAck *>(joinGameAck.get())->SetData(joinGameAckData); JoinGameAck_t *joinAck = &netJoinReply->joinGameResult.choice.joinGameAck;
server->GetLobbyThread().GetSender().Send(session.sessionData, joinGameAck); joinAck->areYouAdmin = session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN;
NetPacket::SetGameData(server->GetGameData(), &joinAck->gameInfo);
OCTET_STRING_fromBuf(
&joinAck->gameInfo.gameName,
session.playerData->GetName().c_str(),
session.playerData->GetName().length());
server->GetLobbyThread().GetSender().Send(session.sessionData, packet);
// Send notifications for connected players to client. // Send notifications for connected players to client.
PlayerDataList tmpPlayerList = server->GetFullPlayerDataList(); PlayerDataList tmpPlayerList = server->GetFullPlayerDataList();
@@ -346,12 +350,12 @@ ServerGameStateInit::HandleNewSession(boost::shared_ptr<ServerGame> server, Sess
PlayerDataList::iterator player_end = tmpPlayerList.end(); PlayerDataList::iterator player_end = tmpPlayerList.end();
while (player_i != player_end) while (player_i != player_end)
{ {
server->GetLobbyThread().GetSender().Send(session.sessionData, CreateNetPacketPlayerJoined(*(*player_i))); server->GetLobbyThread().GetSender().Send(session.sessionData, CreateNetPacketPlayerJoined(server->GetId(), *(*player_i)));
++player_i; ++player_i;
} }
// Send "Player Joined" to other fully connected clients. // Send "Player Joined" to other fully connected clients.
server->SendToAllPlayers(CreateNetPacketPlayerJoined(*session.playerData), SessionData::Game); server->SendToAllPlayers(CreateNetPacketPlayerJoined(server->GetId(), *session.playerData), SessionData::Game);
// Accept session. // Accept session.
server->GetSessionManager().AddSession(session); server->GetSessionManager().AddSession(session);
@@ -388,12 +392,12 @@ ServerGameStateInit::TimerAdminWarning(const boost::system::error_code &ec, boos
if (session.sessionData.get()) if (session.sessionData.get())
{ {
// Send him a warning. // Send him a warning.
boost::shared_ptr<NetPacket> warning(new NetPacketTimeoutWarning); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketTimeoutWarning::Data warningData; packet->GetMsg()->present = PokerTHMessage_PR_timeoutWarningMessage;
warningData.timeoutReason = NETWORK_TIMEOUT_GAME_ADMIN_IDLE; TimeoutWarningMessage_t *netWarning = &packet->GetMsg()->choice.timeoutWarningMessage;
warningData.remainingSeconds = SERVER_GAME_ADMIN_WARNING_REMAINING_SEC; netWarning->timeoutReason = NETWORK_TIMEOUT_GAME_ADMIN_IDLE;
static_cast<NetPacketTimeoutWarning *>(warning.get())->SetData(warningData); netWarning->remainingSeconds = SERVER_GAME_ADMIN_WARNING_REMAINING_SEC;
server->GetLobbyThread().GetSender().Send(session.sessionData, warning); server->GetLobbyThread().GetSender().Send(session.sessionData, packet);
} }
// Start timeout timer. // Start timeout timer.
server->GetStateTimer().expires_from_now( server->GetStateTimer().expires_from_now(
@@ -422,18 +426,16 @@ ServerGameStateInit::TimerAdminTimeout(const boost::system::error_code &ec, boos
void void
ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
{ {
if (packet->ToNetPacketStartEvent()) if (packet->GetMsg()->present == PokerTHMessage_PR_startEventMessage)
{ {
StartEventMessage_t *netStartEvent = &packet->GetMsg()->choice.startEventMessage;
// Only admins are allowed to start the game. // Only admins are allowed to start the game.
if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN) if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN && netStartEvent->gameId == server->GetId())
{ {
NetPacketStartEvent::Data startData;
packet->ToNetPacketStartEvent()->GetData(startData);
// Fill up with computer players. // Fill up with computer players.
server->ResetComputerPlayerList(); server->ResetComputerPlayerList();
if (startData.fillUpWithCpuPlayers) if (netStartEvent->fillWithComputerPlayers)
{ {
int remainingSlots = server->GetGameData().maxNumberOfPlayers - server->GetCurNumberOfPlayers(); int remainingSlots = server->GetGameData().maxNumberOfPlayers - server->GetCurNumberOfPlayers();
for (int i = 1; i <= remainingSlots; i++) for (int i = 1; i <= remainingSlots; i++)
@@ -447,19 +449,19 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
server->AddComputerPlayer(tmpPlayerData); server->AddComputerPlayer(tmpPlayerData);
// Send "Player Joined" to other fully connected clients. // Send "Player Joined" to other fully connected clients.
server->SendToAllPlayers(CreateNetPacketPlayerJoined(*tmpPlayerData), SessionData::Game); server->SendToAllPlayers(CreateNetPacketPlayerJoined(server->GetId(), *tmpPlayerData), SessionData::Game);
// Notify lobby. // Notify lobby.
server->GetLobbyThread().NotifyPlayerJoinedGame(server->GetId(), tmpPlayerData->GetUniqueId()); server->GetLobbyThread().NotifyPlayerJoinedGame(server->GetId(), tmpPlayerData->GetUniqueId());
} }
} }
// Wait for all players to confirm start of game. // Wait for all players to confirm start of game.
server->SendToAllPlayers(boost::shared_ptr<NetPacket>(packet->Clone()), SessionData::Game); server->SendToAllPlayers(packet, SessionData::Game);
server->SetState(ServerGameStateStartGame::Instance()); server->SetState(ServerGameStateStartGame::Instance());
} }
} }
else if (packet->ToNetPacketResetTimeout()) else if (packet->GetMsg()->present == PokerTHMessage_PR_resetTimeoutMessage)
{ {
if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN) if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN)
{ {
@@ -473,14 +475,17 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
} }
boost::shared_ptr<NetPacket> boost::shared_ptr<NetPacket>
ServerGameStateInit::CreateNetPacketPlayerJoined(const PlayerData &playerData) ServerGameStateInit::CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData)
{ {
boost::shared_ptr<NetPacket> thisPlayerJoined(new NetPacketPlayerJoined); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketPlayerJoined::Data thisPlayerJoinedData; packet->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
thisPlayerJoinedData.playerId = playerData.GetUniqueId(); GamePlayerMessage_t *netGamePlayer = &packet->GetMsg()->choice.gamePlayerMessage;
thisPlayerJoinedData.prights = playerData.GetRights(); netGamePlayer->gameId = gameId;
static_cast<NetPacketPlayerJoined *>(thisPlayerJoined.get())->SetData(thisPlayerJoinedData); netGamePlayer->gamePlayerNotification.present = gamePlayerNotification_PR_gamePlayerJoined;
return thisPlayerJoined; GamePlayerJoined_t *playerJoined = &netGamePlayer->gamePlayerNotification.choice.gamePlayerJoined;
playerJoined->playerId = playerData.GetUniqueId();
playerJoined->isAdmin = playerData.GetRights() == PLAYER_RIGHTS_ADMIN;
return packet;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -527,7 +532,7 @@ ServerGameStateStartGame::HandleNewSession(boost::shared_ptr<ServerGame> server,
void void
ServerGameStateStartGame::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) ServerGameStateStartGame::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
{ {
if (packet->ToNetPacketStartEventAck()) if (packet->GetMsg()->present == PokerTHMessage_PR_startEventAckMessage)
{ {
session.sessionData->SetReadyFlag(); session.sessionData->SetReadyFlag();
if (server->GetSessionManager().CountReadySessions() == server->GetSessionManager().GetRawSessionCount()) if (server->GetSessionManager().CountReadySessions() == server->GetSessionManager().GetRawSessionCount())
@@ -570,10 +575,11 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
{ {
server->InternalStartGame(); server->InternalStartGame();
boost::shared_ptr<NetPacket> answer(new NetPacketGameStart); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameStartMessage;
NetPacketGameStart::Data gameStartData; GameStartMessage_t *netGameStart = &packet->GetMsg()->choice.gameStartMessage;
gameStartData.startData = server->GetStartData(); netGameStart->gameId = server->GetId();
netGameStart->startDealerPlayerId = server->GetStartData().startDealerPlayerId;
// Send player order to clients. // Send player order to clients.
// Assume player list is sorted by number. // Assume player list is sorted by number.
@@ -581,15 +587,14 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
PlayerDataList::iterator player_end = tmpPlayerList.end(); PlayerDataList::iterator player_end = tmpPlayerList.end();
while (player_i != player_end) while (player_i != player_end)
{ {
NetPacketGameStart::PlayerSlot tmpPlayerSlot; NonZeroId_t *playerSlot = (NonZeroId_t *)calloc(1, sizeof(NonZeroId_t));
tmpPlayerSlot.playerId = (*player_i)->GetUniqueId(); *playerSlot = (*player_i)->GetUniqueId();
gameStartData.playerSlots.push_back(tmpPlayerSlot); ASN_SEQUENCE_ADD(&netGameStart->playerSeats.list, playerSlot);
++player_i; ++player_i;
} }
static_cast<NetPacketGameStart *>(answer.get())->SetData(gameStartData); server->SendToAllPlayers(packet, SessionData::Game);
server->SendToAllPlayers(answer, SessionData::Game);
// Start the first hand. // Start the first hand.
ServerGameStateHand::StartNewHand(server); ServerGameStateHand::StartNewHand(server);
@@ -688,26 +693,26 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
&& nonFoldPlayers.size() > 1) && nonFoldPlayers.size() > 1)
{ {
// Send cards of all active players to all players (all in). // Send cards of all active players to all players (all in).
boost::shared_ptr<NetPacket> allIn(new NetPacketAllInShowCards); boost::shared_ptr<NetPacket> allIn(new NetPacket(NetPacket::Alloc));
NetPacketAllInShowCards::Data allInData; allIn->GetMsg()->present = PokerTHMessage_PR_allInShowCardsMessage;
AllInShowCardsMessage_t *netAllInShow = &allIn->GetMsg()->choice.allInShowCardsMessage;
netAllInShow->gameId = server->GetId();
PlayerListConstIterator i = nonFoldPlayers.begin(); PlayerListConstIterator i = nonFoldPlayers.begin();
PlayerListConstIterator end = nonFoldPlayers.end(); PlayerListConstIterator end = nonFoldPlayers.end();
while (i != end) while (i != end)
{ {
NetPacketAllInShowCards::PlayerCards tmpPlayerCards; PlayerAllIn_t *playerAllIn = (PlayerAllIn_t *)calloc(1, sizeof(PlayerAllIn_t));
tmpPlayerCards.playerId = (*i)->getMyUniqueID(); playerAllIn->playerId = (*i)->getMyUniqueID();
int tmpCards[2]; int tmpCards[2];
(*i)->getMyCards(tmpCards); (*i)->getMyCards(tmpCards);
tmpPlayerCards.cards[0] = static_cast<u_int16_t>(tmpCards[0]); playerAllIn->allInCard1 = tmpCards[0];
tmpPlayerCards.cards[1] = static_cast<u_int16_t>(tmpCards[1]); playerAllIn->allInCard2 = tmpCards[1];
ASN_SEQUENCE_ADD(&netAllInShow->playersAllIn.list, playerAllIn);
allInData.playerCards.push_back(tmpPlayerCards);
++i; ++i;
} }
static_cast<NetPacketAllInShowCards *>(allIn.get())->SetData(allInData);
server->SendToAllPlayers(allIn, SessionData::Game); server->SendToAllPlayers(allIn, SessionData::Game);
curGame.getCurrentHand()->setCardsShown(true); curGame.getCurrentHand()->setCardsShown(true);
@@ -742,12 +747,12 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
if (!curPlayer->getMyActiveStatus()) if (!curPlayer->getMyActiveStatus())
throw ServerException(__FILE__, __LINE__, ERR_NET_PLAYER_NOT_ACTIVE, 0); throw ServerException(__FILE__, __LINE__, ERR_NET_PLAYER_NOT_ACTIVE, 0);
boost::shared_ptr<NetPacket> notification(new NetPacketPlayersTurn); boost::shared_ptr<NetPacket> notification(new NetPacket(NetPacket::Alloc));
NetPacketPlayersTurn::Data playersTurnData; notification->GetMsg()->present = PokerTHMessage_PR_playersTurnMessage;
playersTurnData.gameState = (GameState)curGame.getCurrentHand()->getCurrentRound(); PlayersTurnMessage_t *netPlayersTurn = &notification->GetMsg()->choice.playersTurnMessage;
playersTurnData.playerId = curPlayer->getMyUniqueID(); netPlayersTurn->gameId = server->GetId();
static_cast<NetPacketPlayersTurn *>(notification.get())->SetData(playersTurnData); netPlayersTurn->gameState = curGame.getCurrentHand()->getCurrentRound();
netPlayersTurn->playerId = curPlayer->getMyUniqueID();
server->SendToAllPlayers(notification, SessionData::Game); server->SendToAllPlayers(notification, SessionData::Game);
// If the player is computer controlled, let the engine act. // If the player is computer controlled, let the engine act.
@@ -788,48 +793,57 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
{ {
// End of Hand, but keep cards hidden. // End of Hand, but keep cards hidden.
boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front(); boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
boost::shared_ptr<NetPacket> endHand(new NetPacketEndOfHandHideCards); boost::shared_ptr<NetPacket> endHand(new NetPacket(NetPacket::Alloc));
NetPacketEndOfHandHideCards::Data endHandData; endHand->GetMsg()->present = PokerTHMessage_PR_endOfHandMessage;
endHandData.playerId = player->getMyUniqueID(); EndOfHandMessage_t *netEndHand = &endHand->GetMsg()->choice.endOfHandMessage;
endHandData.moneyWon = player->getLastMoneyWon(); netEndHand->gameId = server->GetId();
endHandData.playerMoney = player->getMyCash();
static_cast<NetPacketEndOfHandHideCards *>(endHand.get())->SetData(endHandData);
netEndHand->endOfHandType.present = endOfHandType_PR_endOfHandHideCards;
EndOfHandHideCards_t *endHandHide = &netEndHand->endOfHandType.choice.endOfHandHideCards;
endHandHide->playerId = player->getMyUniqueID();
endHandHide->moneyWon = player->getLastMoneyWon();
endHandHide->playerMoney = player->getMyCash();
server->SendToAllPlayers(endHand, SessionData::Game); server->SendToAllPlayers(endHand, SessionData::Game);
} }
else else
{ {
// End of Hand - show cards of active players. // End of Hand - show cards of active players.
boost::shared_ptr<NetPacket> endHand(new NetPacketEndOfHandShowCards); boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
NetPacketEndOfHandShowCards::Data endHandData; boost::shared_ptr<NetPacket> endHand(new NetPacket(NetPacket::Alloc));
endHand->GetMsg()->present = PokerTHMessage_PR_endOfHandMessage;
EndOfHandMessage_t *netEndHand = &endHand->GetMsg()->choice.endOfHandMessage;
netEndHand->gameId = server->GetId();
netEndHand->endOfHandType.present = endOfHandType_PR_endOfHandShowCards;
EndOfHandShowCards_t *endHandShow = &netEndHand->endOfHandType.choice.endOfHandShowCards;
PlayerListConstIterator i = nonFoldPlayers.begin(); PlayerListConstIterator i = nonFoldPlayers.begin();
PlayerListConstIterator end = nonFoldPlayers.end(); PlayerListConstIterator end = nonFoldPlayers.end();
while (i != end) while (i != end)
{ {
NetPacketEndOfHandShowCards::PlayerResult tmpPlayerResult; PlayerResult_t *playerResult = (PlayerResult_t *)calloc(1, sizeof(PlayerResult_t));
tmpPlayerResult.playerId = (*i)->getMyUniqueID(); playerResult->playerId = (*i)->getMyUniqueID();
int tmpCards[2]; int tmpCards[2];
int bestHandPos[5]; int bestHandPos[5];
(*i)->getMyCards(tmpCards); (*i)->getMyCards(tmpCards);
tmpPlayerResult.cards[0] = static_cast<u_int16_t>(tmpCards[0]); playerResult->resultCard1 = tmpCards[0];
tmpPlayerResult.cards[1] = static_cast<u_int16_t>(tmpCards[1]); playerResult->resultCard2 = tmpCards[1];
(*i)->getMyBestHandPosition(bestHandPos); (*i)->getMyBestHandPosition(bestHandPos);
for (int num = 0; num < 5; num++) for (int num = 0; num < 5; num++)
tmpPlayerResult.bestHandPos[num] = bestHandPos[num]; {
long *handPos = (long *)calloc(1, sizeof(long));
*handPos = bestHandPos[num];
ASN_SEQUENCE_ADD(&playerResult->bestHandPosition.list, handPos);
}
tmpPlayerResult.valueOfCards = (*i)->getMyCardsValueInt(); playerResult->cardsValue = (*i)->getMyCardsValueInt();
tmpPlayerResult.moneyWon = (*i)->getLastMoneyWon(); playerResult->moneyWon = (*i)->getLastMoneyWon();
tmpPlayerResult.playerMoney = (*i)->getMyCash(); playerResult->playerMoney = (*i)->getMyCash();
endHandData.playerResults.push_back(tmpPlayerResult); ASN_SEQUENCE_ADD(&endHandShow->playerResults.list, playerResult);
++i; ++i;
} }
static_cast<NetPacketEndOfHandShowCards *>(endHand.get())->SetData(endHandData);
server->SendToAllPlayers(endHand, SessionData::Game); server->SendToAllPlayers(endHand, SessionData::Game);
} }
@@ -934,11 +948,11 @@ ServerGameStateHand::TimerNextGame(const boost::system::error_code &ec, boost::s
if (winnerPlayer) if (winnerPlayer)
{ {
boost::shared_ptr<NetPacket> endGame(new NetPacketEndOfGame); boost::shared_ptr<NetPacket> endGame(new NetPacket(NetPacket::Alloc));
NetPacketEndOfGame::Data endGameData; endGame->GetMsg()->present = PokerTHMessage_PR_endOfGameMessage;
endGameData.winnerPlayerId = winnerPlayer->getMyUniqueID(); EndOfGameMessage_t *netEndGame = &endGame->GetMsg()->choice.endOfGameMessage;
static_cast<NetPacketEndOfGame *>(endGame.get())->SetData(endGameData); netEndGame->gameId = server->GetId();
netEndGame->winnerPlayerId = winnerPlayer->getMyUniqueID();
server->SendToAllPlayers(endGame, SessionData::Game); server->SendToAllPlayers(endGame, SessionData::Game);
// Wait for the start of a new game. // Wait for the start of a new game.
@@ -1002,13 +1016,14 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
{ {
int cards[2]; int cards[2];
tmpPlayer->getMyCards(cards); tmpPlayer->getMyCards(cards);
boost::shared_ptr<NetPacket> notifyCards(new NetPacketHandStart);
NetPacketHandStart::Data handStartData;
handStartData.yourCards[0] = static_cast<unsigned>(cards[0]);
handStartData.yourCards[1] = static_cast<unsigned>(cards[1]);
handStartData.smallBlind = curGame.getCurrentHand()->getSmallBlind();
static_cast<NetPacketHandStart *>(notifyCards.get())->SetData(handStartData);
boost::shared_ptr<NetPacket> notifyCards(new NetPacket(NetPacket::Alloc));
notifyCards->GetMsg()->present = PokerTHMessage_PR_handStartMessage;
HandStartMessage_t *netHandStart = &notifyCards->GetMsg()->choice.handStartMessage;
netHandStart->gameId = server->GetId();
netHandStart->yourCard1 = cards[0];
netHandStart->yourCard2 = cards[1];
netHandStart->smallBlind = curGame.getCurrentHand()->getSmallBlind();
server->GetLobbyThread().GetSender().Send(tmpPlayer->getNetSessionData(), notifyCards); server->GetLobbyThread().GetSender().Send(tmpPlayer->getNetSessionData(), notifyCards);
} }
++i; ++i;
@@ -1026,16 +1041,17 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
boost::shared_ptr<PlayerInterface> tmpPlayer = *i; boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
if (tmpPlayer->getMyButton() == BUTTON_SMALL_BLIND) if (tmpPlayer->getMyButton() == BUTTON_SMALL_BLIND)
{ {
boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacketPlayersActionDone); boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacket(NetPacket::Alloc));
NetPacketPlayersActionDone::Data actionDoneData; notifySmallBlind->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
actionDoneData.gameState = GAME_STATE_PREFLOP_SMALL_BLIND; PlayersActionDoneMessage_t *netSmallBlind = &notifySmallBlind->GetMsg()->choice.playersActionDoneMessage;
actionDoneData.playerId = tmpPlayer->getMyUniqueID(); netSmallBlind->gameId = server->GetId();
actionDoneData.playerAction = (PlayerAction)tmpPlayer->getMyAction(); netSmallBlind->gameState = NetGameState_statePreflopSmallBlind;
actionDoneData.totalPlayerBet = tmpPlayer->getMySet(); netSmallBlind->playerId = tmpPlayer->getMyUniqueID();
actionDoneData.playerMoney = tmpPlayer->getMyCash(); netSmallBlind->playerAction = tmpPlayer->getMyAction();
actionDoneData.highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet(); netSmallBlind->totalPlayerBet = tmpPlayer->getMySet();
actionDoneData.minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise(); netSmallBlind->playerMoney = tmpPlayer->getMyCash();
static_cast<NetPacketPlayersActionDone *>(notifySmallBlind.get())->SetData(actionDoneData); netSmallBlind->highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
netSmallBlind->minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
server->SendToAllPlayers(notifySmallBlind, SessionData::Game); server->SendToAllPlayers(notifySmallBlind, SessionData::Game);
break; break;
} }
@@ -1049,16 +1065,17 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
boost::shared_ptr<PlayerInterface> tmpPlayer = *i; boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
if (tmpPlayer->getMyButton() == BUTTON_BIG_BLIND) if (tmpPlayer->getMyButton() == BUTTON_BIG_BLIND)
{ {
boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacketPlayersActionDone); boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacket(NetPacket::Alloc));
NetPacketPlayersActionDone::Data actionDoneData; notifyBigBlind->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
actionDoneData.gameState = GAME_STATE_PREFLOP_BIG_BLIND; PlayersActionDoneMessage_t *netBigBlind = &notifyBigBlind->GetMsg()->choice.playersActionDoneMessage;
actionDoneData.playerId = tmpPlayer->getMyUniqueID(); netBigBlind->gameId = server->GetId();
actionDoneData.playerAction = (PlayerAction)tmpPlayer->getMyAction(); netBigBlind->gameState = NetGameState_statePreflopBigBlind;
actionDoneData.totalPlayerBet = tmpPlayer->getMySet(); netBigBlind->playerId = tmpPlayer->getMyUniqueID();
actionDoneData.playerMoney = tmpPlayer->getMyCash(); netBigBlind->playerAction = tmpPlayer->getMyAction();
actionDoneData.highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet(); netBigBlind->totalPlayerBet = tmpPlayer->getMySet();
actionDoneData.minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise(); netBigBlind->playerMoney = tmpPlayer->getMyCash();
static_cast<NetPacketPlayersActionDone *>(notifyBigBlind.get())->SetData(actionDoneData); netBigBlind->highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
netBigBlind->minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
server->SendToAllPlayers(notifyBigBlind, SessionData::Game); server->SendToAllPlayers(notifyBigBlind, SessionData::Game);
break; break;
} }
@@ -1116,11 +1133,11 @@ ServerGameStateWaitPlayerAction::HandleNewSession(boost::shared_ptr<ServerGame>
void void
ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet) ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
{ {
if (packet->ToNetPacketPlayersAction()) if (packet->GetMsg()->present == PokerTHMessage_PR_myActionRequestMessage)
{ {
NetPacketPlayersAction::Data actionData; MyActionRequestMessage_t *netMyAction = &packet->GetMsg()->choice.myActionRequestMessage;
packet->ToNetPacketPlayersAction()->GetData(actionData);
// TODO consider game id.
Game &curGame = server->GetGame(); Game &curGame = server->GetGame();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame.getPlayerByUniqueId(session.playerData->GetUniqueId()); boost::shared_ptr<PlayerInterface> tmpPlayer = curGame.getPlayerByUniqueId(session.playerData->GetUniqueId());
if (!tmpPlayer.get()) if (!tmpPlayer.get())
@@ -1128,7 +1145,7 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
// Check whether this is the correct round. // Check whether this is the correct round.
PlayerActionCode code = ACTION_CODE_VALID; PlayerActionCode code = ACTION_CODE_VALID;
if (curGame.getCurrentHand()->getCurrentRound() != actionData.gameState) if (curGame.getCurrentHand()->getCurrentRound() != netMyAction->gameState)
code = ACTION_CODE_INVALID_STATE; code = ACTION_CODE_INVALID_STATE;
// Check whether this is the correct player. // Check whether this is the correct player.
@@ -1140,21 +1157,21 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
} }
// If the client omitted some values, fill them in. // If the client omitted some values, fill them in.
if (actionData.playerAction == PLAYER_ACTION_CALL && actionData.playerBet == 0) if (netMyAction->myAction == PLAYER_ACTION_CALL && netMyAction->myRelativeBet == 0)
{ {
if (curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() >= tmpPlayer->getMySet() + tmpPlayer->getMyCash()) if (curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() >= tmpPlayer->getMySet() + tmpPlayer->getMyCash())
actionData.playerAction = PLAYER_ACTION_ALLIN; netMyAction->myAction = PLAYER_ACTION_ALLIN;
else else
actionData.playerBet = curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() - tmpPlayer->getMySet(); netMyAction->myRelativeBet = curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet() - tmpPlayer->getMySet();
} }
if (actionData.playerAction == PLAYER_ACTION_ALLIN && actionData.playerBet == 0) if (netMyAction->myAction == PLAYER_ACTION_ALLIN && netMyAction->myRelativeBet == 0)
actionData.playerBet = tmpPlayer->getMyCash(); netMyAction->myRelativeBet = tmpPlayer->getMyCash();
// Check whether the action is valid. // Check whether the action is valid.
if (code == ACTION_CODE_VALID if (code == ACTION_CODE_VALID
&& (tmpPlayer->checkMyAction( && (tmpPlayer->checkMyAction(
actionData.playerAction, netMyAction->myAction,
actionData.playerBet, netMyAction->myRelativeBet,
curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet(), curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet(),
curGame.getCurrentHand()->getCurrentBeRo()->getMinimumRaise(), curGame.getCurrentHand()->getCurrentBeRo()->getMinimumRaise(),
curGame.getCurrentHand()->getSmallBlind()) != 0)) curGame.getCurrentHand()->getSmallBlind()) != 0))
@@ -1164,19 +1181,20 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
if (code == ACTION_CODE_VALID) if (code == ACTION_CODE_VALID)
{ {
PerformPlayerAction(*server, tmpPlayer, actionData.playerAction, actionData.playerBet); PerformPlayerAction(*server, tmpPlayer, static_cast<PlayerAction>(netMyAction->myAction), netMyAction->myRelativeBet);
server->SetState(ServerGameStateHand::Instance()); server->SetState(ServerGameStateHand::Instance());
} }
else else
{ {
// Send reject message. // Send reject message.
boost::shared_ptr<NetPacket> reject(new NetPacketPlayersActionRejected); boost::shared_ptr<NetPacket> reject(new NetPacket(NetPacket::Alloc));
NetPacketPlayersActionRejected::Data rejectData; reject->GetMsg()->present = PokerTHMessage_PR_yourActionRejectedMessage;
rejectData.gameState = actionData.gameState; YourActionRejectedMessage_t *netActionRejected = &reject->GetMsg()->choice.yourActionRejectedMessage;
rejectData.playerAction = actionData.playerAction; netActionRejected->gameId = server->GetId();
rejectData.playerBet = actionData.playerBet; netActionRejected->gameState = netMyAction->gameState;
rejectData.rejectionReason = code; netActionRejected->yourAction = netMyAction->myAction;
static_cast<NetPacketPlayersActionRejected *>(reject.get())->SetData(rejectData); netActionRejected->yourRelativeBet = netMyAction->myRelativeBet;
netActionRejected->rejectionReason = code;
server->GetLobbyThread().GetSender().Send(session.sessionData, reject); server->GetLobbyThread().GetSender().Send(session.sessionData, reject);
} }
} }
src/net/common/serverlobbythread.cpp
+322 -209
View File
@@ -192,10 +192,33 @@ ServerLobbyThread::ReAddSession(SessionWrapper session, int reason)
{ {
if (session.sessionData.get() && session.playerData.get()) if (session.sessionData.get() && session.playerData.get())
{ {
boost::shared_ptr<NetPacket> packet(new NetPacketRemovedFromGame); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketRemovedFromGame::Data removedData; packet->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
removedData.removeReason = reason; GamePlayerMessage_t *netPlayerMsg = &packet->GetMsg()->choice.gamePlayerMessage;
static_cast<NetPacketRemovedFromGame *>(packet.get())->SetData(removedData); netPlayerMsg->gamePlayerNotification.present = gamePlayerNotification_PR_removedFromGame;
RemovedFromGame_t *removed = &netPlayerMsg->gamePlayerNotification.choice.removedFromGame;
switch (reason)
{
case NTF_NET_REMOVED_GAME_FULL :
removed->removedFromGameReason = removedFromGameReason_gameIsFull;
break;
case NTF_NET_REMOVED_ALREADY_RUNNING :
removed->removedFromGameReason = removedFromGameReason_gameIsRunning;
break;
case NTF_NET_REMOVED_KICKED :
removed->removedFromGameReason = removedFromGameReason_kickedFromGame;
break;
case NTF_NET_REMOVED_TIMEOUT :
removed->removedFromGameReason = removedFromGameReason_gameTimeout;
break;
case NTF_NET_REMOVED_START_FAILED :
removed->removedFromGameReason = removedFromGameReason_removedStartFailed;
break;
default :
removed->removedFromGameReason = removedFromGameReason_removedOnRequest;
break;
}
GetSender().Send(session.sessionData, packet); GetSender().Send(session.sessionData, packet);
HandleReAddedSession(session); HandleReAddedSession(session);
@@ -251,11 +274,15 @@ void
ServerLobbyThread::NotifyPlayerJoinedGame(unsigned gameId, unsigned playerId) ServerLobbyThread::NotifyPlayerJoinedGame(unsigned gameId, unsigned playerId)
{ {
// Send notification to players in lobby. // Send notification to players in lobby.
boost::shared_ptr<NetPacket> packet(new NetPacketGameListPlayerJoined); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketGameListPlayerJoined::Data packetData; packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
packetData.gameId = gameId; GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
packetData.playerId = playerId; netListMsg->gameId = gameId;
static_cast<NetPacketGameListPlayerJoined *>(packet.get())->SetData(packetData);
netListMsg->gameListNotification.present = gameListNotification_PR_gameListPlayerJoined;
GameListPlayerJoined_t *playerJoined = &netListMsg->gameListNotification.choice.gameListPlayerJoined;
playerJoined->playerId = playerId;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established); m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game); m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
} }
@@ -264,11 +291,15 @@ void
ServerLobbyThread::NotifyPlayerLeftGame(unsigned gameId, unsigned playerId) ServerLobbyThread::NotifyPlayerLeftGame(unsigned gameId, unsigned playerId)
{ {
// Send notification to players in lobby. // Send notification to players in lobby.
boost::shared_ptr<NetPacket> packet(new NetPacketGameListPlayerLeft); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketGameListPlayerLeft::Data packetData; packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
packetData.gameId = gameId; GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
packetData.playerId = playerId; netListMsg->gameId = gameId;
static_cast<NetPacketGameListPlayerLeft *>(packet.get())->SetData(packetData);
netListMsg->gameListNotification.present = gameListNotification_PR_gameListPlayerLeft;
GameListPlayerLeft_t *playerLeft = &netListMsg->gameListNotification.choice.gameListPlayerLeft;
playerLeft->playerId = playerId;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established); m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game); m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
} }
@@ -277,11 +308,15 @@ void
ServerLobbyThread::NotifyGameAdminChanged(unsigned gameId, unsigned newAdminPlayerId) ServerLobbyThread::NotifyGameAdminChanged(unsigned gameId, unsigned newAdminPlayerId)
{ {
// Send notification to players in lobby. // Send notification to players in lobby.
boost::shared_ptr<NetPacket> packet(new NetPacketGameListAdminChanged); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketGameListAdminChanged::Data packetData; packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
packetData.gameId = gameId; GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
packetData.newAdminplayerId = newAdminPlayerId; netListMsg->gameId = gameId;
static_cast<NetPacketGameListAdminChanged *>(packet.get())->SetData(packetData);
netListMsg->gameListNotification.present = gameListNotification_PR_gameListAdminChanged;
GameListAdminChanged_t *adminChanged = &netListMsg->gameListNotification.choice.gameListAdminChanged;
adminChanged->newAdminPlayerId = newAdminPlayerId;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established); m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game); m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
} }
@@ -303,17 +338,17 @@ ServerLobbyThread::NotifyReopeningGame(unsigned gameId)
} }
void void
ServerLobbyThread::HandleGameRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket) ServerLobbyThread::HandleGameRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest)
{ {
// Someone within a game requested player info. // Someone within a game requested player info.
HandleNetPacketRetrievePlayerInfo(session, tmpPacket); HandleNetPacketRetrievePlayerInfo(session, playerInfoRequest);
} }
void void
ServerLobbyThread::HandleGameRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket) ServerLobbyThread::HandleGameRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar)
{ {
// Someone within a game requested an avatar. // Someone within a game requested an avatar.
HandleNetPacketRetrieveAvatar(session, tmpPacket); HandleNetPacketRetrieveAvatar(session, retrieveAvatar);
} }
bool bool
@@ -357,22 +392,32 @@ ServerLobbyThread::RemovePlayer(unsigned playerId, unsigned errorCode)
void void
ServerLobbyThread::SendGlobalChat(const string &message) ServerLobbyThread::SendGlobalChat(const string &message)
{ {
boost::shared_ptr<NetPacket> outChat(new NetPacketChatText); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketChatText::Data outChatData; packet->GetMsg()->present = PokerTHMessage_PR_chatMessage;
outChatData.playerId = 0; ChatMessage_t *netChat = &packet->GetMsg()->choice.chatMessage;
outChatData.text = message; // TODO proper game id handling.
static_cast<NetPacketChatText *>(outChat.get())->SetData(outChatData); netChat->gameId = 0;
m_gameSessionManager.SendToAllSessions(GetSender(), outChat, SessionData::Game); netChat->playerId = 0;
OCTET_STRING_fromBuf(
&netChat->chatText,
message.c_str(),
message.length());
m_gameSessionManager.SendToAllSessions(GetSender(), packet, SessionData::Game);
} }
void void
ServerLobbyThread::SendGlobalMsgBox(const string &message) ServerLobbyThread::SendGlobalMsgBox(const string &message)
{ {
boost::shared_ptr<NetPacket> outMsg(new NetPacketMsgBoxText); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketMsgBoxText::Data outMsgData; packet->GetMsg()->present = PokerTHMessage_PR_dialogMessage;
outMsgData.text = message; DialogMessage_t *netDialog = &packet->GetMsg()->choice.dialogMessage;
static_cast<NetPacketMsgBoxText *>(outMsg.get())->SetData(outMsgData);
m_gameSessionManager.SendToAllSessions(GetSender(), outMsg, SessionData::Game); OCTET_STRING_fromBuf(
&netDialog->notificationText,
message.c_str(),
message.length());
m_gameSessionManager.SendToAllSessions(GetSender(), packet, SessionData::Game);
} }
void void
@@ -626,40 +671,63 @@ ServerLobbyThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPac
if (session.sessionData->GetState() == SessionData::Init) if (session.sessionData->GetState() == SessionData::Init)
{ {
if (packet->ToNetPacketInit()) if (packet->GetMsg()->present == PokerTHMessage_PR_initMessage)
HandleNetPacketInit(session, *packet->ToNetPacketInit()); HandleNetPacketInit(session, packet->GetMsg()->choice.initMessage);
else if (packet->ToNetPacketAvatarHeader()) else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
HandleNetPacketAvatarHeader(session, *packet->ToNetPacketAvatarHeader()); {
else if (packet->ToNetPacketUnknownAvatar()) AvatarReplyMessage_t *avatarReply = &packet->GetMsg()->choice.avatarReplyMessage;
HandleNetPacketUnknownAvatar(session, *packet->ToNetPacketUnknownAvatar()); if (avatarReply->avatarResult.present == avatarResult_PR_avatarHeader)
HandleNetPacketAvatarHeader(session, avatarReply->requestId, avatarReply->avatarResult.choice.avatarHeader);
else if (avatarReply->avatarResult.present == avatarResult_PR_unknownAvatar)
HandleNetPacketUnknownAvatar(session, avatarReply->requestId, avatarReply->avatarResult.choice.unknownAvatar);
else
SessionError(session, ERR_SOCK_INVALID_STATE);
}
else else
SessionError(session, ERR_SOCK_INVALID_STATE); SessionError(session, ERR_SOCK_INVALID_STATE);
} }
else if (session.sessionData->GetState() == SessionData::ReceivingAvatar) else if (session.sessionData->GetState() == SessionData::ReceivingAvatar)
{ {
if (packet->ToNetPacketAvatarFile()) if (packet->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
HandleNetPacketAvatarFile(session, *packet->ToNetPacketAvatarFile()); {
else if (packet->ToNetPacketAvatarEnd()) AvatarReplyMessage_t *avatarReply = &packet->GetMsg()->choice.avatarReplyMessage;
HandleNetPacketAvatarEnd(session, *packet->ToNetPacketAvatarEnd()); if (avatarReply->avatarResult.present == avatarResult_PR_avatarData)
HandleNetPacketAvatarFile(session, avatarReply->requestId, avatarReply->avatarResult.choice.avatarData);
else if (avatarReply->avatarResult.present == avatarResult_PR_avatarEnd)
HandleNetPacketAvatarEnd(session, avatarReply->requestId, avatarReply->avatarResult.choice.avatarEnd);
else
SessionError(session, ERR_SOCK_INVALID_STATE);
}
else else
SessionError(session, ERR_SOCK_INVALID_STATE); SessionError(session, ERR_SOCK_INVALID_STATE);
} }
else else
{ {
if (packet->ToNetPacketRetrievePlayerInfo()) if (packet->GetMsg()->present == PokerTHMessage_PR_playerInfoRequestMessage)
HandleNetPacketRetrievePlayerInfo(session, *packet->ToNetPacketRetrievePlayerInfo()); HandleNetPacketRetrievePlayerInfo(session, packet->GetMsg()->choice.playerInfoRequestMessage);
else if (packet->ToNetPacketRetrieveAvatar()) else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarRequestMessage)
HandleNetPacketRetrieveAvatar(session, *packet->ToNetPacketRetrieveAvatar()); HandleNetPacketRetrieveAvatar(session, packet->GetMsg()->choice.avatarRequestMessage);
else if (packet->ToNetPacketResetTimeout()) else if (packet->GetMsg()->present == PokerTHMessage_PR_resetTimeoutMessage)
{} {}
else if (packet->ToNetPacketUnsubscribeGameList()) else if (packet->GetMsg()->present == PokerTHMessage_PR_subscriptionRequestMessage)
session.sessionData->ResetWantsLobbyMsg(); {
else if (packet->ToNetPacketResubscribeGameList()) SubscriptionRequestMessage_t *subscriptionRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
InternalResubscribeMsg(session); if (subscriptionRequest->subscriptionAction == subscriptionAction_resubscribeGameList)
else if (packet->ToNetPacketCreateGame()) InternalResubscribeMsg(session);
HandleNetPacketCreateGame(session, *packet->ToNetPacketCreateGame()); else
else if (packet->ToNetPacketJoinGame()) session.sessionData->ResetWantsLobbyMsg();
HandleNetPacketJoinGame(session, *packet->ToNetPacketJoinGame()); }
else if (packet->GetMsg()->present == PokerTHMessage_PR_joinGameRequestMessage)
{
JoinGameRequestMessage_t *joinRequest = &packet->GetMsg()->choice.joinGameRequestMessage;
string password;
if (joinRequest->password)
password = string((char *)joinRequest->password->buf, joinRequest->password->size);
if (joinRequest->joinGameAction.present == joinGameAction_PR_joinNewGame)
HandleNetPacketCreateGame(session, password, joinRequest->joinGameAction.choice.joinNewGame);
else if (joinRequest->joinGameAction.present == joinGameAction_PR_joinExistingGame)
HandleNetPacketJoinGame(session, password, joinRequest->joinGameAction.choice.joinExistingGame);
}
else else
SessionError(session, ERR_SOCK_INVALID_STATE); SessionError(session, ERR_SOCK_INVALID_STATE);
} }
@@ -667,52 +735,61 @@ ServerLobbyThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPac
} }
void void
ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketInit &tmpPacket) ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const InitMessage_t &initMessage)
{ {
LOG_VERBOSE("Received init for session #" << session.sessionData->GetId() << "."); LOG_VERBOSE("Received init for session #" << session.sessionData->GetId() << ".");
NetPacketInit::Data initData;
tmpPacket.GetData(initData);
// Check the protocol version. // Check the protocol version.
if (initData.versionMajor != NET_VERSION_MAJOR) if (initMessage.requestedVersion.major != NET_VERSION_MAJOR)
{ {
SessionError(session, ERR_NET_VERSION_NOT_SUPPORTED); SessionError(session, ERR_NET_VERSION_NOT_SUPPORTED);
return; return;
} }
if (initData.versionMajor == 5 && (initData.versionMinor == 0 || initData.versionMinor == 1)) if (initMessage.requestedVersion.major == 5 && (initMessage.requestedVersion.minor == 0 || initMessage.requestedVersion.minor == 1))
session.sessionData->SetMaxNumPlayers(7); session.sessionData->SetMaxNumPlayers(7);
else else
session.sessionData->SetMaxNumPlayers(MAX_NUMBER_OF_PLAYERS); session.sessionData->SetMaxNumPlayers(MAX_NUMBER_OF_PLAYERS);
string playerName;
MD5Buf avatarMD5;
if (initMessage.login.present == login_PR_anonymousLogin)
{
const AnonymousLogin_t *anonLogin = &initMessage.login.choice.anonymousLogin;
playerName = string((const char *)anonLogin->playerName.buf, anonLogin->playerName.size);
if (anonLogin->avatar)
memcpy(avatarMD5.data, anonLogin->avatar->buf, MD5_DATA_SIZE);
}
else
SessionError(session, ERR_NET_INVALID_PASSWORD); // TODO not yet supported
// Check the server password. // Check the server password.
if (!CheckPassword(initData.password)) /* if (!CheckPassword(initData.password))
{ {
SessionError(session, ERR_NET_INVALID_PASSWORD); SessionError(session, ERR_NET_INVALID_PASSWORD);
return; return;
} }*/
// Check whether the player name is correct. // Check whether the player name is correct.
// Partly, this is also done in netpacket. // Partly, this is also done in netpacket.
// However, some disallowed names are checked only here. // However, some disallowed names are checked only here.
if (initData.playerName.empty() || initData.playerName.size() > MAX_NAME_SIZE if (playerName.empty()
|| initData.playerName[0] == '#' || playerName[0] == '#'
|| initData.playerName[0] == ' ' || playerName[0] == ' '
|| initData.playerName.substr(0, sizeof(SERVER_COMPUTER_PLAYER_NAME) - 1) == SERVER_COMPUTER_PLAYER_NAME) || playerName.substr(0, sizeof(SERVER_COMPUTER_PLAYER_NAME) - 1) == SERVER_COMPUTER_PLAYER_NAME)
{ {
SessionError(session, ERR_NET_INVALID_PLAYER_NAME); SessionError(session, ERR_NET_INVALID_PLAYER_NAME);
return; return;
} }
// Check whether this player is already connected. // Check whether this player is already connected.
if (IsPlayerConnected(initData.playerName)) if (IsPlayerConnected(playerName))
{ {
SessionError(session, ERR_NET_PLAYER_NAME_IN_USE); SessionError(session, ERR_NET_PLAYER_NAME_IN_USE);
return; return;
} }
// Check whether the player name is banned. // Check whether the player name is banned.
if (GetBanManager().IsPlayerBanned(initData.playerName)) if (GetBanManager().IsPlayerBanned(playerName))
{ {
SessionError(session, ERR_NET_PLAYER_BANNED); SessionError(session, ERR_NET_PLAYER_BANNED);
return; return;
@@ -727,19 +804,17 @@ ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketIn
// Create player data object. // Create player data object.
boost::shared_ptr<PlayerData> tmpPlayerData( boost::shared_ptr<PlayerData> tmpPlayerData(
new PlayerData(GetNextUniquePlayerId(), 0, PLAYER_TYPE_HUMAN, PLAYER_RIGHTS_NORMAL)); new PlayerData(GetNextUniquePlayerId(), 0, PLAYER_TYPE_HUMAN, PLAYER_RIGHTS_NORMAL));
tmpPlayerData->SetName(initData.playerName); tmpPlayerData->SetName(playerName);
tmpPlayerData->SetNetSessionData(session.sessionData); tmpPlayerData->SetNetSessionData(session.sessionData);
if (initData.showAvatar) tmpPlayerData->SetAvatarMD5(avatarMD5);
tmpPlayerData->SetAvatarMD5(initData.avatar);
// Set player data for session. // Set player data for session.
m_sessionManager.SetSessionPlayerData(session.sessionData->GetId(), tmpPlayerData); m_sessionManager.SetSessionPlayerData(session.sessionData->GetId(), tmpPlayerData);
session.playerData = tmpPlayerData; session.playerData = tmpPlayerData;
string avatarFileName; string avatarFileName;
if (initData.showAvatar if (!avatarMD5.IsZero()
&& !initData.avatar.IsZero() && !GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName))
&& !GetAvatarManager().GetAvatarFileName(initData.avatar, avatarFileName))
{ {
bool avatarRecentlyRequested = false; bool avatarRecentlyRequested = false;
{ {
@@ -761,22 +836,19 @@ ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketIn
} }
void void
ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, const NetPacketAvatarHeader &tmpPacket) ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, unsigned /*requestId*/, const AvatarHeader_t &avatarHeader)
{ {
if (session.playerData.get()) if (session.playerData.get())
{ {
NetPacketAvatarHeader::Data headerData; if (avatarHeader.avatarSize >= MIN_AVATAR_FILE_SIZE && avatarHeader.avatarSize <= MAX_AVATAR_FILE_SIZE)
tmpPacket.GetData(headerData);
if (headerData.avatarFileSize >= MIN_AVATAR_FILE_SIZE && headerData.avatarFileSize <= MAX_AVATAR_FILE_SIZE)
{ {
boost::shared_ptr<AvatarData> tmpAvatarData(new AvatarData); boost::shared_ptr<AvatarFile> tmpAvatarFile(new AvatarFile);
tmpAvatarData->fileData.reserve(headerData.avatarFileSize); tmpAvatarFile->fileData.reserve(avatarHeader.avatarSize);
tmpAvatarData->fileType = headerData.avatarFileType; tmpAvatarFile->fileType = static_cast<AvatarFileType>(avatarHeader.avatarType);
tmpAvatarData->reportedSize = headerData.avatarFileSize; tmpAvatarFile->reportedSize = avatarHeader.avatarSize;
// Ignore request id for now. // Ignore request id for now.
session.playerData->SetNetAvatarData(tmpAvatarData); session.playerData->SetNetAvatarFile(tmpAvatarFile);
// Session is now receiving an avatar. // Session is now receiving an avatar.
session.sessionData->SetState(SessionData::ReceivingAvatar); session.sessionData->SetState(SessionData::ReceivingAvatar);
@@ -787,12 +859,12 @@ ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, const Net
} }
void void
ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, const NetPacketUnknownAvatar &/*tmpPacket*/) ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, unsigned /*requestId*/, const UnknownAvatar_t &/*unknownAvatar*/)
{ {
if (session.playerData.get()) if (session.playerData.get())
{ {
// Free memory (just in case). // Free memory (just in case).
session.playerData->SetNetAvatarData(boost::shared_ptr<AvatarData>()); session.playerData->SetNetAvatarFile(boost::shared_ptr<AvatarFile>());
session.playerData->SetAvatarMD5(MD5Buf()); session.playerData->SetAvatarMD5(MD5Buf());
// Start session. // Start session.
EstablishSession(session); EstablishSession(session);
@@ -800,27 +872,24 @@ ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, const Ne
} }
void void
ServerLobbyThread::HandleNetPacketAvatarFile(SessionWrapper session, const NetPacketAvatarFile &tmpPacket) ServerLobbyThread::HandleNetPacketAvatarFile(SessionWrapper session, unsigned /*requestId*/, const AvatarData_t &avatarData)
{ {
if (session.playerData.get()) if (session.playerData.get())
{ {
NetPacketAvatarFile::Data data; boost::shared_ptr<AvatarFile> tmpAvatar = session.playerData->GetNetAvatarFile();
tmpPacket.GetData(data); if (tmpAvatar.get() && tmpAvatar->fileData.size() + avatarData.avatarBlock.size <= tmpAvatar->reportedSize)
boost::shared_ptr<AvatarData> tmpAvatar = session.playerData->GetNetAvatarData();
if (tmpAvatar.get() && tmpAvatar->fileData.size() + data.fileData.size() <= tmpAvatar->reportedSize)
{ {
std::copy(data.fileData.begin(), data.fileData.end(), back_inserter(tmpAvatar->fileData)); std::copy(&avatarData.avatarBlock.buf[0], &avatarData.avatarBlock.buf[avatarData.avatarBlock.size], back_inserter(tmpAvatar->fileData));
} }
} }
} }
void void
ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPacketAvatarEnd &/*tmpPacket*/) ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, unsigned /*requestId*/, const AvatarEnd_t &/*avatarEnd*/)
{ {
if (session.playerData.get()) if (session.playerData.get())
{ {
boost::shared_ptr<AvatarData> tmpAvatar = session.playerData->GetNetAvatarData(); boost::shared_ptr<AvatarFile> tmpAvatar = session.playerData->GetNetAvatarFile();
MD5Buf avatarMD5 = session.playerData->GetAvatarMD5(); MD5Buf avatarMD5 = session.playerData->GetAvatarMD5();
if (!avatarMD5.IsZero() && tmpAvatar.get()) if (!avatarMD5.IsZero() && tmpAvatar.get())
{ {
@@ -834,7 +903,7 @@ ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPac
} }
// Free memory. // Free memory.
session.playerData->SetNetAvatarData(boost::shared_ptr<AvatarData>()); session.playerData->SetNetAvatarFile(boost::shared_ptr<AvatarFile>());
// Set avatar file name. // Set avatar file name.
string avatarFileName; string avatarFileName;
if (GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName)) if (GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName))
@@ -851,63 +920,66 @@ ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPac
} }
void void
ServerLobbyThread::HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket) ServerLobbyThread::HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest)
{ {
NetPacketRetrievePlayerInfo::Data request;
tmpPacket.GetData(request);
// Find player in lobby or in a game. // Find player in lobby or in a game.
boost::shared_ptr<PlayerData> tmpPlayer = m_sessionManager.GetSessionByUniquePlayerId(request.playerId).playerData; boost::shared_ptr<PlayerData> tmpPlayer = m_sessionManager.GetSessionByUniquePlayerId(playerInfoRequest.playerId).playerData;
if (!tmpPlayer.get()) if (!tmpPlayer.get())
tmpPlayer = m_gameSessionManager.GetSessionByUniquePlayerId(request.playerId).playerData; tmpPlayer = m_gameSessionManager.GetSessionByUniquePlayerId(playerInfoRequest.playerId).playerData;
if (!tmpPlayer.get()) if (!tmpPlayer.get())
{ {
boost::mutex::scoped_lock lock(m_computerPlayersMutex); boost::mutex::scoped_lock lock(m_computerPlayersMutex);
PlayerDataMap::const_iterator pos = m_computerPlayers.find(request.playerId); PlayerDataMap::const_iterator pos = m_computerPlayers.find(playerInfoRequest.playerId);
if (pos != m_computerPlayers.end()) if (pos != m_computerPlayers.end())
tmpPlayer = pos->second; tmpPlayer = pos->second;
} }
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_playerInfoReplyMessage;
PlayerInfoReplyMessage_t *netPlayerInfoReply = &packet->GetMsg()->choice.playerInfoReplyMessage;
netPlayerInfoReply->playerId = tmpPlayer->GetUniqueId();
if (tmpPlayer.get()) if (tmpPlayer.get())
{ {
// Send player info to client. // Send player info to client.
boost::shared_ptr<NetPacket> info(new NetPacketPlayerInfo); netPlayerInfoReply->playerInfoResult.present = playerInfoResult_PR_playerInfoData;
NetPacketPlayerInfo::Data infoData; PlayerInfoData *data = &netPlayerInfoReply->playerInfoResult.choice.playerInfoData;
infoData.playerId = tmpPlayer->GetUniqueId();
infoData.playerInfo.ptype = tmpPlayer->GetType(); data->isHuman = tmpPlayer->GetType() == PLAYER_TYPE_HUMAN;
infoData.playerInfo.playerName = tmpPlayer->GetName(); OCTET_STRING_fromBuf(
infoData.playerInfo.hasAvatar = !tmpPlayer->GetAvatarMD5().IsZero(); &data->playerName,
if (infoData.playerInfo.hasAvatar) tmpPlayer->GetName().c_str(),
tmpPlayer->GetName().length());
if (!tmpPlayer->GetAvatarMD5().IsZero())
{ {
infoData.playerInfo.avatar = tmpPlayer->GetAvatarMD5(); data->avatarData = (struct PlayerInfoData::avatarData *)calloc(1, sizeof(struct PlayerInfoData::avatarData));
infoData.playerInfo.avatarType = AvatarManager::GetAvatarFileType(tmpPlayer->GetAvatarFile()); data->avatarData->avatarType = static_cast<NetAvatarType_t>(AvatarManager::GetAvatarFileType(tmpPlayer->GetAvatarFile()));
OCTET_STRING_fromBuf(
&data->avatarData->avatar,
(char *)tmpPlayer->GetAvatarMD5().data,
MD5_DATA_SIZE);
} }
static_cast<NetPacketPlayerInfo *>(info.get())->SetData(infoData);
GetSender().Send(session.sessionData, info);
} }
else else
{ {
// Unknown player id - notify client. // Unknown player id - notify client.
boost::shared_ptr<NetPacket> unknown(new NetPacketUnknownPlayerId); netPlayerInfoReply->playerInfoResult.present = playerInfoResult_PR_unknownPlayerInfo;
NetPacketUnknownPlayerId::Data unknownData;
unknownData.playerId = request.playerId;
static_cast<NetPacketUnknownPlayerId *>(unknown.get())->SetData(unknownData);
GetSender().Send(session.sessionData, unknown);
} }
GetSender().Send(session.sessionData, packet);
} }
void void
ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket) ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar)
{ {
bool avatarFound = false; bool avatarFound = false;
NetPacketRetrieveAvatar::Data request;
tmpPacket.GetData(request);
string tmpFile; string tmpFile;
if (GetAvatarManager().GetAvatarFileName(request.avatar, tmpFile)) MD5Buf tmpMD5;
memcpy(tmpMD5.data, retrieveAvatar.avatar.buf, MD5_DATA_SIZE);
if (GetAvatarManager().GetAvatarFileName(tmpMD5, tmpFile))
{ {
NetPacketList tmpPackets; NetPacketList tmpPackets;
if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, request.requestId, tmpPackets) == 0) if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, retrieveAvatar.requestId, tmpPackets) == 0)
{ {
avatarFound = true; avatarFound = true;
GetSender().Send(session.sessionData, tmpPackets); GetSender().Send(session.sessionData, tmpPackets);
@@ -919,30 +991,31 @@ ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const N
if (!avatarFound) if (!avatarFound)
{ {
// Notify client we didn't find the avatar. // Notify client we didn't find the avatar.
boost::shared_ptr<NetPacket> unknown(new NetPacketUnknownAvatar); boost::shared_ptr<NetPacket> unknownAvatar(new NetPacket(NetPacket::Alloc));
NetPacketUnknownAvatar::Data unknownData; unknownAvatar->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
unknownData.requestId = request.requestId; AvatarReplyMessage_t *netAvatarReply = &unknownAvatar->GetMsg()->choice.avatarReplyMessage;
static_cast<NetPacketUnknownAvatar *>(unknown.get())->SetData(unknownData); netAvatarReply->requestId = retrieveAvatar.requestId;
GetSender().Send(session.sessionData, unknown); netAvatarReply->avatarResult.present = avatarResult_PR_unknownAvatar;
GetSender().Send(session.sessionData, unknownAvatar);
} }
} }
void void
ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const NetPacketCreateGame &tmpPacket) ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const std::string &password, const JoinNewGame_t &newGame)
{ {
LOG_VERBOSE("Creating new game, initiated by session #" << session.sessionData->GetId() << "."); LOG_VERBOSE("Creating new game, initiated by session #" << session.sessionData->GetId() << ".");
// Create a new game. // Create a new game.
NetPacketCreateGame::Data createGameData; GameData tmpData;
tmpPacket.GetData(createGameData); NetPacket::GetGameData(&newGame.gameInfo, tmpData);
boost::shared_ptr<ServerGame> game( boost::shared_ptr<ServerGame> game(
new ServerGame( new ServerGame(
shared_from_this(), shared_from_this(),
GetNextGameId(), GetNextGameId(),
createGameData.gameName, string((char *)newGame.gameInfo.gameName.buf, newGame.gameInfo.gameName.size),
createGameData.password, password,
createGameData.gameData, tmpData,
session.playerData->GetUniqueId(), session.playerData->GetUniqueId(),
GetGui(), GetGui(),
m_playerConfig)); m_playerConfig));
@@ -954,18 +1027,15 @@ ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const NetPa
} }
void void
ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPacketJoinGame &tmpPacket) ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const std::string &password, const JoinExistingGame_t &joinGame)
{ {
// Join an existing game. // Join an existing game.
NetPacketJoinGame::Data joinGameData; GameMap::iterator pos = m_gameMap.find(joinGame.gameId);
tmpPacket.GetData(joinGameData);
GameMap::iterator pos = m_gameMap.find(joinGameData.gameId);
if (pos != m_gameMap.end()) if (pos != m_gameMap.end())
{ {
ServerGame &game = *pos->second; ServerGame &game = *pos->second;
if (game.CheckPassword(joinGameData.password)) if (game.CheckPassword(password))
{ {
MoveSessionToGame(game, session); MoveSessionToGame(game, session);
} }
@@ -976,6 +1046,7 @@ ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPack
} }
else else
{ {
// TODO do not remove session
SessionError(session, ERR_NET_UNKNOWN_GAME); SessionError(session, ERR_NET_UNKNOWN_GAME);
} }
} }
@@ -986,14 +1057,15 @@ ServerLobbyThread::EstablishSession(SessionWrapper session)
if (!session.playerData.get()) if (!session.playerData.get())
throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0); throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0);
// Send ACK to client. // Send ACK to client.
boost::shared_ptr<NetPacket> initAck(new NetPacketInitAck); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketInitAck::Data initAckData; packet->GetMsg()->present = PokerTHMessage_PR_initAckMessage;
initAckData.latestGameVersion = POKERTH_VERSION; InitAckMessage_t *netInitAck = &packet->GetMsg()->choice.initAckMessage;
initAckData.latestBetaRevision = POKERTH_BETA_REVISION; netInitAck->latestGameVersion.major = POKERTH_VERSION_MAJOR;
initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused. netInitAck->latestGameVersion.minor = POKERTH_VERSION_MINOR;
initAckData.playerId = session.playerData->GetUniqueId(); netInitAck->latestBetaRevision = POKERTH_BETA_REVISION;
static_cast<NetPacketInitAck *>(initAck.get())->SetData(initAckData); // initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
GetSender().Send(session.sessionData, initAck); netInitAck->yourPlayerId = session.playerData->GetUniqueId();
GetSender().Send(session.sessionData, packet);
// Send the game list to the client. // Send the game list to the client.
SendGameList(session.sessionData); SendGameList(session.sessionData);
@@ -1020,12 +1092,15 @@ ServerLobbyThread::RequestPlayerAvatar(SessionWrapper session)
m_timerAvatarClientAddressMap[session.sessionData->GetClientAddr()] = boost::timers::portable::microsec_timer(); m_timerAvatarClientAddressMap[session.sessionData->GetClientAddr()] = boost::timers::portable::microsec_timer();
} }
// Ask the client to send its avatar. // Ask the client to send its avatar.
boost::shared_ptr<NetPacket> retrieveAvatar(new NetPacketRetrieveAvatar); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketRetrieveAvatar::Data retrieveAvatarData; packet->GetMsg()->present = PokerTHMessage_PR_avatarRequestMessage;
retrieveAvatarData.requestId = session.playerData->GetUniqueId(); AvatarRequestMessage_t *netAvatarRequest = &packet->GetMsg()->choice.avatarRequestMessage;
retrieveAvatarData.avatar = session.playerData->GetAvatarMD5(); netAvatarRequest->requestId = session.playerData->GetUniqueId();
static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData); OCTET_STRING_fromBuf(
GetSender().Send(session.sessionData, retrieveAvatar); &netAvatarRequest->avatar,
(char *)session.playerData->GetAvatarMD5().data,
MD5_DATA_SIZE);
GetSender().Send(session.sessionData, packet);
} }
void void
@@ -1236,17 +1311,16 @@ ServerLobbyThread::InternalResubscribeMsg(SessionWrapper session)
session.sessionData->SetWantsLobbyMsg(); session.sessionData->SetWantsLobbyMsg();
SendGameList(session.sessionData); SendGameList(session.sessionData);
// Send new statistics information. // Send new statistics information.
boost::shared_ptr<NetPacket> packet(new NetPacketStatisticsChanged); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketStatisticsChanged::Data statData; packet->GetMsg()->present = PokerTHMessage_PR_statisticsMessage;
statData.stats.numberOfPlayersOnServer = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount(); StatisticsMessage_t *netStatistics = &packet->GetMsg()->choice.statisticsMessage;
try {
static_cast<NetPacketStatisticsChanged *>(packet.get())->SetData(statData);
GetSender().Send(session.sessionData, packet); StatisticsData_t *data = (StatisticsData_t *)calloc(1, sizeof(struct StatisticsData));
} catch (const NetException &) data->statisticsType = statisticsType_statNumberOfPlayers;
{ data->statisticsValue = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
// Ignore errors for now. ASN_SEQUENCE_ADD(&netStatistics->statisticsData.list, data);
}
GetSender().Send(session.sessionData, packet);
} }
} }
@@ -1286,11 +1360,12 @@ ServerLobbyThread::InternalCheckSessionTimeouts(SessionWrapper session)
&& !session.sessionData->HasActivityNoticeBeenSent()) && !session.sessionData->HasActivityNoticeBeenSent())
{ {
session.sessionData->MarkActivityNotice(); session.sessionData->MarkActivityNotice();
boost::shared_ptr<NetPacket> packet(new NetPacketTimeoutWarning);
NetPacketTimeoutWarning::Data warningData; boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
warningData.timeoutReason = NETWORK_TIMEOUT_GENERIC; packet->GetMsg()->present = PokerTHMessage_PR_timeoutWarningMessage;
warningData.remainingSeconds = SERVER_TIMEOUT_WARNING_REMAINING_SEC; TimeoutWarningMessage_t *netWarning = &packet->GetMsg()->choice.timeoutWarningMessage;
static_cast<NetPacketTimeoutWarning *>(packet.get())->SetData(warningData); netWarning->timeoutReason = timeoutReason_timeoutNoDataReceived;
netWarning->remainingSeconds = SERVER_TIMEOUT_WARNING_REMAINING_SEC;
GetSender().Send(session.sessionData, packet); GetSender().Send(session.sessionData, packet);
} }
else if (session.sessionData->GetActivityTimerElapsedSec() >= SERVER_SESSION_ACTIVITY_TIMEOUT_SEC) else if (session.sessionData->GetActivityTimerElapsedSec() >= SERVER_SESSION_ACTIVITY_TIMEOUT_SEC)
@@ -1324,20 +1399,39 @@ void
ServerLobbyThread::SendError(boost::shared_ptr<SessionData> s, int errorCode) ServerLobbyThread::SendError(boost::shared_ptr<SessionData> s, int errorCode)
{ {
LOG_VERBOSE("Sending error code " << errorCode << " to session #" << s->GetId() << "."); LOG_VERBOSE("Sending error code " << errorCode << " to session #" << s->GetId() << ".");
boost::shared_ptr<NetPacket> packet(new NetPacketError); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketError::Data errorData; packet->GetMsg()->present = PokerTHMessage_PR_errorMessage;
errorData.errorCode = errorCode; ErrorMessage_t *netError = &packet->GetMsg()->choice.errorMessage;
static_cast<NetPacketError *>(packet.get())->SetData(errorData); netError->errorReason = NetPacket::GameErrorToNetError(errorCode);
GetSender().Send(s, packet); GetSender().Send(s, packet);
} }
void void
ServerLobbyThread::SendJoinGameFailed(boost::shared_ptr<SessionData> s, int reason) ServerLobbyThread::SendJoinGameFailed(boost::shared_ptr<SessionData> s, int reason)
{ {
boost::shared_ptr<NetPacket> packet(new NetPacketJoinGameFailed); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketJoinGameFailed::Data failedData; packet->GetMsg()->present = PokerTHMessage_PR_joinGameReplyMessage;
failedData.failureCode = reason; JoinGameReplyMessage_t *netJoinReply = &packet->GetMsg()->choice.joinGameReplyMessage;
static_cast<NetPacketJoinGameFailed *>(packet.get())->SetData(failedData); netJoinReply->gameId = s->GetGameId();
netJoinReply->joinGameResult.present = joinGameResult_PR_joinGameFailed;
JoinGameFailed_t *joinFailed = &netJoinReply->joinGameResult.choice.joinGameFailed;
switch (reason)
{
case NTF_NET_JOIN_GAME_FULL :
joinFailed->joinGameFailureReason = joinGameFailureReason_gameIsFull;
break;
case NTF_NET_JOIN_ALREADY_RUNNING :
joinFailed->joinGameFailureReason = joinGameFailureReason_gameIsRunning;
break;
case NTF_NET_JOIN_INVALID_PASSWORD :
joinFailed->joinGameFailureReason = joinGameFailureReason_invalidPassword;
break;
default :
joinFailed->joinGameFailureReason = joinGameFailureReason_invalidGame;
break;
}
GetSender().Send(s, packet); GetSender().Send(s, packet);
} }
@@ -1377,19 +1471,17 @@ ServerLobbyThread::BroadcastStatisticsUpdate(const ServerStats &stats)
{ {
if (stats.numberOfPlayersOnServer) if (stats.numberOfPlayersOnServer)
{ {
boost::shared_ptr<NetPacket> packet(new NetPacketStatisticsChanged); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketStatisticsChanged::Data statData; packet->GetMsg()->present = PokerTHMessage_PR_statisticsMessage;
statData.stats = stats; StatisticsMessage_t *netStatistics = &packet->GetMsg()->choice.statisticsMessage;
try {
static_cast<NetPacketStatisticsChanged *>(packet.get())->SetData(statData);
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established); StatisticsData_t *data = (StatisticsData_t *)calloc(1, sizeof(struct StatisticsData));
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game); data->statisticsType = statisticsType_statNumberOfPlayers;
} catch (const NetException &) data->statisticsValue = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
{ ASN_SEQUENCE_ADD(&netStatistics->statisticsData.list, data);
// Ignore errors for now.
//LOG_ERROR("ServerLobbyThread::BroadcastStatisticsUpdate: " << e.what()); m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
} m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
} }
} }
@@ -1499,27 +1591,48 @@ ServerLobbyThread::IsPlayerConnected(const string &name) const
boost::shared_ptr<NetPacket> boost::shared_ptr<NetPacket>
ServerLobbyThread::CreateNetPacketGameListNew(const ServerGame &game) ServerLobbyThread::CreateNetPacketGameListNew(const ServerGame &game)
{ {
boost::shared_ptr<NetPacket> packet(new NetPacketGameListNew); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketGameListNew::Data packetData; packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
packetData.gameId = game.GetId(); GameListMessage_t *netGameList = &packet->GetMsg()->choice.gameListMessage;
packetData.gameInfo.adminPlayerId = game.GetAdminPlayerId(); netGameList->gameId = game.GetId();
packetData.gameInfo.mode = game.IsRunning() ? GAME_MODE_STARTED : GAME_MODE_CREATED;
packetData.gameInfo.name = game.GetName(); netGameList->gameListNotification.present = gameListNotification_PR_gameListNew;
packetData.gameInfo.data = game.GetGameData(); GameListNew_t *gameNew = &netGameList->gameListNotification.choice.gameListNew;
packetData.gameInfo.players = game.GetPlayerIdList(); gameNew->adminPlayerId = game.GetAdminPlayerId();
packetData.gameInfo.isPasswordProtected = game.IsPasswordProtected(); gameNew->gameMode = game.IsRunning() ? NetGameMode_gameStarted : NetGameMode_gameCreated;
static_cast<NetPacketGameListNew *>(packet.get())->SetData(packetData); NetPacket::SetGameData(game.GetGameData(), &gameNew->gameInfo);
OCTET_STRING_fromBuf(
&gameNew->gameInfo.gameName,
game.GetName().c_str(),
game.GetName().length());
gameNew->isPrivate = game.IsPasswordProtected();
PlayerIdList tmpList = game.GetPlayerIdList();
PlayerIdList::const_iterator i = tmpList.begin();
PlayerIdList::const_iterator end = tmpList.end();
while (i != end)
{
NonZeroId_t *playerId = (NonZeroId_t *)calloc(1, sizeof(NonZeroId_t));
*playerId = *i;
ASN_SEQUENCE_ADD(&gameNew->playerIds.list, playerId);
++i;
}
return packet; return packet;
} }
boost::shared_ptr<NetPacket> boost::shared_ptr<NetPacket>
ServerLobbyThread::CreateNetPacketGameListUpdate(unsigned gameId, GameMode mode) ServerLobbyThread::CreateNetPacketGameListUpdate(unsigned gameId, GameMode mode)
{ {
boost::shared_ptr<NetPacket> packet(new NetPacketGameListUpdate); boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
NetPacketGameListUpdate::Data packetData; packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
packetData.gameId = gameId; GameListMessage_t *netGameList = &packet->GetMsg()->choice.gameListMessage;
packetData.gameMode = mode; netGameList->gameId = gameId;
static_cast<NetPacketGameListUpdate *>(packet.get())->SetData(packetData);
netGameList->gameListNotification.present = gameListNotification_PR_gameListUpdate;
GameListUpdate_t *gameUpdate = &netGameList->gameListNotification.choice.gameListUpdate;
gameUpdate->gameMode = mode;
return packet; return packet;
} }
src/net/common/sessionmanager.cpp
+3 -3
View File
@@ -307,7 +307,7 @@ SessionManager::SendToAllSessions(SenderHelper &sender, boost::shared_ptr<NetPac
// Send each client (with a certain state) a copy of the packet. // Send each client (with a certain state) a copy of the packet.
if (i->second.sessionData->GetState() == state) if (i->second.sessionData->GetState() == state)
sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone())); sender.Send(i->second.sessionData, packet);
++i; ++i;
} }
} }
@@ -327,7 +327,7 @@ SessionManager::SendLobbyMsgToAllSessions(SenderHelper &sender, boost::shared_pt
// Send each client (with a certain state) a copy of the packet. // Send each client (with a certain state) a copy of the packet.
if (i->second.sessionData->GetState() == state && i->second.sessionData->WantsLobbyMsg()) if (i->second.sessionData->GetState() == state && i->second.sessionData->WantsLobbyMsg())
sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone())); sender.Send(i->second.sessionData, packet);
++i; ++i;
} }
} }
@@ -345,7 +345,7 @@ SessionManager::SendToAllButOneSessions(SenderHelper &sender, boost::shared_ptr<
// Send each fully connected client but one a copy of the packet. // Send each fully connected client but one a copy of the packet.
if (i->second.sessionData->GetState() == state) if (i->second.sessionData->GetState() == state)
if (i->first != except) if (i->first != except)
sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone())); sender.Send(i->second.sessionData, packet);
++i; ++i;
} }
} }
src/net/netpacket.h
+21 -1522
View File
File diff suppressed because it is too large Load Diff
src/net/senderhelper.h
+2
View File
@@ -39,6 +39,8 @@ public:
void SignalSessionTerminated(unsigned sessionId); void SignalSessionTerminated(unsigned sessionId);
protected: protected:
void InternalStorePacket(SendDataManager &tmpManager, boost::shared_ptr<NetPacket> packet);
typedef std::map<SessionId, boost::shared_ptr<SendDataManager> > SendQueueMap; typedef std::map<SessionId, boost::shared_ptr<SendDataManager> > SendQueueMap;
private: private:
src/net/servergamestate.h
+1 -1
View File
@@ -92,7 +92,7 @@ protected:
virtual void InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet); virtual void InternalProcessPacket(boost::shared_ptr<ServerGame> server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(const PlayerData &playerData); static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData);
private: private:
static ServerGameStateInit s_state; static ServerGameStateInit s_state;
src/net/serverlobbythread.h
+11 -11
View File
@@ -67,8 +67,8 @@ public:
void NotifyStartingGame(unsigned gameId); void NotifyStartingGame(unsigned gameId);
void NotifyReopeningGame(unsigned gameId); void NotifyReopeningGame(unsigned gameId);
void HandleGameRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket); void HandleGameRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest);
void HandleGameRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket); void HandleGameRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar);
bool KickPlayerByName(const std::string &playerName); bool KickPlayerByName(const std::string &playerName);
std::string GetPlayerIPAddress(const std::string &playerName) const; std::string GetPlayerIPAddress(const std::string &playerName) const;
@@ -111,15 +111,15 @@ protected:
void HandleRead(const boost::system::error_code &ec, SessionId sessionId, size_t bytesRead); void HandleRead(const boost::system::error_code &ec, SessionId sessionId, size_t bytesRead);
void HandlePacket(SessionWrapper session, boost::shared_ptr<NetPacket> packet); void HandlePacket(SessionWrapper session, boost::shared_ptr<NetPacket> packet);
void HandleNetPacketInit(SessionWrapper session, const NetPacketInit &tmpPacket); void HandleNetPacketInit(SessionWrapper session, const InitMessage_t &initMessage);
void HandleNetPacketAvatarHeader(SessionWrapper session, const NetPacketAvatarHeader &tmpPacket); void HandleNetPacketAvatarHeader(SessionWrapper session, unsigned requestId, const AvatarHeader_t &avatarHeader);
void HandleNetPacketUnknownAvatar(SessionWrapper session, const NetPacketUnknownAvatar &tmpPacket); void HandleNetPacketUnknownAvatar(SessionWrapper session, unsigned requestId, const UnknownAvatar_t &unknownAvatar);
void HandleNetPacketAvatarFile(SessionWrapper session, const NetPacketAvatarFile &tmpPacket); void HandleNetPacketAvatarFile(SessionWrapper session, unsigned requestId, const AvatarData_t &avatarData);
void HandleNetPacketAvatarEnd(SessionWrapper session, const NetPacketAvatarEnd &tmpPacket); void HandleNetPacketAvatarEnd(SessionWrapper session, unsigned requestId, const AvatarEnd_t &avatarEnd);
void HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket); void HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest);
void HandleNetPacketRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket); void HandleNetPacketRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar);
void HandleNetPacketCreateGame(SessionWrapper session, const NetPacketCreateGame &tmpPacket); void HandleNetPacketCreateGame(SessionWrapper session, const std::string &password, const JoinNewGame_t &newGame);
void HandleNetPacketJoinGame(SessionWrapper session, const NetPacketJoinGame &tmpPacket); void HandleNetPacketJoinGame(SessionWrapper session, const std::string &password, const JoinExistingGame_t &joinGame);
void EstablishSession(SessionWrapper session); void EstablishSession(SessionWrapper session);
void RequestPlayerAvatar(SessionWrapper session); void RequestPlayerAvatar(SessionWrapper session);
void TimerRemoveGame(const boost::system::error_code &ec); void TimerRemoveGame(const boost::system::error_code &ec);
src/net/socket_msg.h
+4 -3
View File
@@ -104,9 +104,10 @@
#define NTF_NET_REMOVED_START_FAILED 207 #define NTF_NET_REMOVED_START_FAILED 207
// Notifications - join failed // Notifications - join failed
#define NTF_NET_JOIN_GAME_FULL 210 #define NTF_NET_JOIN_GAME_INVALID 210
#define NTF_NET_JOIN_ALREADY_RUNNING 211 #define NTF_NET_JOIN_GAME_FULL 211
#define NTF_NET_JOIN_INVALID_PASSWORD 212 #define NTF_NET_JOIN_ALREADY_RUNNING 212
#define NTF_NET_JOIN_INVALID_PASSWORD 213
// Notifications - version // Notifications - version
#define NTF_NET_NEW_RELEASE_AVAILABLE 220 #define NTF_NET_NEW_RELEASE_AVAILABLE 220
src/playerdata.cpp
+5 -5
View File
@@ -92,16 +92,16 @@ PlayerData::SetNetSessionData(boost::shared_ptr<SessionData> session)
m_netSessionData = session; m_netSessionData = session;
} }
boost::shared_ptr<AvatarData> boost::shared_ptr<AvatarFile>
PlayerData::GetNetAvatarData() const PlayerData::GetNetAvatarFile() const
{ {
return m_netAvatarData; return m_netAvatarFile;
} }
void void
PlayerData::SetNetAvatarData(boost::shared_ptr<AvatarData> avatarData) PlayerData::SetNetAvatarFile(boost::shared_ptr<AvatarFile> AvatarFile)
{ {
m_netAvatarData = avatarData; m_netAvatarFile = AvatarFile;
} }
PlayerType PlayerType
src/playerdata.h
+5 -5
View File
@@ -51,9 +51,9 @@ enum AvatarFileType
AVATAR_FILE_TYPE_GIF AVATAR_FILE_TYPE_GIF
}; };
struct AvatarData struct AvatarFile
{ {
AvatarData() : fileType(AVATAR_FILE_TYPE_UNKNOWN), reportedSize(0) {} AvatarFile() : fileType(AVATAR_FILE_TYPE_UNKNOWN), reportedSize(0) {}
std::vector<unsigned char> fileData; std::vector<unsigned char> fileData;
AvatarFileType fileType; AvatarFileType fileType;
unsigned reportedSize; unsigned reportedSize;
@@ -84,8 +84,8 @@ public:
void SetAvatarMD5(const MD5Buf &avatarMD5); void SetAvatarMD5(const MD5Buf &avatarMD5);
boost::shared_ptr<SessionData> GetNetSessionData() const; boost::shared_ptr<SessionData> GetNetSessionData() const;
void SetNetSessionData(boost::shared_ptr<SessionData> session); void SetNetSessionData(boost::shared_ptr<SessionData> session);
boost::shared_ptr<AvatarData> GetNetAvatarData() const; boost::shared_ptr<AvatarFile> GetNetAvatarFile() const;
void SetNetAvatarData(boost::shared_ptr<AvatarData> avatarData); void SetNetAvatarFile(boost::shared_ptr<AvatarFile> AvatarFile);
PlayerType GetType() const; PlayerType GetType() const;
void SetType(PlayerType type); void SetType(PlayerType type);
PlayerRights GetRights() const; PlayerRights GetRights() const;
@@ -105,7 +105,7 @@ private:
PlayerType m_type; PlayerType m_type;
PlayerRights m_rights; PlayerRights m_rights;
boost::shared_ptr<SessionData> m_netSessionData; boost::shared_ptr<SessionData> m_netSessionData;
boost::shared_ptr<AvatarData> m_netAvatarData; boost::shared_ptr<AvatarFile> m_netAvatarFile;
mutable boost::mutex m_dataMutex; mutable boost::mutex m_dataMutex;
}; };
src/pokerth.cpp
+8 -8
View File
@@ -18,12 +18,20 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include <boost/asio.hpp>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <qapplication.h> #include <qapplication.h>
#include <QtGui>
#include <QtCore>
#ifdef __APPLE__ #ifdef __APPLE__
#include <QMacStyle> #include <QMacStyle>
#endif #endif
#include <curl/curl.h>
#include "session.h" #include "session.h"
#include "startwindowimpl.h" #include "startwindowimpl.h"
#include "configfile.h" #include "configfile.h"
@@ -31,14 +39,6 @@
#include "game_defs.h" #include "game_defs.h"
#include <net/socket_startup.h> #include <net/socket_startup.h>
#include <curl/curl.h>
#include <QtGui>
#include <QtCore>
#include <iostream>
#include <cstdlib>
#include <ctime>
#ifdef _MSC_VER #ifdef _MSC_VER
#ifdef _DEBUG #ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC #define _CRTDBG_MAP_ALLOC
src/session.cpp
+1
View File
@@ -17,6 +17,7 @@
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include <boost/asio.hpp>
#include <net/socket_helper.h> #include <net/socket_helper.h>
#include "session.h" #include "session.h"
#include "game.h" #include "game.h"