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
src/net/clientthread.h
+6 -6
View File
@@ -98,7 +98,7 @@ protected:
typedef std::map<unsigned, GameInfo> GameInfoMap;
typedef std::list<boost::shared_ptr<NetPacket> > NetPacketList;
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;
// Main function of the thread.
@@ -117,10 +117,10 @@ protected:
void SetNewGameAdmin(unsigned id);
void RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info);
void AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFileType type);
void StoreInTempAvatarData(unsigned playerId, const std::vector<unsigned char> &data);
void CompleteTempAvatarData(unsigned playerId);
void PassAvatarDataToManager(unsigned playerId, boost::shared_ptr<AvatarData> avatarData);
void AddTempAvatarFile(unsigned playerId, unsigned avatarSize, AvatarFileType type);
void StoreInTempAvatarFile(unsigned playerId, const std::vector<unsigned char> &data);
void CompleteTempAvatarFile(unsigned playerId);
void PassAvatarFileToManager(unsigned playerId, boost::shared_ptr<AvatarFile> AvatarFile);
void SetUnknownAvatar(unsigned playerId);
void TimerCheckAvatarDownloads(const boost::system::error_code& ec);
@@ -234,7 +234,7 @@ private:
unsigned m_curPetitionId;
mutable boost::mutex m_curPetitionIdMutex;
AvatarDataMap m_tempAvatarMap;
AvatarFileMap m_tempAvatarMap;
unsigned m_curGameNum;
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. *
***************************************************************************/
#include <boost/asio.hpp>
#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
ClientThread::SendKickPlayer(unsigned playerId)
{
boost::shared_ptr<NetPacket> request(new NetPacketKickPlayer);
NetPacketKickPlayer::Data requestData;
requestData.playerId = playerId;
static_cast<NetPacketKickPlayer *>(request.get())->SetData(requestData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), request));
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_kickPlayerRequestMessage;
KickPlayerRequestMessage_t *netKick = &packet->GetMsg()->choice.kickPlayerRequestMessage;
netKick->gameId = GetGameId();
netKick->playerId = playerId;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
ClientThread::SendLeaveCurrentGame()
{
boost::shared_ptr<NetPacket> request(new NetPacketLeaveCurrentGame);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), request));
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_leaveGameRequestMessage;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
@@ -138,17 +140,12 @@ ClientThread::SendStartEvent(bool fillUpWithCpuPlayers)
{
// Warning: This function is called in the context of the GUI thread.
// Create a network packet for the server start event.
boost::shared_ptr<NetPacket> start(new NetPacketStartEvent);
NetPacketStartEvent::Data startData;
startData.fillUpWithCpuPlayers = fillUpWithCpuPlayers;
try
{
static_cast<NetPacketStartEvent *>(start.get())->SetData(startData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), start));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendStartEvent: " << e.what());
}
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_startEventMessage;
StartEventMessage_t *netStartEvent = &packet->GetMsg()->choice.startEventMessage;
netStartEvent->gameId = GetGameId();
netStartEvent->fillWithComputerPlayers = fillUpWithCpuPlayers;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
@@ -156,25 +153,20 @@ ClientThread::SendPlayerAction()
{
// Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the current player action.
boost::shared_ptr<NetPacket> action(new NetPacketPlayersAction);
NetPacketPlayersAction::Data actionData;
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_myActionRequestMessage;
MyActionRequestMessage_t *netMyAction = &packet->GetMsg()->choice.myActionRequestMessage;
netMyAction->gameId = GetGameId();
boost::shared_ptr<PlayerInterface> myPlayer = GetGame()->getSeatsList()->front();
actionData.gameState = static_cast<GameState>(GetGame()->getCurrentHand()->getCurrentRound());
actionData.playerAction = static_cast<PlayerAction>(myPlayer->getMyAction());
netMyAction->gameState = GetGame()->getCurrentHand()->getCurrentRound();
netMyAction->myAction = myPlayer->getMyAction();
// Only send last bet if not fold/checked.
if (actionData.playerAction != PLAYER_ACTION_FOLD && actionData.playerAction != PLAYER_ACTION_CHECK)
actionData.playerBet = myPlayer->getMyLastRelativeSet();
if (myPlayer->getMyAction() != PLAYER_ACTION_FOLD && myPlayer->getMyAction() != PLAYER_ACTION_CHECK)
netMyAction->myRelativeBet = myPlayer->getMyLastRelativeSet();
else
actionData.playerBet = 0;
try
{
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());
}
netMyAction->myRelativeBet = 0;
// Just dump the packet.
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
@@ -182,18 +174,16 @@ ClientThread::SendChatMessage(const std::string &msg)
{
// Warning: This function is called in the context of the GUI thread.
// Create a network packet containing the chat message.
boost::shared_ptr<NetPacket> chat(new NetPacketSendChatText);
NetPacketSendChatText::Data chatData;
chatData.text = msg;
try
{
static_cast<NetPacketSendChatText *>(chat.get())->SetData(chatData);
// Just dump the packet.
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), chat));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendChatMessage: " << e.what());
}
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_chatRequestMessage;
ChatRequestMessage_t *netChat = &packet->GetMsg()->choice.chatRequestMessage;
netChat->gameId = GetGameId();
OCTET_STRING_fromBuf(&netChat->chatText,
msg.c_str(),
msg.length());
// Just dump the packet.
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
@@ -201,18 +191,21 @@ ClientThread::SendJoinFirstGame(const std::string &password)
{
// Warning: This function is called in the context of the GUI thread.
// Create a network packet to request joining a game.
boost::shared_ptr<NetPacket> join(new NetPacketJoinGame);
NetPacketJoinGame::Data joinData;
joinData.gameId = 1;
joinData.password = password;
try
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
if (!password.empty())
{
static_cast<NetPacketJoinGame *>(join.get())->SetData(joinData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), join));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendJoinFirstGame: " << e.what());
netJoinGame->password = OCTET_STRING_new_fromBuf(
&asn_DEF_UTF8String,
password.c_str(),
password.length());
}
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
@@ -220,18 +213,21 @@ ClientThread::SendJoinGame(unsigned gameId, const std::string &password)
{
// Warning: This function is called in the context of the GUI thread.
// Create a network packet to request joining a game.
boost::shared_ptr<NetPacket> join(new NetPacketJoinGame);
NetPacketJoinGame::Data joinData;
joinData.password = password;
joinData.gameId = gameId;
try
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
if (!password.empty())
{
static_cast<NetPacketJoinGame *>(join.get())->SetData(joinData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), join));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendJoinGame: " << e.what());
netJoinGame->password = OCTET_STRING_new_fromBuf(
&asn_DEF_UTF8String,
password.c_str(),
password.length());
}
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
@@ -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.
// Create a network packet to request creating a new game.
boost::shared_ptr<NetPacket> create(new NetPacketCreateGame);
NetPacketCreateGame::Data createData;
createData.gameData = gameData;
createData.gameName = name;
createData.password = password;
try
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_joinGameRequestMessage;
JoinGameRequestMessage_t *netJoinGame = &packet->GetMsg()->choice.joinGameRequestMessage;
if (!password.empty())
{
static_cast<NetPacketCreateGame *>(create.get())->SetData(createData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), create));
} catch (const NetException &e)
{
LOG_ERROR("ClientThread::SendCreateGame: " << e.what());
netJoinGame->password = OCTET_STRING_new_fromBuf(
&asn_DEF_UTF8String,
password.c_str(),
password.length());
}
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
ClientThread::SendResetTimeout()
{
boost::shared_ptr<NetPacket> reset(new NetPacketResetTimeout);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), reset));
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_resetTimeoutMessage;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
ClientThread::SendAskKickPlayer(unsigned playerId)
{
boost::shared_ptr<NetPacket> ask(new NetPacketAskKickPlayer);
NetPacketAskKickPlayer::Data askData;
askData.playerId = playerId;
static_cast<NetPacketAskKickPlayer *>(ask.get())->SetData(askData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), ask));
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_askKickPlayerMessage;
AskKickPlayerMessage_t *netAsk = &packet->GetMsg()->choice.askKickPlayerMessage;
netAsk->playerId = playerId;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
ClientThread::SendVoteKick(bool doKick)
{
boost::shared_ptr<NetPacket> vote(new NetPacketVoteKickPlayer);
NetPacketVoteKickPlayer::Data voteData;
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_voteKickRequestMessage;
VoteKickRequestMessage_t *netVote = &packet->GetMsg()->choice.voteKickRequestMessage;
{
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;
static_cast<NetPacketVoteKickPlayer *>(vote.get())->SetData(voteData);
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), vote));
netVote->voteKick = doKick;
m_ioService->post(boost::bind(&ClientThread::SendSessionPacket, shared_from_this(), packet));
}
void
@@ -523,11 +525,11 @@ ClientThread::RequestPlayerInfo(unsigned id, bool requestAvatar)
{
if (find(m_playerInfoRequestList.begin(), m_playerInfoRequestList.end(), id) == m_playerInfoRequestList.end())
{
boost::shared_ptr<NetPacket> req(new NetPacketRetrievePlayerInfo);
NetPacketRetrievePlayerInfo::Data reqData;
reqData.playerId = id;
static_cast<NetPacketRetrievePlayerInfo *>(req.get())->SetData(reqData);
GetSender().Send(GetContext().GetSessionData(), req);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_playerInfoRequestMessage;
PlayerInfoRequestMessage_t *netPlayerInfo = &packet->GetMsg()->choice.playerInfoRequestMessage;
netPlayerInfo->playerId = id;
GetSender().Send(GetContext().GetSessionData(), packet);
m_playerInfoRequestList.push_back(id);
@@ -637,21 +639,23 @@ ClientThread::RetrieveAvatarIfNeeded(unsigned id, const PlayerInfo &info)
}
else
{
boost::shared_ptr<NetPacket> retrieveAvatar(new NetPacketRetrieveAvatar);
NetPacketRetrieveAvatar::Data retrieveAvatarData;
retrieveAvatarData.requestId = id;
retrieveAvatarData.avatar = info.avatar;
static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData);
GetSender().Send(GetContext().GetSessionData(), retrieveAvatar);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_avatarRequestMessage;
AvatarRequestMessage_t *netAvatar = &packet->GetMsg()->choice.avatarRequestMessage;
netAvatar->requestId = id;
OCTET_STRING_fromBuf(&netAvatar->avatar,
(const char *)info.avatar.data,
MD5_DATA_SIZE);
GetSender().Send(GetContext().GetSessionData(), packet);
}
}
}
}
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->fileType = type;
tmpAvatar->reportedSize = avatarSize;
@@ -660,9 +664,9 @@ ClientThread::AddTempAvatarData(unsigned playerId, unsigned avatarSize, AvatarFi
}
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())
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_REQUEST_ID, 0);
// We trust the server (concerning size of the data).
@@ -670,33 +674,33 @@ ClientThread::StoreInTempAvatarData(unsigned playerId, const vector<unsigned cha
}
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())
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();
if (avatarSize != tmpAvatar->reportedSize)
LOG_ERROR("Client received invalid avatar file size!");
else
PassAvatarDataToManager(playerId, tmpAvatar);
PassAvatarFileToManager(playerId, tmpAvatar);
// Free memory.
m_tempAvatarMap.erase(pos);
}
void
ClientThread::PassAvatarDataToManager(unsigned playerId, boost::shared_ptr<AvatarData> avatarData)
ClientThread::PassAvatarFileToManager(unsigned playerId, boost::shared_ptr<AvatarFile> AvatarFile)
{
PlayerInfo tmpPlayerInfo;
if (!GetCachedPlayerInfo(playerId, tmpPlayerInfo))
LOG_ERROR("Client received invalid player id!");
else
{
if (avatarData->fileType == AVATAR_FILE_TYPE_UNKNOWN)
avatarData->fileType = tmpPlayerInfo.avatarType;
if (!GetAvatarManager().StoreAvatarInCache(tmpPlayerInfo.avatar, avatarData->fileType, &avatarData->fileData[0], avatarData->reportedSize, false))
if (AvatarFile->fileType == AVATAR_FILE_TYPE_UNKNOWN)
AvatarFile->fileType = tmpPlayerInfo.avatarType;
if (!GetAvatarManager().StoreAvatarInCache(tmpPlayerInfo.avatar, AvatarFile->fileType, &AvatarFile->fileData[0], AvatarFile->reportedSize, false))
LOG_ERROR("Failed to store avatar in cache directory.");
// 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())
{
unsigned playerId;
boost::shared_ptr<AvatarData> tmpAvatar(new AvatarData);
boost::shared_ptr<AvatarFile> tmpAvatar(new AvatarFile);
m_avatarDownloader->GetDownloadResult(playerId, tmpAvatar->fileData);
tmpAvatar->reportedSize = tmpAvatar->fileData.size();
PassAvatarDataToManager(playerId, tmpAvatar);
PassAvatarFileToManager(playerId, tmpAvatar);
}
m_avatarTimer.expires_from_now(
boost::posix_time::milliseconds(CLIENT_AVATAR_LOOP_MSEC));
@@ -745,8 +749,11 @@ ClientThread::UnsubscribeLobbyMsg()
if (GetContext().GetSubscribeLobbyMsg())
{
// Send unsubscribe request.
boost::shared_ptr<NetPacket> unsubscr(new NetPacketUnsubscribeGameList);
GetSender().Send(GetContext().GetSessionData(), unsubscr);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
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);
}
}
@@ -759,8 +766,10 @@ ClientThread::ResubscribeLobbyMsg()
// Clear game info map as it is outdated.
ClearGameInfoMap();
// Send resubscribe request.
boost::shared_ptr<NetPacket> resubscr(new NetPacketResubscribeGameList);
GetSender().Send(GetContext().GetSessionData(), resubscr);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_subscriptionRequestMessage;
SubscriptionRequestMessage_t *netRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
netRequest->subscriptionAction = subscriptionAction_resubscribeGameList;
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.
// Packets may be received in multiple chunks or
// several packets may be received at once.
if (buf.recvBufUsed >= MIN_PACKET_SIZE)
if (buf.recvBufUsed)
{
try
{
src/net/common/senderhelper.cpp
+49 -7
View File
@@ -17,8 +17,9 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <boost/asio.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/sendercallback.h>
@@ -37,8 +38,37 @@ using boost::asio::ip::tcp;
#define SEND_QUEUE_SIZE 10000000
#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>
{
@@ -87,7 +117,7 @@ SendDataManager::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::soc
SendDataList::iterator end = list.end();
while (i != end)
{
bufSize += (*i)->GetLen();
bufSize += (*i)->GetSize();
++i;
}
if (bufSize)
@@ -97,8 +127,8 @@ SendDataManager::AsyncSendNextPacket(boost::shared_ptr<boost::asio::ip::tcp::soc
end = list.end();
while (i != end)
{
memcpy(sendBuf + bufPos, (*i)->GetRawData(), (*i)->GetLen());
bufPos += (*i)->GetLen();
memcpy(sendBuf + bufPos, (*i)->GetData(), (*i)->GetSize());
bufPos += (*i)->GetSize();
++i;
}
list.clear();
@@ -144,7 +174,7 @@ SenderHelper::Send(boost::shared_ptr<SessionData> session, boost::shared_ptr<Net
boost::mutex::scoped_lock lock(tmpManager->dataMutex);
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)
{
if (*i)
tmpManager->list.push_back(*i);
InternalStorePacket(*tmpManager, *i);
++i;
}
}
@@ -200,3 +230,15 @@ SenderHelper::SignalSessionTerminated(unsigned sessionId)
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. *
***************************************************************************/
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <net/servergame.h>
#include <net/servergamestate.h>
#include <net/serverlobbythread.h>
@@ -29,8 +32,6 @@
#include <localenginefactory.h>
#include <tools.h>
#include <boost/bind.hpp>
#define SERVER_CHECK_VOTE_KICK_INTERVAL_MSEC 500
#define SERVER_KICK_TIMEOUT_ADD_DELAY_SEC 2
@@ -181,16 +182,15 @@ ServerGame::TimerVoteKick(const boost::system::error_code &ec)
}
if (abortPetition)
{
boost::shared_ptr<NetPacket> endPetition(new NetPacketEndKickPlayerPetition);
NetPacketEndKickPlayerPetition::Data endPetitionData;
endPetitionData.petitionId = m_voteKickData->petitionId;
endPetitionData.numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
endPetitionData.numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
endPetitionData.playerKicked = doKick;
endPetitionData.endReason = reason;
static_cast<NetPacketEndKickPlayerPetition *>(endPetition.get())->SetData(endPetitionData);
SendToAllPlayers(endPetition, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_endKickPetitionMessage;
EndKickPetitionMessage_t *netEndPetition = &packet->GetMsg()->choice.endKickPetitionMessage;
netEndPetition->petitionId = m_voteKickData->petitionId;
netEndPetition->numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
netEndPetition->numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
netEndPetition->resultPlayerKicked = doKick;
netEndPetition->petitionEndReason = reason;
SendToAllPlayers(packet, SessionData::Game);
// Perform kick.
if (doKick)
@@ -300,16 +300,15 @@ ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, uns
m_voteKickData->numVotesInFavourOfKicking = 1;
m_voteKickData->votedPlayerIds.push_back(playerIdByWhom);
boost::shared_ptr<NetPacket> startPetition(new NetPacketStartKickPlayerPetition);
NetPacketStartKickPlayerPetition::Data startPetitionData;
startPetitionData.petitionId = m_voteKickData->petitionId;
startPetitionData.proposingPlayerId = playerIdByWhom;
startPetitionData.kickPlayerId = m_voteKickData->kickPlayerId;
startPetitionData.kickTimeoutSec = timeoutSec;
startPetitionData.numVotesNeededToKick = m_voteKickData->numVotesToKick;
static_cast<NetPacketStartKickPlayerPetition *>(startPetition.get())->SetData(startPetitionData);
SendToAllPlayers(startPetition, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_startKickPetitionMessage;
StartKickPetitionMessage_t *netStartPetition = &packet->GetMsg()->choice.startKickPetitionMessage;
netStartPetition->petitionId = m_voteKickData->petitionId;
netStartPetition->proposingPlayerId = playerIdByWhom;
netStartPetition->kickPlayerId = m_voteKickData->kickPlayerId;
netStartPetition->kickTimeoutSec = timeoutSec;
netStartPetition->numVotesNeededToKick = m_voteKickData->numVotesToKick;
SendToAllPlayers(packet, SessionData::Game);
}
else
InternalDenyAskVoteKick(byWhom, playerIdWho, KICK_DENIED_OTHER_IN_PROGRESS);
@@ -327,12 +326,12 @@ ServerGame::InternalAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, uns
void
ServerGame::InternalDenyAskVoteKick(SessionWrapper byWhom, unsigned playerIdWho, DenyKickPlayerReason reason)
{
boost::shared_ptr<NetPacket> denyPetition(new NetPacketAskKickPlayerDenied);
NetPacketAskKickPlayerDenied::Data denyPetitionData;
denyPetitionData.playerId = playerIdWho;
denyPetitionData.denyReason = reason;
static_cast<NetPacketAskKickPlayerDenied *>(denyPetition.get())->SetData(denyPetitionData);
GetLobbyThread().GetSender().Send(byWhom.sessionData, denyPetition);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_askKickDeniedMessage;
AskKickDeniedMessage_t *netKickDenied = &packet->GetMsg()->choice.askKickDeniedMessage;
netKickDenied->playerId = playerIdWho;
netKickDenied->kickDeniedReason = reason;
GetLobbyThread().GetSender().Send(byWhom.sessionData, packet);
}
void
@@ -353,15 +352,14 @@ ServerGame::InternalVoteKick(SessionWrapper byWhom, unsigned petitionId, KickVot
else
m_voteKickData->numVotesAgainstKicking++;
// Send update notification.
boost::shared_ptr<NetPacket> updatePetition(new NetPacketKickPlayerPetitionUpdate);
NetPacketKickPlayerPetitionUpdate::Data updatePetitionData;
updatePetitionData.petitionId = m_voteKickData->petitionId;
updatePetitionData.numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
updatePetitionData.numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
updatePetitionData.numVotesNeededToKick = m_voteKickData->numVotesToKick;
static_cast<NetPacketKickPlayerPetitionUpdate *>(updatePetition.get())->SetData(updatePetitionData);
SendToAllPlayers(updatePetition, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_kickPetitionUpdateMessage;
KickPetitionUpdateMessage_t *netKickUpdate = &packet->GetMsg()->choice.kickPetitionUpdateMessage;
netKickUpdate->petitionId = m_voteKickData->petitionId;
netKickUpdate->numVotesAgainstKicking = m_voteKickData->numVotesAgainstKicking;
netKickUpdate->numVotesInFavourOfKicking = m_voteKickData->numVotesInFavourOfKicking;
netKickUpdate->numVotesNeededToKick = m_voteKickData->numVotesToKick;
SendToAllPlayers(packet, SessionData::Game);
}
else
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);
}
else
InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_IMPOSSIBLE);
InternalDenyVoteKick(byWhom, petitionId, VOTE_DENIED_INVALID_PETITION);
}
void
ServerGame::InternalDenyVoteKick(SessionWrapper byWhom, unsigned petitionId, DenyVoteReason reason)
{
boost::shared_ptr<NetPacket> denyVote(new NetPacketVoteKickPlayerDenied);
NetPacketVoteKickPlayerDenied::Data denyVoteData;
denyVoteData.petitionId = petitionId;
denyVoteData.denyReason = reason;
static_cast<NetPacketVoteKickPlayerDenied *>(denyVote.get())->SetData(denyVoteData);
GetLobbyThread().GetSender().Send(byWhom.sessionData, denyVote);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_voteKickReplyMessage;
VoteKickReplyMessage_t *netVoteReply = &packet->GetMsg()->choice.voteKickReplyMessage;
netVoteReply->petitionId = petitionId;
netVoteReply->voteKickReplyType.present = voteKickReplyType_PR_voteKickDenied;
VoteKickDenied_t *kickDenied = &netVoteReply->voteKickReplyType.choice.voteKickDenied;
kickDenied->voteKickDeniedReason = reason;
GetLobbyThread().GetSender().Send(byWhom.sessionData, packet);
}
PlayerDataList
@@ -557,10 +558,14 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
// Notify game state on admin change
GetState().NotifyGameAdminChanged(shared_from_this());
// Send "Game Admin Changed" to clients.
boost::shared_ptr<NetPacket> adminChanged(new NetPacketGameAdminChanged);
NetPacketGameAdminChanged::Data adminChangedData;
adminChangedData.playerId = newAdmin->GetUniqueId(); // Choose next player as admin.
static_cast<NetPacketGameAdminChanged *>(adminChanged.get())->SetData(adminChangedData);
boost::shared_ptr<NetPacket> adminChanged(new NetPacket(NetPacket::Alloc));
adminChanged->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
GamePlayerMessage_t *netGameAdmin = &adminChanged->GetMsg()->choice.gamePlayerMessage;
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);
GetLobbyThread().NotifyGameAdminChanged(GetId(), newAdmin->GetUniqueId());
@@ -570,11 +575,26 @@ ServerGame::RemovePlayerData(boost::shared_ptr<PlayerData> player, int reason)
player->SetRights(PLAYER_RIGHTS_NORMAL);
// Send "Player Left" to clients.
boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacketPlayerLeft);
NetPacketPlayerLeft::Data thisPlayerLeftData;
thisPlayerLeftData.playerId = player->GetUniqueId();
thisPlayerLeftData.removeReason = reason;
static_cast<NetPacketPlayerLeft *>(thisPlayerLeft.get())->SetData(thisPlayerLeftData);
boost::shared_ptr<NetPacket> thisPlayerLeft(new NetPacket(NetPacket::Alloc));
thisPlayerLeft->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
GamePlayerMessage_t *netPlayerLeft = &thisPlayerLeft->GetMsg()->choice.gamePlayerMessage;
netPlayerLeft->gameId = GetId();
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);
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())
throw ServerException(__FILE__, __LINE__, ERR_NET_NO_CURRENT_PLAYER, 0);
boost::shared_ptr<NetPacket> notifyActionDone(new NetPacketPlayersActionDone);
NetPacketPlayersActionDone::Data actionDoneData;
actionDoneData.gameState = server.GetCurRound();
actionDoneData.playerId = player->getMyUniqueID();
actionDoneData.playerAction = static_cast<PlayerAction>(player->getMyAction());
actionDoneData.totalPlayerBet = player->getMySet();
actionDoneData.playerMoney = player->getMyCash();
actionDoneData.highestSet = server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
actionDoneData.minimumRaise = server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
static_cast<NetPacketPlayersActionDone *>(notifyActionDone.get())->SetData(actionDoneData);
server.SendToAllPlayers(notifyActionDone, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
PlayersActionDoneMessage_t *netActionDone = &packet->GetMsg()->choice.playersActionDoneMessage;
netActionDone->gameId = server.GetId();
netActionDone->gameState = server.GetCurRound();
netActionDone->highestSet = server.GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
netActionDone->minimumRaise = server.GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
netActionDone->playerAction = static_cast<PlayerAction>(player->getMyAction());
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)
{
int cards[5];
curGame.getCurrentHand()->getBoard()->getMyCards(cards);
switch(state) {
case GAME_STATE_PREFLOP: {
// nothing to do
} break;
case GAME_STATE_FLOP: {
// deal flop cards
int cards[5];
curGame.getCurrentHand()->getBoard()->getMyCards(cards);
boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealFlopCards);
NetPacketDealFlopCards::Data notifyCardsData;
for (int num = 0; num < 3; num++)
notifyCardsData.flopCards[num] = static_cast<u_int16_t>(cards[num]);
static_cast<NetPacketDealFlopCards *>(notifyCards.get())->SetData(notifyCardsData);
server.SendToAllPlayers(notifyCards, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_dealFlopCardsMessage;
DealFlopCardsMessage_t *netDealFlop = &packet->GetMsg()->choice.dealFlopCardsMessage;
netDealFlop->gameId = server.GetId();
netDealFlop->flopCard1 = cards[0];
netDealFlop->flopCard2 = cards[1];
netDealFlop->flopCard3 = cards[2];
server.SendToAllPlayers(packet, SessionData::Game);
} break;
case GAME_STATE_TURN: {
// deal turn card
int cards[5];
curGame.getCurrentHand()->getBoard()->getMyCards(cards);
boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealTurnCard);
NetPacketDealTurnCard::Data notifyCardsData;
notifyCardsData.turnCard = static_cast<u_int16_t>(cards[3]);
static_cast<NetPacketDealTurnCard *>(notifyCards.get())->SetData(notifyCardsData);
server.SendToAllPlayers(notifyCards, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_dealTurnCardMessage;
DealTurnCardMessage_t *netDealTurn = &packet->GetMsg()->choice.dealTurnCardMessage;
netDealTurn->gameId = server.GetId();
netDealTurn->turnCard = cards[3];
server.SendToAllPlayers(packet, SessionData::Game);
} break;
case GAME_STATE_RIVER: {
// deal river card
int cards[5];
curGame.getCurrentHand()->getBoard()->getMyCards(cards);
boost::shared_ptr<NetPacket> notifyCards(new NetPacketDealRiverCard);
NetPacketDealRiverCard::Data notifyCardsData;
notifyCardsData.riverCard = static_cast<u_int16_t>(cards[4]);
static_cast<NetPacketDealRiverCard *>(notifyCards.get())->SetData(notifyCardsData);
server.SendToAllPlayers(notifyCards, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_dealRiverCardMessage;
DealRiverCardMessage_t *netDealRiver = &packet->GetMsg()->choice.dealRiverCardMessage;
netDealRiver->gameId = server.GetId();
netDealRiver->riverCard = cards[4];
server.SendToAllPlayers(packet, SessionData::Game);
} break;
default: {
//
@@ -186,81 +189,76 @@ AbstractServerGameStateReceiving::ProcessPacket(boost::shared_ptr<ServerGame> se
{
if (packet->IsClientActivity())
session.sessionData->ResetActivityTimer();
if (packet->ToNetPacketRetrievePlayerInfo())
if (packet->GetMsg()->present == PokerTHMessage_PR_playerInfoRequestMessage)
{
// 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.
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);
}
else if (packet->ToNetPacketKickPlayer())
else if (packet->GetMsg()->present == PokerTHMessage_PR_kickPlayerRequestMessage)
{
// Only admins are allowed to kick, and only in the lobby.
// 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;
packet->ToNetPacketKickPlayer()->GetData(kickPlayerData);
server->InternalKickPlayer(kickPlayerData.playerId);
server->InternalKickPlayer(netKickRequest->playerId);
}
}
else if (packet->ToNetPacketAskKickPlayer())
else if (packet->GetMsg()->present == PokerTHMessage_PR_askKickPlayerMessage)
{
if (session.playerData)
{
NetPacketAskKickPlayer::Data askKickData;
packet->ToNetPacketAskKickPlayer()->GetData(askKickData);
server->InternalAskVoteKick(session, askKickData.playerId, SERVER_VOTE_KICK_TIMEOUT_SEC);
AskKickPlayerMessage_t *netAskKick = &packet->GetMsg()->choice.askKickPlayerMessage;
server->InternalAskVoteKick(session, netAskKick->playerId, SERVER_VOTE_KICK_TIMEOUT_SEC);
}
}
else if (packet->ToNetPacketVoteKickPlayer())
else if (packet->GetMsg()->present == PokerTHMessage_PR_voteKickRequestMessage)
{
if (session.playerData)
{
NetPacketVoteKickPlayer::Data voteData;
packet->ToNetPacketVoteKickPlayer()->GetData(voteData);
server->InternalVoteKick(session, voteData.petitionId, voteData.vote);
VoteKickRequestMessage_t *netVoteKick = &packet->GetMsg()->choice.voteKickRequestMessage;
server->InternalVoteKick(session, netVoteKick->petitionId, netVoteKick->voteKick ? KICK_VOTE_AGAINST : KICK_VOTE_IN_FAVOUR);
}
}
// 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.
{
// Forward chat text to all players.
// TODO: Some limitation needed.
NetPacketSendChatText::Data inChatData;
packet->ToNetPacketSendChatText()->GetData(inChatData);
boost::shared_ptr<NetPacket> outChat(new NetPacketChatText);
NetPacketChatText::Data outChatData;
outChatData.playerId = session.playerData->GetUniqueId();
outChatData.text = inChatData.text;
static_cast<NetPacketChatText *>(outChat.get())->SetData(outChatData);
server->SendToAllPlayers(outChat, SessionData::Game);
ChatRequestMessage_t *netChatRequest = &packet->GetMsg()->choice.chatRequestMessage;
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_chatMessage;
ChatMessage_t *netChat = &packet->GetMsg()->choice.chatMessage;
netChat->gameId = server->GetId();
netChat->playerId = session.playerData->GetUniqueId();
OCTET_STRING_fromBuf(
&netChat->chatText,
(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.
session.sessionData->ResetWantsLobbyMsg();
}
else if (packet->ToNetPacketResubscribeGameList())
{
// This needs to be performed in the lobby thread,
// because a new game list needs to be sent.
if (!session.sessionData->WantsLobbyMsg())
server->GetLobbyThread().ResubscribeLobbyMsg(session);
SubscriptionRequestMessage_t *netSubscription = &packet->GetMsg()->choice.subscriptionRequestMessage;
if (netSubscription->subscriptionAction == subscriptionAction_resubscribeGameList)
{
if (!session.sessionData->WantsLobbyMsg())
server->GetLobbyThread().ResubscribeLobbyMsg(session);
}
else
session.sessionData->ResetWantsLobbyMsg();
}
else
{
@@ -332,13 +330,19 @@ ServerGameStateInit::HandleNewSession(boost::shared_ptr<ServerGame> server, Sess
}
// Send ack to client.
boost::shared_ptr<NetPacket> joinGameAck(new NetPacketJoinGameAck);
NetPacketJoinGameAck::Data joinGameAckData;
joinGameAckData.gameId = server->GetId();
joinGameAckData.prights = session.playerData->GetRights();
joinGameAckData.gameData = server->GetGameData();
static_cast<NetPacketJoinGameAck *>(joinGameAck.get())->SetData(joinGameAckData);
server->GetLobbyThread().GetSender().Send(session.sessionData, joinGameAck);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_joinGameReplyMessage;
JoinGameReplyMessage_t *netJoinReply = &packet->GetMsg()->choice.joinGameReplyMessage;
netJoinReply->gameId = server->GetId();
netJoinReply->joinGameResult.present = joinGameResult_PR_joinGameAck;
JoinGameAck_t *joinAck = &netJoinReply->joinGameResult.choice.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.
PlayerDataList tmpPlayerList = server->GetFullPlayerDataList();
@@ -346,12 +350,12 @@ ServerGameStateInit::HandleNewSession(boost::shared_ptr<ServerGame> server, Sess
PlayerDataList::iterator player_end = tmpPlayerList.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;
}
// 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.
server->GetSessionManager().AddSession(session);
@@ -388,12 +392,12 @@ ServerGameStateInit::TimerAdminWarning(const boost::system::error_code &ec, boos
if (session.sessionData.get())
{
// Send him a warning.
boost::shared_ptr<NetPacket> warning(new NetPacketTimeoutWarning);
NetPacketTimeoutWarning::Data warningData;
warningData.timeoutReason = NETWORK_TIMEOUT_GAME_ADMIN_IDLE;
warningData.remainingSeconds = SERVER_GAME_ADMIN_WARNING_REMAINING_SEC;
static_cast<NetPacketTimeoutWarning *>(warning.get())->SetData(warningData);
server->GetLobbyThread().GetSender().Send(session.sessionData, warning);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_timeoutWarningMessage;
TimeoutWarningMessage_t *netWarning = &packet->GetMsg()->choice.timeoutWarningMessage;
netWarning->timeoutReason = NETWORK_TIMEOUT_GAME_ADMIN_IDLE;
netWarning->remainingSeconds = SERVER_GAME_ADMIN_WARNING_REMAINING_SEC;
server->GetLobbyThread().GetSender().Send(session.sessionData, packet);
}
// Start timeout timer.
server->GetStateTimer().expires_from_now(
@@ -422,18 +426,16 @@ ServerGameStateInit::TimerAdminTimeout(const boost::system::error_code &ec, boos
void
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.
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.
server->ResetComputerPlayerList();
if (startData.fillUpWithCpuPlayers)
if (netStartEvent->fillWithComputerPlayers)
{
int remainingSlots = server->GetGameData().maxNumberOfPlayers - server->GetCurNumberOfPlayers();
for (int i = 1; i <= remainingSlots; i++)
@@ -447,19 +449,19 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
server->AddComputerPlayer(tmpPlayerData);
// Send "Player Joined" to other fully connected clients.
server->SendToAllPlayers(CreateNetPacketPlayerJoined(*tmpPlayerData), SessionData::Game);
server->SendToAllPlayers(CreateNetPacketPlayerJoined(server->GetId(), *tmpPlayerData), SessionData::Game);
// Notify lobby.
server->GetLobbyThread().NotifyPlayerJoinedGame(server->GetId(), tmpPlayerData->GetUniqueId());
}
}
// 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());
}
}
else if (packet->ToNetPacketResetTimeout())
else if (packet->GetMsg()->present == PokerTHMessage_PR_resetTimeoutMessage)
{
if (session.playerData->GetRights() == PLAYER_RIGHTS_ADMIN)
{
@@ -473,14 +475,17 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
}
boost::shared_ptr<NetPacket>
ServerGameStateInit::CreateNetPacketPlayerJoined(const PlayerData &playerData)
ServerGameStateInit::CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData)
{
boost::shared_ptr<NetPacket> thisPlayerJoined(new NetPacketPlayerJoined);
NetPacketPlayerJoined::Data thisPlayerJoinedData;
thisPlayerJoinedData.playerId = playerData.GetUniqueId();
thisPlayerJoinedData.prights = playerData.GetRights();
static_cast<NetPacketPlayerJoined *>(thisPlayerJoined.get())->SetData(thisPlayerJoinedData);
return thisPlayerJoined;
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
GamePlayerMessage_t *netGamePlayer = &packet->GetMsg()->choice.gamePlayerMessage;
netGamePlayer->gameId = gameId;
netGamePlayer->gamePlayerNotification.present = gamePlayerNotification_PR_gamePlayerJoined;
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
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();
if (server->GetSessionManager().CountReadySessions() == server->GetSessionManager().GetRawSessionCount())
@@ -570,10 +575,11 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
{
server->InternalStartGame();
boost::shared_ptr<NetPacket> answer(new NetPacketGameStart);
NetPacketGameStart::Data gameStartData;
gameStartData.startData = server->GetStartData();
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameStartMessage;
GameStartMessage_t *netGameStart = &packet->GetMsg()->choice.gameStartMessage;
netGameStart->gameId = server->GetId();
netGameStart->startDealerPlayerId = server->GetStartData().startDealerPlayerId;
// Send player order to clients.
// Assume player list is sorted by number.
@@ -581,15 +587,14 @@ ServerGameStateStartGame::DoStart(boost::shared_ptr<ServerGame> server)
PlayerDataList::iterator player_end = tmpPlayerList.end();
while (player_i != player_end)
{
NetPacketGameStart::PlayerSlot tmpPlayerSlot;
tmpPlayerSlot.playerId = (*player_i)->GetUniqueId();
gameStartData.playerSlots.push_back(tmpPlayerSlot);
NonZeroId_t *playerSlot = (NonZeroId_t *)calloc(1, sizeof(NonZeroId_t));
*playerSlot = (*player_i)->GetUniqueId();
ASN_SEQUENCE_ADD(&netGameStart->playerSeats.list, playerSlot);
++player_i;
}
static_cast<NetPacketGameStart *>(answer.get())->SetData(gameStartData);
server->SendToAllPlayers(answer, SessionData::Game);
server->SendToAllPlayers(packet, SessionData::Game);
// Start the first hand.
ServerGameStateHand::StartNewHand(server);
@@ -688,26 +693,26 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
&& nonFoldPlayers.size() > 1)
{
// Send cards of all active players to all players (all in).
boost::shared_ptr<NetPacket> allIn(new NetPacketAllInShowCards);
NetPacketAllInShowCards::Data allInData;
boost::shared_ptr<NetPacket> allIn(new NetPacket(NetPacket::Alloc));
allIn->GetMsg()->present = PokerTHMessage_PR_allInShowCardsMessage;
AllInShowCardsMessage_t *netAllInShow = &allIn->GetMsg()->choice.allInShowCardsMessage;
netAllInShow->gameId = server->GetId();
PlayerListConstIterator i = nonFoldPlayers.begin();
PlayerListConstIterator end = nonFoldPlayers.end();
while (i != end)
{
NetPacketAllInShowCards::PlayerCards tmpPlayerCards;
tmpPlayerCards.playerId = (*i)->getMyUniqueID();
PlayerAllIn_t *playerAllIn = (PlayerAllIn_t *)calloc(1, sizeof(PlayerAllIn_t));
playerAllIn->playerId = (*i)->getMyUniqueID();
int tmpCards[2];
(*i)->getMyCards(tmpCards);
tmpPlayerCards.cards[0] = static_cast<u_int16_t>(tmpCards[0]);
tmpPlayerCards.cards[1] = static_cast<u_int16_t>(tmpCards[1]);
playerAllIn->allInCard1 = tmpCards[0];
playerAllIn->allInCard2 = tmpCards[1];
ASN_SEQUENCE_ADD(&netAllInShow->playersAllIn.list, playerAllIn);
allInData.playerCards.push_back(tmpPlayerCards);
++i;
}
static_cast<NetPacketAllInShowCards *>(allIn.get())->SetData(allInData);
server->SendToAllPlayers(allIn, SessionData::Game);
curGame.getCurrentHand()->setCardsShown(true);
@@ -742,12 +747,12 @@ ServerGameStateHand::EngineLoop(boost::shared_ptr<ServerGame> server)
if (!curPlayer->getMyActiveStatus())
throw ServerException(__FILE__, __LINE__, ERR_NET_PLAYER_NOT_ACTIVE, 0);
boost::shared_ptr<NetPacket> notification(new NetPacketPlayersTurn);
NetPacketPlayersTurn::Data playersTurnData;
playersTurnData.gameState = (GameState)curGame.getCurrentHand()->getCurrentRound();
playersTurnData.playerId = curPlayer->getMyUniqueID();
static_cast<NetPacketPlayersTurn *>(notification.get())->SetData(playersTurnData);
boost::shared_ptr<NetPacket> notification(new NetPacket(NetPacket::Alloc));
notification->GetMsg()->present = PokerTHMessage_PR_playersTurnMessage;
PlayersTurnMessage_t *netPlayersTurn = &notification->GetMsg()->choice.playersTurnMessage;
netPlayersTurn->gameId = server->GetId();
netPlayersTurn->gameState = curGame.getCurrentHand()->getCurrentRound();
netPlayersTurn->playerId = curPlayer->getMyUniqueID();
server->SendToAllPlayers(notification, SessionData::Game);
// 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.
boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
boost::shared_ptr<NetPacket> endHand(new NetPacketEndOfHandHideCards);
NetPacketEndOfHandHideCards::Data endHandData;
endHandData.playerId = player->getMyUniqueID();
endHandData.moneyWon = player->getLastMoneyWon();
endHandData.playerMoney = player->getMyCash();
static_cast<NetPacketEndOfHandHideCards *>(endHand.get())->SetData(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_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);
}
else
{
// End of Hand - show cards of active players.
boost::shared_ptr<NetPacket> endHand(new NetPacketEndOfHandShowCards);
NetPacketEndOfHandShowCards::Data endHandData;
boost::shared_ptr<PlayerInterface> player = nonFoldPlayers.front();
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 end = nonFoldPlayers.end();
while (i != end)
{
NetPacketEndOfHandShowCards::PlayerResult tmpPlayerResult;
tmpPlayerResult.playerId = (*i)->getMyUniqueID();
PlayerResult_t *playerResult = (PlayerResult_t *)calloc(1, sizeof(PlayerResult_t));
playerResult->playerId = (*i)->getMyUniqueID();
int tmpCards[2];
int bestHandPos[5];
(*i)->getMyCards(tmpCards);
tmpPlayerResult.cards[0] = static_cast<u_int16_t>(tmpCards[0]);
tmpPlayerResult.cards[1] = static_cast<u_int16_t>(tmpCards[1]);
playerResult->resultCard1 = tmpCards[0];
playerResult->resultCard2 = tmpCards[1];
(*i)->getMyBestHandPosition(bestHandPos);
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();
tmpPlayerResult.moneyWon = (*i)->getLastMoneyWon();
tmpPlayerResult.playerMoney = (*i)->getMyCash();
playerResult->cardsValue = (*i)->getMyCardsValueInt();
playerResult->moneyWon = (*i)->getLastMoneyWon();
playerResult->playerMoney = (*i)->getMyCash();
endHandData.playerResults.push_back(tmpPlayerResult);
ASN_SEQUENCE_ADD(&endHandShow->playerResults.list, playerResult);
++i;
}
static_cast<NetPacketEndOfHandShowCards *>(endHand.get())->SetData(endHandData);
server->SendToAllPlayers(endHand, SessionData::Game);
}
@@ -934,11 +948,11 @@ ServerGameStateHand::TimerNextGame(const boost::system::error_code &ec, boost::s
if (winnerPlayer)
{
boost::shared_ptr<NetPacket> endGame(new NetPacketEndOfGame);
NetPacketEndOfGame::Data endGameData;
endGameData.winnerPlayerId = winnerPlayer->getMyUniqueID();
static_cast<NetPacketEndOfGame *>(endGame.get())->SetData(endGameData);
boost::shared_ptr<NetPacket> endGame(new NetPacket(NetPacket::Alloc));
endGame->GetMsg()->present = PokerTHMessage_PR_endOfGameMessage;
EndOfGameMessage_t *netEndGame = &endGame->GetMsg()->choice.endOfGameMessage;
netEndGame->gameId = server->GetId();
netEndGame->winnerPlayerId = winnerPlayer->getMyUniqueID();
server->SendToAllPlayers(endGame, SessionData::Game);
// Wait for the start of a new game.
@@ -1002,13 +1016,14 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
{
int cards[2];
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);
}
++i;
@@ -1026,16 +1041,17 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
if (tmpPlayer->getMyButton() == BUTTON_SMALL_BLIND)
{
boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacketPlayersActionDone);
NetPacketPlayersActionDone::Data actionDoneData;
actionDoneData.gameState = GAME_STATE_PREFLOP_SMALL_BLIND;
actionDoneData.playerId = tmpPlayer->getMyUniqueID();
actionDoneData.playerAction = (PlayerAction)tmpPlayer->getMyAction();
actionDoneData.totalPlayerBet = tmpPlayer->getMySet();
actionDoneData.playerMoney = tmpPlayer->getMyCash();
actionDoneData.highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
actionDoneData.minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
static_cast<NetPacketPlayersActionDone *>(notifySmallBlind.get())->SetData(actionDoneData);
boost::shared_ptr<NetPacket> notifySmallBlind(new NetPacket(NetPacket::Alloc));
notifySmallBlind->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
PlayersActionDoneMessage_t *netSmallBlind = &notifySmallBlind->GetMsg()->choice.playersActionDoneMessage;
netSmallBlind->gameId = server->GetId();
netSmallBlind->gameState = NetGameState_statePreflopSmallBlind;
netSmallBlind->playerId = tmpPlayer->getMyUniqueID();
netSmallBlind->playerAction = tmpPlayer->getMyAction();
netSmallBlind->totalPlayerBet = tmpPlayer->getMySet();
netSmallBlind->playerMoney = tmpPlayer->getMyCash();
netSmallBlind->highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
netSmallBlind->minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
server->SendToAllPlayers(notifySmallBlind, SessionData::Game);
break;
}
@@ -1049,16 +1065,17 @@ ServerGameStateHand::StartNewHand(boost::shared_ptr<ServerGame> server)
boost::shared_ptr<PlayerInterface> tmpPlayer = *i;
if (tmpPlayer->getMyButton() == BUTTON_BIG_BLIND)
{
boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacketPlayersActionDone);
NetPacketPlayersActionDone::Data actionDoneData;
actionDoneData.gameState = GAME_STATE_PREFLOP_BIG_BLIND;
actionDoneData.playerId = tmpPlayer->getMyUniqueID();
actionDoneData.playerAction = (PlayerAction)tmpPlayer->getMyAction();
actionDoneData.totalPlayerBet = tmpPlayer->getMySet();
actionDoneData.playerMoney = tmpPlayer->getMyCash();
actionDoneData.highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
actionDoneData.minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
static_cast<NetPacketPlayersActionDone *>(notifyBigBlind.get())->SetData(actionDoneData);
boost::shared_ptr<NetPacket> notifyBigBlind(new NetPacket(NetPacket::Alloc));
notifyBigBlind->GetMsg()->present = PokerTHMessage_PR_playersActionDoneMessage;
PlayersActionDoneMessage_t *netBigBlind = &notifyBigBlind->GetMsg()->choice.playersActionDoneMessage;
netBigBlind->gameId = server->GetId();
netBigBlind->gameState = NetGameState_statePreflopBigBlind;
netBigBlind->playerId = tmpPlayer->getMyUniqueID();
netBigBlind->playerAction = tmpPlayer->getMyAction();
netBigBlind->totalPlayerBet = tmpPlayer->getMySet();
netBigBlind->playerMoney = tmpPlayer->getMyCash();
netBigBlind->highestSet = server->GetGame().getCurrentHand()->getCurrentBeRo()->getHighestSet();
netBigBlind->minimumRaise = server->GetGame().getCurrentHand()->getCurrentBeRo()->getMinimumRaise();
server->SendToAllPlayers(notifyBigBlind, SessionData::Game);
break;
}
@@ -1116,11 +1133,11 @@ ServerGameStateWaitPlayerAction::HandleNewSession(boost::shared_ptr<ServerGame>
void
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;
packet->ToNetPacketPlayersAction()->GetData(actionData);
MyActionRequestMessage_t *netMyAction = &packet->GetMsg()->choice.myActionRequestMessage;
// TODO consider game id.
Game &curGame = server->GetGame();
boost::shared_ptr<PlayerInterface> tmpPlayer = curGame.getPlayerByUniqueId(session.playerData->GetUniqueId());
if (!tmpPlayer.get())
@@ -1128,7 +1145,7 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
// Check whether this is the correct round.
PlayerActionCode code = ACTION_CODE_VALID;
if (curGame.getCurrentHand()->getCurrentRound() != actionData.gameState)
if (curGame.getCurrentHand()->getCurrentRound() != netMyAction->gameState)
code = ACTION_CODE_INVALID_STATE;
// 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 (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())
actionData.playerAction = PLAYER_ACTION_ALLIN;
netMyAction->myAction = PLAYER_ACTION_ALLIN;
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)
actionData.playerBet = tmpPlayer->getMyCash();
if (netMyAction->myAction == PLAYER_ACTION_ALLIN && netMyAction->myRelativeBet == 0)
netMyAction->myRelativeBet = tmpPlayer->getMyCash();
// Check whether the action is valid.
if (code == ACTION_CODE_VALID
&& (tmpPlayer->checkMyAction(
actionData.playerAction,
actionData.playerBet,
netMyAction->myAction,
netMyAction->myRelativeBet,
curGame.getCurrentHand()->getCurrentBeRo()->getHighestSet(),
curGame.getCurrentHand()->getCurrentBeRo()->getMinimumRaise(),
curGame.getCurrentHand()->getSmallBlind()) != 0))
@@ -1164,19 +1181,20 @@ ServerGameStateWaitPlayerAction::InternalProcessPacket(boost::shared_ptr<ServerG
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());
}
else
{
// Send reject message.
boost::shared_ptr<NetPacket> reject(new NetPacketPlayersActionRejected);
NetPacketPlayersActionRejected::Data rejectData;
rejectData.gameState = actionData.gameState;
rejectData.playerAction = actionData.playerAction;
rejectData.playerBet = actionData.playerBet;
rejectData.rejectionReason = code;
static_cast<NetPacketPlayersActionRejected *>(reject.get())->SetData(rejectData);
boost::shared_ptr<NetPacket> reject(new NetPacket(NetPacket::Alloc));
reject->GetMsg()->present = PokerTHMessage_PR_yourActionRejectedMessage;
YourActionRejectedMessage_t *netActionRejected = &reject->GetMsg()->choice.yourActionRejectedMessage;
netActionRejected->gameId = server->GetId();
netActionRejected->gameState = netMyAction->gameState;
netActionRejected->yourAction = netMyAction->myAction;
netActionRejected->yourRelativeBet = netMyAction->myRelativeBet;
netActionRejected->rejectionReason = code;
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())
{
boost::shared_ptr<NetPacket> packet(new NetPacketRemovedFromGame);
NetPacketRemovedFromGame::Data removedData;
removedData.removeReason = reason;
static_cast<NetPacketRemovedFromGame *>(packet.get())->SetData(removedData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gamePlayerMessage;
GamePlayerMessage_t *netPlayerMsg = &packet->GetMsg()->choice.gamePlayerMessage;
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);
HandleReAddedSession(session);
@@ -251,11 +274,15 @@ void
ServerLobbyThread::NotifyPlayerJoinedGame(unsigned gameId, unsigned playerId)
{
// Send notification to players in lobby.
boost::shared_ptr<NetPacket> packet(new NetPacketGameListPlayerJoined);
NetPacketGameListPlayerJoined::Data packetData;
packetData.gameId = gameId;
packetData.playerId = playerId;
static_cast<NetPacketGameListPlayerJoined *>(packet.get())->SetData(packetData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
netListMsg->gameId = gameId;
netListMsg->gameListNotification.present = gameListNotification_PR_gameListPlayerJoined;
GameListPlayerJoined_t *playerJoined = &netListMsg->gameListNotification.choice.gameListPlayerJoined;
playerJoined->playerId = playerId;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
}
@@ -264,11 +291,15 @@ void
ServerLobbyThread::NotifyPlayerLeftGame(unsigned gameId, unsigned playerId)
{
// Send notification to players in lobby.
boost::shared_ptr<NetPacket> packet(new NetPacketGameListPlayerLeft);
NetPacketGameListPlayerLeft::Data packetData;
packetData.gameId = gameId;
packetData.playerId = playerId;
static_cast<NetPacketGameListPlayerLeft *>(packet.get())->SetData(packetData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
netListMsg->gameId = gameId;
netListMsg->gameListNotification.present = gameListNotification_PR_gameListPlayerLeft;
GameListPlayerLeft_t *playerLeft = &netListMsg->gameListNotification.choice.gameListPlayerLeft;
playerLeft->playerId = playerId;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
}
@@ -277,11 +308,15 @@ void
ServerLobbyThread::NotifyGameAdminChanged(unsigned gameId, unsigned newAdminPlayerId)
{
// Send notification to players in lobby.
boost::shared_ptr<NetPacket> packet(new NetPacketGameListAdminChanged);
NetPacketGameListAdminChanged::Data packetData;
packetData.gameId = gameId;
packetData.newAdminplayerId = newAdminPlayerId;
static_cast<NetPacketGameListAdminChanged *>(packet.get())->SetData(packetData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
GameListMessage_t *netListMsg = &packet->GetMsg()->choice.gameListMessage;
netListMsg->gameId = gameId;
netListMsg->gameListNotification.present = gameListNotification_PR_gameListAdminChanged;
GameListAdminChanged_t *adminChanged = &netListMsg->gameListNotification.choice.gameListAdminChanged;
adminChanged->newAdminPlayerId = newAdminPlayerId;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
}
@@ -303,17 +338,17 @@ ServerLobbyThread::NotifyReopeningGame(unsigned gameId)
}
void
ServerLobbyThread::HandleGameRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket)
ServerLobbyThread::HandleGameRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest)
{
// Someone within a game requested player info.
HandleNetPacketRetrievePlayerInfo(session, tmpPacket);
HandleNetPacketRetrievePlayerInfo(session, playerInfoRequest);
}
void
ServerLobbyThread::HandleGameRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket)
ServerLobbyThread::HandleGameRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar)
{
// Someone within a game requested an avatar.
HandleNetPacketRetrieveAvatar(session, tmpPacket);
HandleNetPacketRetrieveAvatar(session, retrieveAvatar);
}
bool
@@ -357,22 +392,32 @@ ServerLobbyThread::RemovePlayer(unsigned playerId, unsigned errorCode)
void
ServerLobbyThread::SendGlobalChat(const string &message)
{
boost::shared_ptr<NetPacket> outChat(new NetPacketChatText);
NetPacketChatText::Data outChatData;
outChatData.playerId = 0;
outChatData.text = message;
static_cast<NetPacketChatText *>(outChat.get())->SetData(outChatData);
m_gameSessionManager.SendToAllSessions(GetSender(), outChat, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_chatMessage;
ChatMessage_t *netChat = &packet->GetMsg()->choice.chatMessage;
// TODO proper game id handling.
netChat->gameId = 0;
netChat->playerId = 0;
OCTET_STRING_fromBuf(
&netChat->chatText,
message.c_str(),
message.length());
m_gameSessionManager.SendToAllSessions(GetSender(), packet, SessionData::Game);
}
void
ServerLobbyThread::SendGlobalMsgBox(const string &message)
{
boost::shared_ptr<NetPacket> outMsg(new NetPacketMsgBoxText);
NetPacketMsgBoxText::Data outMsgData;
outMsgData.text = message;
static_cast<NetPacketMsgBoxText *>(outMsg.get())->SetData(outMsgData);
m_gameSessionManager.SendToAllSessions(GetSender(), outMsg, SessionData::Game);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_dialogMessage;
DialogMessage_t *netDialog = &packet->GetMsg()->choice.dialogMessage;
OCTET_STRING_fromBuf(
&netDialog->notificationText,
message.c_str(),
message.length());
m_gameSessionManager.SendToAllSessions(GetSender(), packet, SessionData::Game);
}
void
@@ -626,40 +671,63 @@ ServerLobbyThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPac
if (session.sessionData->GetState() == SessionData::Init)
{
if (packet->ToNetPacketInit())
HandleNetPacketInit(session, *packet->ToNetPacketInit());
else if (packet->ToNetPacketAvatarHeader())
HandleNetPacketAvatarHeader(session, *packet->ToNetPacketAvatarHeader());
else if (packet->ToNetPacketUnknownAvatar())
HandleNetPacketUnknownAvatar(session, *packet->ToNetPacketUnknownAvatar());
if (packet->GetMsg()->present == PokerTHMessage_PR_initMessage)
HandleNetPacketInit(session, packet->GetMsg()->choice.initMessage);
else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
{
AvatarReplyMessage_t *avatarReply = &packet->GetMsg()->choice.avatarReplyMessage;
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
SessionError(session, ERR_SOCK_INVALID_STATE);
}
else if (session.sessionData->GetState() == SessionData::ReceivingAvatar)
{
if (packet->ToNetPacketAvatarFile())
HandleNetPacketAvatarFile(session, *packet->ToNetPacketAvatarFile());
else if (packet->ToNetPacketAvatarEnd())
HandleNetPacketAvatarEnd(session, *packet->ToNetPacketAvatarEnd());
if (packet->GetMsg()->present == PokerTHMessage_PR_avatarReplyMessage)
{
AvatarReplyMessage_t *avatarReply = &packet->GetMsg()->choice.avatarReplyMessage;
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
SessionError(session, ERR_SOCK_INVALID_STATE);
}
else
{
if (packet->ToNetPacketRetrievePlayerInfo())
HandleNetPacketRetrievePlayerInfo(session, *packet->ToNetPacketRetrievePlayerInfo());
else if (packet->ToNetPacketRetrieveAvatar())
HandleNetPacketRetrieveAvatar(session, *packet->ToNetPacketRetrieveAvatar());
else if (packet->ToNetPacketResetTimeout())
if (packet->GetMsg()->present == PokerTHMessage_PR_playerInfoRequestMessage)
HandleNetPacketRetrievePlayerInfo(session, packet->GetMsg()->choice.playerInfoRequestMessage);
else if (packet->GetMsg()->present == PokerTHMessage_PR_avatarRequestMessage)
HandleNetPacketRetrieveAvatar(session, packet->GetMsg()->choice.avatarRequestMessage);
else if (packet->GetMsg()->present == PokerTHMessage_PR_resetTimeoutMessage)
{}
else if (packet->ToNetPacketUnsubscribeGameList())
session.sessionData->ResetWantsLobbyMsg();
else if (packet->ToNetPacketResubscribeGameList())
InternalResubscribeMsg(session);
else if (packet->ToNetPacketCreateGame())
HandleNetPacketCreateGame(session, *packet->ToNetPacketCreateGame());
else if (packet->ToNetPacketJoinGame())
HandleNetPacketJoinGame(session, *packet->ToNetPacketJoinGame());
else if (packet->GetMsg()->present == PokerTHMessage_PR_subscriptionRequestMessage)
{
SubscriptionRequestMessage_t *subscriptionRequest = &packet->GetMsg()->choice.subscriptionRequestMessage;
if (subscriptionRequest->subscriptionAction == subscriptionAction_resubscribeGameList)
InternalResubscribeMsg(session);
else
session.sessionData->ResetWantsLobbyMsg();
}
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
SessionError(session, ERR_SOCK_INVALID_STATE);
}
@@ -667,52 +735,61 @@ ServerLobbyThread::HandlePacket(SessionWrapper session, boost::shared_ptr<NetPac
}
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() << ".");
NetPacketInit::Data initData;
tmpPacket.GetData(initData);
// Check the protocol version.
if (initData.versionMajor != NET_VERSION_MAJOR)
if (initMessage.requestedVersion.major != NET_VERSION_MAJOR)
{
SessionError(session, ERR_NET_VERSION_NOT_SUPPORTED);
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);
else
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.
if (!CheckPassword(initData.password))
/* if (!CheckPassword(initData.password))
{
SessionError(session, ERR_NET_INVALID_PASSWORD);
return;
}
}*/
// Check whether the player name is correct.
// Partly, this is also done in netpacket.
// However, some disallowed names are checked only here.
if (initData.playerName.empty() || initData.playerName.size() > MAX_NAME_SIZE
|| initData.playerName[0] == '#'
|| initData.playerName[0] == ' '
|| initData.playerName.substr(0, sizeof(SERVER_COMPUTER_PLAYER_NAME) - 1) == SERVER_COMPUTER_PLAYER_NAME)
if (playerName.empty()
|| playerName[0] == '#'
|| playerName[0] == ' '
|| playerName.substr(0, sizeof(SERVER_COMPUTER_PLAYER_NAME) - 1) == SERVER_COMPUTER_PLAYER_NAME)
{
SessionError(session, ERR_NET_INVALID_PLAYER_NAME);
return;
}
// Check whether this player is already connected.
if (IsPlayerConnected(initData.playerName))
if (IsPlayerConnected(playerName))
{
SessionError(session, ERR_NET_PLAYER_NAME_IN_USE);
return;
}
// Check whether the player name is banned.
if (GetBanManager().IsPlayerBanned(initData.playerName))
if (GetBanManager().IsPlayerBanned(playerName))
{
SessionError(session, ERR_NET_PLAYER_BANNED);
return;
@@ -727,19 +804,17 @@ ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketIn
// Create player data object.
boost::shared_ptr<PlayerData> tmpPlayerData(
new PlayerData(GetNextUniquePlayerId(), 0, PLAYER_TYPE_HUMAN, PLAYER_RIGHTS_NORMAL));
tmpPlayerData->SetName(initData.playerName);
tmpPlayerData->SetName(playerName);
tmpPlayerData->SetNetSessionData(session.sessionData);
if (initData.showAvatar)
tmpPlayerData->SetAvatarMD5(initData.avatar);
tmpPlayerData->SetAvatarMD5(avatarMD5);
// Set player data for session.
m_sessionManager.SetSessionPlayerData(session.sessionData->GetId(), tmpPlayerData);
session.playerData = tmpPlayerData;
string avatarFileName;
if (initData.showAvatar
&& !initData.avatar.IsZero()
&& !GetAvatarManager().GetAvatarFileName(initData.avatar, avatarFileName))
if (!avatarMD5.IsZero()
&& !GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName))
{
bool avatarRecentlyRequested = false;
{
@@ -761,22 +836,19 @@ ServerLobbyThread::HandleNetPacketInit(SessionWrapper session, const NetPacketIn
}
void
ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, const NetPacketAvatarHeader &tmpPacket)
ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, unsigned /*requestId*/, const AvatarHeader_t &avatarHeader)
{
if (session.playerData.get())
{
NetPacketAvatarHeader::Data headerData;
tmpPacket.GetData(headerData);
if (headerData.avatarFileSize >= MIN_AVATAR_FILE_SIZE && headerData.avatarFileSize <= MAX_AVATAR_FILE_SIZE)
if (avatarHeader.avatarSize >= MIN_AVATAR_FILE_SIZE && avatarHeader.avatarSize <= MAX_AVATAR_FILE_SIZE)
{
boost::shared_ptr<AvatarData> tmpAvatarData(new AvatarData);
tmpAvatarData->fileData.reserve(headerData.avatarFileSize);
tmpAvatarData->fileType = headerData.avatarFileType;
tmpAvatarData->reportedSize = headerData.avatarFileSize;
boost::shared_ptr<AvatarFile> tmpAvatarFile(new AvatarFile);
tmpAvatarFile->fileData.reserve(avatarHeader.avatarSize);
tmpAvatarFile->fileType = static_cast<AvatarFileType>(avatarHeader.avatarType);
tmpAvatarFile->reportedSize = avatarHeader.avatarSize;
// Ignore request id for now.
session.playerData->SetNetAvatarData(tmpAvatarData);
session.playerData->SetNetAvatarFile(tmpAvatarFile);
// Session is now receiving an avatar.
session.sessionData->SetState(SessionData::ReceivingAvatar);
@@ -787,12 +859,12 @@ ServerLobbyThread::HandleNetPacketAvatarHeader(SessionWrapper session, const Net
}
void
ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, const NetPacketUnknownAvatar &/*tmpPacket*/)
ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, unsigned /*requestId*/, const UnknownAvatar_t &/*unknownAvatar*/)
{
if (session.playerData.get())
{
// Free memory (just in case).
session.playerData->SetNetAvatarData(boost::shared_ptr<AvatarData>());
session.playerData->SetNetAvatarFile(boost::shared_ptr<AvatarFile>());
session.playerData->SetAvatarMD5(MD5Buf());
// Start session.
EstablishSession(session);
@@ -800,27 +872,24 @@ ServerLobbyThread::HandleNetPacketUnknownAvatar(SessionWrapper session, const Ne
}
void
ServerLobbyThread::HandleNetPacketAvatarFile(SessionWrapper session, const NetPacketAvatarFile &tmpPacket)
ServerLobbyThread::HandleNetPacketAvatarFile(SessionWrapper session, unsigned /*requestId*/, const AvatarData_t &avatarData)
{
if (session.playerData.get())
{
NetPacketAvatarFile::Data data;
tmpPacket.GetData(data);
boost::shared_ptr<AvatarData> tmpAvatar = session.playerData->GetNetAvatarData();
if (tmpAvatar.get() && tmpAvatar->fileData.size() + data.fileData.size() <= tmpAvatar->reportedSize)
boost::shared_ptr<AvatarFile> tmpAvatar = session.playerData->GetNetAvatarFile();
if (tmpAvatar.get() && tmpAvatar->fileData.size() + avatarData.avatarBlock.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
ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPacketAvatarEnd &/*tmpPacket*/)
ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, unsigned /*requestId*/, const AvatarEnd_t &/*avatarEnd*/)
{
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();
if (!avatarMD5.IsZero() && tmpAvatar.get())
{
@@ -834,7 +903,7 @@ ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPac
}
// Free memory.
session.playerData->SetNetAvatarData(boost::shared_ptr<AvatarData>());
session.playerData->SetNetAvatarFile(boost::shared_ptr<AvatarFile>());
// Set avatar file name.
string avatarFileName;
if (GetAvatarManager().GetAvatarFileName(avatarMD5, avatarFileName))
@@ -851,63 +920,66 @@ ServerLobbyThread::HandleNetPacketAvatarEnd(SessionWrapper session, const NetPac
}
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.
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())
tmpPlayer = m_gameSessionManager.GetSessionByUniquePlayerId(request.playerId).playerData;
tmpPlayer = m_gameSessionManager.GetSessionByUniquePlayerId(playerInfoRequest.playerId).playerData;
if (!tmpPlayer.get())
{
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())
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())
{
// Send player info to client.
boost::shared_ptr<NetPacket> info(new NetPacketPlayerInfo);
NetPacketPlayerInfo::Data infoData;
infoData.playerId = tmpPlayer->GetUniqueId();
infoData.playerInfo.ptype = tmpPlayer->GetType();
infoData.playerInfo.playerName = tmpPlayer->GetName();
infoData.playerInfo.hasAvatar = !tmpPlayer->GetAvatarMD5().IsZero();
if (infoData.playerInfo.hasAvatar)
netPlayerInfoReply->playerInfoResult.present = playerInfoResult_PR_playerInfoData;
PlayerInfoData *data = &netPlayerInfoReply->playerInfoResult.choice.playerInfoData;
data->isHuman = tmpPlayer->GetType() == PLAYER_TYPE_HUMAN;
OCTET_STRING_fromBuf(
&data->playerName,
tmpPlayer->GetName().c_str(),
tmpPlayer->GetName().length());
if (!tmpPlayer->GetAvatarMD5().IsZero())
{
infoData.playerInfo.avatar = tmpPlayer->GetAvatarMD5();
infoData.playerInfo.avatarType = AvatarManager::GetAvatarFileType(tmpPlayer->GetAvatarFile());
data->avatarData = (struct PlayerInfoData::avatarData *)calloc(1, sizeof(struct PlayerInfoData::avatarData));
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
{
// Unknown player id - notify client.
boost::shared_ptr<NetPacket> unknown(new NetPacketUnknownPlayerId);
NetPacketUnknownPlayerId::Data unknownData;
unknownData.playerId = request.playerId;
static_cast<NetPacketUnknownPlayerId *>(unknown.get())->SetData(unknownData);
GetSender().Send(session.sessionData, unknown);
netPlayerInfoReply->playerInfoResult.present = playerInfoResult_PR_unknownPlayerInfo;
}
GetSender().Send(session.sessionData, packet);
}
void
ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket)
ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar)
{
bool avatarFound = false;
NetPacketRetrieveAvatar::Data request;
tmpPacket.GetData(request);
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;
if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, request.requestId, tmpPackets) == 0)
if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, retrieveAvatar.requestId, tmpPackets) == 0)
{
avatarFound = true;
GetSender().Send(session.sessionData, tmpPackets);
@@ -919,30 +991,31 @@ ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const N
if (!avatarFound)
{
// Notify client we didn't find the avatar.
boost::shared_ptr<NetPacket> unknown(new NetPacketUnknownAvatar);
NetPacketUnknownAvatar::Data unknownData;
unknownData.requestId = request.requestId;
static_cast<NetPacketUnknownAvatar *>(unknown.get())->SetData(unknownData);
GetSender().Send(session.sessionData, unknown);
boost::shared_ptr<NetPacket> unknownAvatar(new NetPacket(NetPacket::Alloc));
unknownAvatar->GetMsg()->present = PokerTHMessage_PR_avatarReplyMessage;
AvatarReplyMessage_t *netAvatarReply = &unknownAvatar->GetMsg()->choice.avatarReplyMessage;
netAvatarReply->requestId = retrieveAvatar.requestId;
netAvatarReply->avatarResult.present = avatarResult_PR_unknownAvatar;
GetSender().Send(session.sessionData, unknownAvatar);
}
}
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() << ".");
// Create a new game.
NetPacketCreateGame::Data createGameData;
tmpPacket.GetData(createGameData);
GameData tmpData;
NetPacket::GetGameData(&newGame.gameInfo, tmpData);
boost::shared_ptr<ServerGame> game(
new ServerGame(
shared_from_this(),
GetNextGameId(),
createGameData.gameName,
createGameData.password,
createGameData.gameData,
string((char *)newGame.gameInfo.gameName.buf, newGame.gameInfo.gameName.size),
password,
tmpData,
session.playerData->GetUniqueId(),
GetGui(),
m_playerConfig));
@@ -954,18 +1027,15 @@ ServerLobbyThread::HandleNetPacketCreateGame(SessionWrapper session, const NetPa
}
void
ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPacketJoinGame &tmpPacket)
ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const std::string &password, const JoinExistingGame_t &joinGame)
{
// Join an existing game.
NetPacketJoinGame::Data joinGameData;
tmpPacket.GetData(joinGameData);
GameMap::iterator pos = m_gameMap.find(joinGameData.gameId);
GameMap::iterator pos = m_gameMap.find(joinGame.gameId);
if (pos != m_gameMap.end())
{
ServerGame &game = *pos->second;
if (game.CheckPassword(joinGameData.password))
if (game.CheckPassword(password))
{
MoveSessionToGame(game, session);
}
@@ -976,6 +1046,7 @@ ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPack
}
else
{
// TODO do not remove session
SessionError(session, ERR_NET_UNKNOWN_GAME);
}
}
@@ -986,14 +1057,15 @@ ServerLobbyThread::EstablishSession(SessionWrapper session)
if (!session.playerData.get())
throw ServerException(__FILE__, __LINE__, ERR_NET_INVALID_SESSION, 0);
// Send ACK to client.
boost::shared_ptr<NetPacket> initAck(new NetPacketInitAck);
NetPacketInitAck::Data initAckData;
initAckData.latestGameVersion = POKERTH_VERSION;
initAckData.latestBetaRevision = POKERTH_BETA_REVISION;
initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
initAckData.playerId = session.playerData->GetUniqueId();
static_cast<NetPacketInitAck *>(initAck.get())->SetData(initAckData);
GetSender().Send(session.sessionData, initAck);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_initAckMessage;
InitAckMessage_t *netInitAck = &packet->GetMsg()->choice.initAckMessage;
netInitAck->latestGameVersion.major = POKERTH_VERSION_MAJOR;
netInitAck->latestGameVersion.minor = POKERTH_VERSION_MINOR;
netInitAck->latestBetaRevision = POKERTH_BETA_REVISION;
// initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
netInitAck->yourPlayerId = session.playerData->GetUniqueId();
GetSender().Send(session.sessionData, packet);
// Send the game list to the client.
SendGameList(session.sessionData);
@@ -1020,12 +1092,15 @@ ServerLobbyThread::RequestPlayerAvatar(SessionWrapper session)
m_timerAvatarClientAddressMap[session.sessionData->GetClientAddr()] = boost::timers::portable::microsec_timer();
}
// Ask the client to send its avatar.
boost::shared_ptr<NetPacket> retrieveAvatar(new NetPacketRetrieveAvatar);
NetPacketRetrieveAvatar::Data retrieveAvatarData;
retrieveAvatarData.requestId = session.playerData->GetUniqueId();
retrieveAvatarData.avatar = session.playerData->GetAvatarMD5();
static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData);
GetSender().Send(session.sessionData, retrieveAvatar);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_avatarRequestMessage;
AvatarRequestMessage_t *netAvatarRequest = &packet->GetMsg()->choice.avatarRequestMessage;
netAvatarRequest->requestId = session.playerData->GetUniqueId();
OCTET_STRING_fromBuf(
&netAvatarRequest->avatar,
(char *)session.playerData->GetAvatarMD5().data,
MD5_DATA_SIZE);
GetSender().Send(session.sessionData, packet);
}
void
@@ -1236,17 +1311,16 @@ ServerLobbyThread::InternalResubscribeMsg(SessionWrapper session)
session.sessionData->SetWantsLobbyMsg();
SendGameList(session.sessionData);
// Send new statistics information.
boost::shared_ptr<NetPacket> packet(new NetPacketStatisticsChanged);
NetPacketStatisticsChanged::Data statData;
statData.stats.numberOfPlayersOnServer = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
try {
static_cast<NetPacketStatisticsChanged *>(packet.get())->SetData(statData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_statisticsMessage;
StatisticsMessage_t *netStatistics = &packet->GetMsg()->choice.statisticsMessage;
GetSender().Send(session.sessionData, packet);
} catch (const NetException &)
{
// Ignore errors for now.
}
StatisticsData_t *data = (StatisticsData_t *)calloc(1, sizeof(struct StatisticsData));
data->statisticsType = statisticsType_statNumberOfPlayers;
data->statisticsValue = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
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->MarkActivityNotice();
boost::shared_ptr<NetPacket> packet(new NetPacketTimeoutWarning);
NetPacketTimeoutWarning::Data warningData;
warningData.timeoutReason = NETWORK_TIMEOUT_GENERIC;
warningData.remainingSeconds = SERVER_TIMEOUT_WARNING_REMAINING_SEC;
static_cast<NetPacketTimeoutWarning *>(packet.get())->SetData(warningData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_timeoutWarningMessage;
TimeoutWarningMessage_t *netWarning = &packet->GetMsg()->choice.timeoutWarningMessage;
netWarning->timeoutReason = timeoutReason_timeoutNoDataReceived;
netWarning->remainingSeconds = SERVER_TIMEOUT_WARNING_REMAINING_SEC;
GetSender().Send(session.sessionData, packet);
}
else if (session.sessionData->GetActivityTimerElapsedSec() >= SERVER_SESSION_ACTIVITY_TIMEOUT_SEC)
@@ -1324,20 +1399,39 @@ void
ServerLobbyThread::SendError(boost::shared_ptr<SessionData> s, int errorCode)
{
LOG_VERBOSE("Sending error code " << errorCode << " to session #" << s->GetId() << ".");
boost::shared_ptr<NetPacket> packet(new NetPacketError);
NetPacketError::Data errorData;
errorData.errorCode = errorCode;
static_cast<NetPacketError *>(packet.get())->SetData(errorData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_errorMessage;
ErrorMessage_t *netError = &packet->GetMsg()->choice.errorMessage;
netError->errorReason = NetPacket::GameErrorToNetError(errorCode);
GetSender().Send(s, packet);
}
void
ServerLobbyThread::SendJoinGameFailed(boost::shared_ptr<SessionData> s, int reason)
{
boost::shared_ptr<NetPacket> packet(new NetPacketJoinGameFailed);
NetPacketJoinGameFailed::Data failedData;
failedData.failureCode = reason;
static_cast<NetPacketJoinGameFailed *>(packet.get())->SetData(failedData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_joinGameReplyMessage;
JoinGameReplyMessage_t *netJoinReply = &packet->GetMsg()->choice.joinGameReplyMessage;
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);
}
@@ -1377,19 +1471,17 @@ ServerLobbyThread::BroadcastStatisticsUpdate(const ServerStats &stats)
{
if (stats.numberOfPlayersOnServer)
{
boost::shared_ptr<NetPacket> packet(new NetPacketStatisticsChanged);
NetPacketStatisticsChanged::Data statData;
statData.stats = stats;
try {
static_cast<NetPacketStatisticsChanged *>(packet.get())->SetData(statData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_statisticsMessage;
StatisticsMessage_t *netStatistics = &packet->GetMsg()->choice.statisticsMessage;
m_sessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Established);
m_gameSessionManager.SendLobbyMsgToAllSessions(GetSender(), packet, SessionData::Game);
} catch (const NetException &)
{
// Ignore errors for now.
//LOG_ERROR("ServerLobbyThread::BroadcastStatisticsUpdate: " << e.what());
}
StatisticsData_t *data = (StatisticsData_t *)calloc(1, sizeof(struct StatisticsData));
data->statisticsType = statisticsType_statNumberOfPlayers;
data->statisticsValue = m_sessionManager.GetRawSessionCount() + m_gameSessionManager.GetRawSessionCount();
ASN_SEQUENCE_ADD(&netStatistics->statisticsData.list, data);
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>
ServerLobbyThread::CreateNetPacketGameListNew(const ServerGame &game)
{
boost::shared_ptr<NetPacket> packet(new NetPacketGameListNew);
NetPacketGameListNew::Data packetData;
packetData.gameId = game.GetId();
packetData.gameInfo.adminPlayerId = game.GetAdminPlayerId();
packetData.gameInfo.mode = game.IsRunning() ? GAME_MODE_STARTED : GAME_MODE_CREATED;
packetData.gameInfo.name = game.GetName();
packetData.gameInfo.data = game.GetGameData();
packetData.gameInfo.players = game.GetPlayerIdList();
packetData.gameInfo.isPasswordProtected = game.IsPasswordProtected();
static_cast<NetPacketGameListNew *>(packet.get())->SetData(packetData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
GameListMessage_t *netGameList = &packet->GetMsg()->choice.gameListMessage;
netGameList->gameId = game.GetId();
netGameList->gameListNotification.present = gameListNotification_PR_gameListNew;
GameListNew_t *gameNew = &netGameList->gameListNotification.choice.gameListNew;
gameNew->adminPlayerId = game.GetAdminPlayerId();
gameNew->gameMode = game.IsRunning() ? NetGameMode_gameStarted : NetGameMode_gameCreated;
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;
}
boost::shared_ptr<NetPacket>
ServerLobbyThread::CreateNetPacketGameListUpdate(unsigned gameId, GameMode mode)
{
boost::shared_ptr<NetPacket> packet(new NetPacketGameListUpdate);
NetPacketGameListUpdate::Data packetData;
packetData.gameId = gameId;
packetData.gameMode = mode;
static_cast<NetPacketGameListUpdate *>(packet.get())->SetData(packetData);
boost::shared_ptr<NetPacket> packet(new NetPacket(NetPacket::Alloc));
packet->GetMsg()->present = PokerTHMessage_PR_gameListMessage;
GameListMessage_t *netGameList = &packet->GetMsg()->choice.gameListMessage;
netGameList->gameId = gameId;
netGameList->gameListNotification.present = gameListNotification_PR_gameListUpdate;
GameListUpdate_t *gameUpdate = &netGameList->gameListNotification.choice.gameListUpdate;
gameUpdate->gameMode = mode;
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.
if (i->second.sessionData->GetState() == state)
sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
sender.Send(i->second.sessionData, packet);
++i;
}
}
@@ -327,7 +327,7 @@ SessionManager::SendLobbyMsgToAllSessions(SenderHelper &sender, boost::shared_pt
// Send each client (with a certain state) a copy of the packet.
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;
}
}
@@ -345,7 +345,7 @@ SessionManager::SendToAllButOneSessions(SenderHelper &sender, boost::shared_ptr<
// Send each fully connected client but one a copy of the packet.
if (i->second.sessionData->GetState() == state)
if (i->first != except)
sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
sender.Send(i->second.sessionData, packet);
++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);
protected:
void InternalStorePacket(SendDataManager &tmpManager, boost::shared_ptr<NetPacket> packet);
typedef std::map<SessionId, boost::shared_ptr<SendDataManager> > SendQueueMap;
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);
static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(const PlayerData &playerData);
static boost::shared_ptr<NetPacket> CreateNetPacketPlayerJoined(unsigned gameId, const PlayerData &playerData);
private:
static ServerGameStateInit s_state;
src/net/serverlobbythread.h
+11 -11
View File
@@ -67,8 +67,8 @@ public:
void NotifyStartingGame(unsigned gameId);
void NotifyReopeningGame(unsigned gameId);
void HandleGameRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket);
void HandleGameRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket);
void HandleGameRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest);
void HandleGameRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar);
bool KickPlayerByName(const std::string &playerName);
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 HandlePacket(SessionWrapper session, boost::shared_ptr<NetPacket> packet);
void HandleNetPacketInit(SessionWrapper session, const NetPacketInit &tmpPacket);
void HandleNetPacketAvatarHeader(SessionWrapper session, const NetPacketAvatarHeader &tmpPacket);
void HandleNetPacketUnknownAvatar(SessionWrapper session, const NetPacketUnknownAvatar &tmpPacket);
void HandleNetPacketAvatarFile(SessionWrapper session, const NetPacketAvatarFile &tmpPacket);
void HandleNetPacketAvatarEnd(SessionWrapper session, const NetPacketAvatarEnd &tmpPacket);
void HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const NetPacketRetrievePlayerInfo &tmpPacket);
void HandleNetPacketRetrieveAvatar(SessionWrapper session, const NetPacketRetrieveAvatar &tmpPacket);
void HandleNetPacketCreateGame(SessionWrapper session, const NetPacketCreateGame &tmpPacket);
void HandleNetPacketJoinGame(SessionWrapper session, const NetPacketJoinGame &tmpPacket);
void HandleNetPacketInit(SessionWrapper session, const InitMessage_t &initMessage);
void HandleNetPacketAvatarHeader(SessionWrapper session, unsigned requestId, const AvatarHeader_t &avatarHeader);
void HandleNetPacketUnknownAvatar(SessionWrapper session, unsigned requestId, const UnknownAvatar_t &unknownAvatar);
void HandleNetPacketAvatarFile(SessionWrapper session, unsigned requestId, const AvatarData_t &avatarData);
void HandleNetPacketAvatarEnd(SessionWrapper session, unsigned requestId, const AvatarEnd_t &avatarEnd);
void HandleNetPacketRetrievePlayerInfo(SessionWrapper session, const PlayerInfoRequestMessage_t &playerInfoRequest);
void HandleNetPacketRetrieveAvatar(SessionWrapper session, const AvatarRequestMessage_t &retrieveAvatar);
void HandleNetPacketCreateGame(SessionWrapper session, const std::string &password, const JoinNewGame_t &newGame);
void HandleNetPacketJoinGame(SessionWrapper session, const std::string &password, const JoinExistingGame_t &joinGame);
void EstablishSession(SessionWrapper session);
void RequestPlayerAvatar(SessionWrapper session);
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
// Notifications - join failed
#define NTF_NET_JOIN_GAME_FULL 210
#define NTF_NET_JOIN_ALREADY_RUNNING 211
#define NTF_NET_JOIN_INVALID_PASSWORD 212
#define NTF_NET_JOIN_GAME_INVALID 210
#define NTF_NET_JOIN_GAME_FULL 211
#define NTF_NET_JOIN_ALREADY_RUNNING 212
#define NTF_NET_JOIN_INVALID_PASSWORD 213
// Notifications - version
#define NTF_NET_NEW_RELEASE_AVAILABLE 220