diff --git a/pokerth.proto b/pokerth.proto index 2fda5a68..4795a198 100644 --- a/pokerth.proto +++ b/pokerth.proto @@ -451,6 +451,17 @@ message GameStartRejoinMessage { repeated RejoinPlayerData rejoinPlayerData = 4; } +message GameStartReentryMessage { + required uint32 gameId = 1; + required uint32 startDealerPlayerId = 2; + required uint32 handNum = 3; + message ReentryPlayerData { + required uint32 playerId = 1; + required uint32 playerMoney = 2; + } + repeated ReentryPlayerData reentryPlayerData = 4; +} + message HandStartMessage { required uint32 gameId = 1; message PlainCards { @@ -841,6 +852,7 @@ message PokerTHMessage { Type_GameListSpectatorLeftMessage = 79; Type_GameSpectatorJoinedMessage = 80; Type_GameSpectatorLeftMessage = 81; + Type_GameStartReentryMessage = 82; } required PokerTHMessageType messageType = 1; @@ -925,4 +937,5 @@ message PokerTHMessage { optional GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 80; optional GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 81; optional GameSpectatorLeftMessage gameSpectatorLeftMessage = 82; + optional GameStartReentryMessage gameStartReentryMessage = 83; } diff --git a/src/engine/local_engine/localhand.cpp b/src/engine/local_engine/localhand.cpp index f2f8af5f..0a62ae5d 100755 --- a/src/engine/local_engine/localhand.cpp +++ b/src/engine/local_engine/localhand.cpp @@ -66,7 +66,12 @@ LocalHand::LocalHand(boost::shared_ptr f, GuiInterface *g, boost: 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 }; + + // Shuffle three times Tools::ShuffleArrayNonDeterministic(cardsArray, NumCards); + Tools::ShuffleArrayNonDeterministic(cardsArray, NumCards); + Tools::ShuffleArrayNonDeterministic(cardsArray, NumCards); + int tempBoardArray[5]; int tempPlayerArray[2]; int tempPlayerAndBoardArray[7]; diff --git a/src/net/common/netpacketvalidator.cpp b/src/net/common/netpacketvalidator.cpp index 5eb51849..c9232120 100644 --- a/src/net/common/netpacketvalidator.cpp +++ b/src/net/common/netpacketvalidator.cpp @@ -94,6 +94,7 @@ NetPacketValidator::NetPacketValidator() m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_StartEventAckMessage, ValidateStartEventAckMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_GameStartInitialMessage, ValidateGameStartInitialMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_GameStartRejoinMessage, ValidateGameStartRejoinMessage)); + m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_GameStartReentryMessage, ValidateGameStartReentryMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_HandStartMessage, ValidateHandStartMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_PlayersTurnMessage, ValidatePlayersTurnMessage)); m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_MyActionRequestMessage, ValidateMyActionRequestMessage)); @@ -695,6 +696,22 @@ NetPacketValidator::ValidateGameStartRejoinMessage(const NetPacket &packet) return retVal; } +bool +NetPacketValidator::ValidateGameStartReentryMessage(const NetPacket &packet) +{ + bool retVal = false; + if (packet.GetMsg()->has_gamestartreentrymessage()) { + const GameStartReentryMessage &msg = packet.GetMsg()->gamestartreentrymessage(); + if (msg.gameid() != 0 + && msg.startdealerplayerid() != 0 + && msg.handnum() != 0 + && VALIDATE_LIST_SIZE(msg.reentryplayerdata(), 2, 10)) { + + retVal = true; + } + } + return retVal; +} bool NetPacketValidator::ValidateHandStartMessage(const NetPacket &packet) { diff --git a/src/net/common/servergamestate.cpp b/src/net/common/servergamestate.cpp index 30823013..f50fb6c3 100644 --- a/src/net/common/servergamestate.cpp +++ b/src/net/common/servergamestate.cpp @@ -962,7 +962,7 @@ AbstractServerGameStateRunning::HandleNewPlayer(boost::shared_ptr se else if (session && session->GetPlayerData() && server->admitReentries(session->GetPlayerData())) { const GameData tmpGameData = server->GetGameData(); - if (server->GetCurNumberOfPlayers() + server->GetNumberPlayersReentry() < tmpGameData.maxNumberOfPlayers) { // there is a seat available + if (server->GetCurNumberOfPlayers() + static_cast(server->GetNumberPlayersReentry()) < tmpGameData.maxNumberOfPlayers) { // there is a seat available @@ -1680,19 +1680,91 @@ ServerGameStateHand::PerformReentry(boost::shared_ptr server, boost: // check if player already played this game boost::shared_ptr tmpPlayer = curGame.getPlayerByName(session->GetPlayerData()->GetName()); if (!tmpPlayer) { - tmpPlayer = curGame.addNewPlayer(session->GetPlayerData()); // TODO (albmed): Create addNewPlayer method + + // TODO: Late registration implementation is postponed + + throw ServerException(__FILE__, __LINE__, ERR_NET_INTERNAL_GAME_ERROR, 0); + // tmpPlayer = curGame.addNewPlayer(session->GetPlayerData()); // TODO (albmed): Create addNewPlayer method + } + else { + // This means this is a reentry, because player already played this game + + // check for id change + if (session->GetPlayerData()->GetUniqueId() != tmpPlayer->getMyUniqueID()) { + // Notify other clients about id change. + boost::shared_ptr packet(new NetPacket); + packet->GetMsg()->set_messagetype(PokerTHMessage::Type_PlayerIdChangedMessage); + PlayerIdChangedMessage *netIdChanged = packet->GetMsg()->mutable_playeridchangedmessage(); + netIdChanged->set_oldplayerid(tmpPlayer->getMyUniqueID()); + netIdChanged->set_newplayerid(session->GetPlayerData()->GetUniqueId()); + server->SendToAllButOnePlayers(packet, session->GetId(), SessionData::Game | SessionData::Spectating | SessionData::SpectatorWaiting); + + // Update the dealer, if necessary. + curGame.replaceDealer(tmpPlayer->getMyUniqueID(), session->GetPlayerData()->GetUniqueId()); + + // Update the ranking map. + server->ReplaceRankingPlayer(tmpPlayer->getMyUniqueID(), session->GetPlayerData()->GetUniqueId()); + // Change the Id in the poker engine. + tmpPlayer->setMyUniqueID(session->GetPlayerData()->GetUniqueId()); + tmpPlayer->setMyGuid(session->GetPlayerData()->GetGuid()); + } + + tmpPlayer->markRemoteAction(); + tmpPlayer->setIsSessionActive(true); + SendGameDataReentry(server, session); // TODO (albmed): This method should be duplicated + // - to send starting game cash: server->GetGameData().startMoney + // - to make a new reentry message + } - int seat = getRandomFreeSeat(curGame.getActivePlayerList()); +/* int seat = GetRandomFreeSeat(curGame.getActivePlayerList()); // (albmed): if reentry, assign same seat or find a new one? if (seat >= 0) { // ok // seat found.... + + // is between dealer? TODO (albmed) + unsigned dealerPosition = curGame.getDealerPosition(); + + } - else throw ServerException(__FILE__, __LINE__, ERR_NET_INTERNAL_GAME_ERROR, 0); + else throw ServerException(__FILE__, __LINE__, ERR_NET_INTERNAL_GAME_ERROR, 0); */ + + + + } } +int +ServerGameStateHand::GetRandomFreeSeat(const PlayerList playerList) { + + // seek for a free seat + PlayerListConstIterator player_i = playerList->begin(); + PlayerListConstIterator player_end = playerList->end(); + + std::vector v(10, 0); + while (player_i != player_end) { + v[(*player_i)->getMyID()] = 1; // mark seats with player + ++player_i; + } + + // random seats + random_shuffle(v.begin(), v.end()); + + int seat = -1; + // seeks first free seat + for(std::vector::size_type i = 0; i != v.size(); i++) { + if (v[i] == 0) { + seat = i; + break; + } + } + + return seat; +} + + void ServerGameStateHand::SendGameData(boost::shared_ptr server, boost::shared_ptr session) { @@ -1719,6 +1791,33 @@ ServerGameStateHand::SendGameData(boost::shared_ptr server, boost::s server->GetLobbyThread().GetSender().Send(session, packet); } +void +ServerGameStateHand::SendGameDataReentry(boost::shared_ptr server, boost::shared_ptr session) +{ + Game &curGame = server->GetGame(); + // Send game start notification to reentry client. + boost::shared_ptr packet(new NetPacket); + packet->GetMsg()->set_messagetype(PokerTHMessage::Type_GameStartReentryMessage); + GameStartReentryMessage *netGameStart = packet->GetMsg()->mutable_gamestartreentrymessage(); + netGameStart->set_gameid(server->GetId()); + netGameStart->set_startdealerplayerid(curGame.getDealerPosition()); + netGameStart->set_handnum(curGame.getCurrentHandID()); + PlayerListIterator player_i = curGame.getSeatsList()->begin(); + PlayerListIterator player_end = curGame.getSeatsList()->end(); + int player_count = 0; + while (player_i != player_end && player_count < server->GetStartData().numberOfPlayers) { + boost::shared_ptr tmpPlayer = *player_i; + GameStartReentryMessage::ReentryPlayerData *playerSlot = netGameStart->add_reentryplayerdata(); + playerSlot->set_playerid(tmpPlayer->getMyUniqueID()); + playerSlot->set_playermoney(server->GetGameData().startMoney); + ++player_i; + ++player_count; + } + + server->GetLobbyThread().GetSender().Send(session, packet); + +} + //----------------------------------------------------------------------------- diff --git a/src/net/netpacketvalidator.h b/src/net/netpacketvalidator.h index f6afaaaa..970845d1 100644 --- a/src/net/netpacketvalidator.h +++ b/src/net/netpacketvalidator.h @@ -85,6 +85,7 @@ protected: static bool ValidateStartEventAckMessage(const NetPacket &packet); static bool ValidateGameStartInitialMessage(const NetPacket &packet); static bool ValidateGameStartRejoinMessage(const NetPacket &packet); + static bool ValidateGameStartReentryMessage(const NetPacket &packet); static bool ValidateHandStartMessage(const NetPacket &packet); static bool ValidatePlayersTurnMessage(const NetPacket &packet); static bool ValidateMyActionRequestMessage(const NetPacket &packet); diff --git a/src/net/servergame.h b/src/net/servergame.h index 7d916310..cc47b2a7 100644 --- a/src/net/servergame.h +++ b/src/net/servergame.h @@ -113,7 +113,7 @@ public: void AddReentryPlayer(unsigned playerId); PlayerIdList GetAndResetReentryPlayers(); - int GetNumberPlayersReentry(); + unsigned GetNumberPlayersReentry(); void AddReactivatePlayer(unsigned playerId); PlayerIdList GetAndResetReactivatePlayers(); diff --git a/src/net/servergamestate.h b/src/net/servergamestate.h index e7db339d..f0b924af 100644 --- a/src/net/servergamestate.h +++ b/src/net/servergamestate.h @@ -36,6 +36,7 @@ #include #include #include +#include #ifdef _MSC_VER @@ -197,6 +198,8 @@ protected: static void PerformRejoin(boost::shared_ptr server, boost::shared_ptr session); static void PerformReentry(boost::shared_ptr server, boost::shared_ptr session); static void SendGameData(boost::shared_ptr server, boost::shared_ptr session); + static void SendGameDataReentry(boost::shared_ptr server, boost::shared_ptr session); + static int GetRandomFreeSeat(const PlayerList playerList); private: static ServerGameStateHand s_state; diff --git a/src/third_party/protobuf/pokerth.pb.cc b/src/third_party/protobuf/pokerth.pb.cc index 4e64f6e5..87afe1f8 100644 --- a/src/third_party/protobuf/pokerth.pb.cc +++ b/src/third_party/protobuf/pokerth.pb.cc @@ -62,6 +62,8 @@ void protobuf_ShutdownFile_pokerth_2eproto() { delete GameStartInitialMessage::default_instance_; delete GameStartRejoinMessage::default_instance_; delete GameStartRejoinMessage_RejoinPlayerData::default_instance_; + delete GameStartReentryMessage::default_instance_; + delete GameStartReentryMessage_ReentryPlayerData::default_instance_; delete HandStartMessage::default_instance_; delete HandStartMessage_PlainCards::default_instance_; delete PlayersTurnMessage::default_instance_; @@ -167,6 +169,8 @@ void protobuf_AddDesc_pokerth_2eproto() { GameStartInitialMessage::default_instance_ = new GameStartInitialMessage(); GameStartRejoinMessage::default_instance_ = new GameStartRejoinMessage(); GameStartRejoinMessage_RejoinPlayerData::default_instance_ = new GameStartRejoinMessage_RejoinPlayerData(); + GameStartReentryMessage::default_instance_ = new GameStartReentryMessage(); + GameStartReentryMessage_ReentryPlayerData::default_instance_ = new GameStartReentryMessage_ReentryPlayerData(); HandStartMessage::default_instance_ = new HandStartMessage(); HandStartMessage_PlainCards::default_instance_ = new HandStartMessage_PlainCards(); PlayersTurnMessage::default_instance_ = new PlayersTurnMessage(); @@ -258,6 +262,8 @@ void protobuf_AddDesc_pokerth_2eproto() { GameStartInitialMessage::default_instance_->InitAsDefaultInstance(); GameStartRejoinMessage::default_instance_->InitAsDefaultInstance(); GameStartRejoinMessage_RejoinPlayerData::default_instance_->InitAsDefaultInstance(); + GameStartReentryMessage::default_instance_->InitAsDefaultInstance(); + GameStartReentryMessage_ReentryPlayerData::default_instance_->InitAsDefaultInstance(); HandStartMessage::default_instance_->InitAsDefaultInstance(); HandStartMessage_PlainCards::default_instance_->InitAsDefaultInstance(); PlayersTurnMessage::default_instance_->InitAsDefaultInstance(); @@ -11414,6 +11420,7 @@ bool StartEventMessage_StartEventType_IsValid(int value) { switch(value) { case 0: case 1: + case 2: return true; default: return false; @@ -11423,6 +11430,7 @@ bool StartEventMessage_StartEventType_IsValid(int value) { #ifndef _MSC_VER const StartEventMessage_StartEventType StartEventMessage::startEvent; const StartEventMessage_StartEventType StartEventMessage::rejoinEvent; +const StartEventMessage_StartEventType StartEventMessage::reentryEvent; const StartEventMessage_StartEventType StartEventMessage::StartEventType_MIN; const StartEventMessage_StartEventType StartEventMessage::StartEventType_MAX; const int StartEventMessage::StartEventType_ARRAYSIZE; @@ -12564,6 +12572,483 @@ void GameStartRejoinMessage::Swap(GameStartRejoinMessage* other) { } +// =================================================================== + +#ifndef _MSC_VER +const int GameStartReentryMessage_ReentryPlayerData::kPlayerIdFieldNumber; +const int GameStartReentryMessage_ReentryPlayerData::kPlayerMoneyFieldNumber; +#endif // !_MSC_VER + +GameStartReentryMessage_ReentryPlayerData::GameStartReentryMessage_ReentryPlayerData() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void GameStartReentryMessage_ReentryPlayerData::InitAsDefaultInstance() { +} + +GameStartReentryMessage_ReentryPlayerData::GameStartReentryMessage_ReentryPlayerData(const GameStartReentryMessage_ReentryPlayerData& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void GameStartReentryMessage_ReentryPlayerData::SharedCtor() { + _cached_size_ = 0; + playerid_ = 0u; + playermoney_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameStartReentryMessage_ReentryPlayerData::~GameStartReentryMessage_ReentryPlayerData() { + SharedDtor(); +} + +void GameStartReentryMessage_ReentryPlayerData::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void GameStartReentryMessage_ReentryPlayerData::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const GameStartReentryMessage_ReentryPlayerData& GameStartReentryMessage_ReentryPlayerData::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_pokerth_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto(); +#endif + return *default_instance_; +} + +GameStartReentryMessage_ReentryPlayerData* GameStartReentryMessage_ReentryPlayerData::default_instance_ = NULL; + +GameStartReentryMessage_ReentryPlayerData* GameStartReentryMessage_ReentryPlayerData::New() const { + return new GameStartReentryMessage_ReentryPlayerData; +} + +void GameStartReentryMessage_ReentryPlayerData::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + playerid_ = 0u; + playermoney_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool GameStartReentryMessage_ReentryPlayerData::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required uint32 playerId = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &playerid_))); + set_has_playerid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_playerMoney; + break; + } + + // required uint32 playerMoney = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_playerMoney: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &playermoney_))); + set_has_playermoney(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void GameStartReentryMessage_ReentryPlayerData::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required uint32 playerId = 1; + if (has_playerid()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output); + } + + // required uint32 playerMoney = 2; + if (has_playermoney()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playermoney(), output); + } + +} + +int GameStartReentryMessage_ReentryPlayerData::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 playerId = 1; + if (has_playerid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->playerid()); + } + + // required uint32 playerMoney = 2; + if (has_playermoney()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->playermoney()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GameStartReentryMessage_ReentryPlayerData::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void GameStartReentryMessage_ReentryPlayerData::MergeFrom(const GameStartReentryMessage_ReentryPlayerData& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_playerid()) { + set_playerid(from.playerid()); + } + if (from.has_playermoney()) { + set_playermoney(from.playermoney()); + } + } +} + +void GameStartReentryMessage_ReentryPlayerData::CopyFrom(const GameStartReentryMessage_ReentryPlayerData& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameStartReentryMessage_ReentryPlayerData::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void GameStartReentryMessage_ReentryPlayerData::Swap(GameStartReentryMessage_ReentryPlayerData* other) { + if (other != this) { + std::swap(playerid_, other->playerid_); + std::swap(playermoney_, other->playermoney_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string GameStartReentryMessage_ReentryPlayerData::GetTypeName() const { + return "GameStartReentryMessage.ReentryPlayerData"; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int GameStartReentryMessage::kGameIdFieldNumber; +const int GameStartReentryMessage::kStartDealerPlayerIdFieldNumber; +const int GameStartReentryMessage::kHandNumFieldNumber; +const int GameStartReentryMessage::kReentryPlayerDataFieldNumber; +#endif // !_MSC_VER + +GameStartReentryMessage::GameStartReentryMessage() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void GameStartReentryMessage::InitAsDefaultInstance() { +} + +GameStartReentryMessage::GameStartReentryMessage(const GameStartReentryMessage& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void GameStartReentryMessage::SharedCtor() { + _cached_size_ = 0; + gameid_ = 0u; + startdealerplayerid_ = 0u; + handnum_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GameStartReentryMessage::~GameStartReentryMessage() { + SharedDtor(); +} + +void GameStartReentryMessage::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void GameStartReentryMessage::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const GameStartReentryMessage& GameStartReentryMessage::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_pokerth_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto(); +#endif + return *default_instance_; +} + +GameStartReentryMessage* GameStartReentryMessage::default_instance_ = NULL; + +GameStartReentryMessage* GameStartReentryMessage::New() const { + return new GameStartReentryMessage; +} + +void GameStartReentryMessage::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + gameid_ = 0u; + startdealerplayerid_ = 0u; + handnum_ = 0u; + } + reentryplayerdata_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool GameStartReentryMessage::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required uint32 gameId = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &gameid_))); + set_has_gameid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_startDealerPlayerId; + break; + } + + // required uint32 startDealerPlayerId = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_startDealerPlayerId: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &startdealerplayerid_))); + set_has_startdealerplayerid(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_handNum; + break; + } + + // required uint32 handNum = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_handNum: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &handnum_))); + set_has_handnum(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_reentryPlayerData; + break; + } + + // repeated .GameStartReentryMessage.ReentryPlayerData reentryPlayerData = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_reentryPlayerData: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_reentryplayerdata())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_reentryPlayerData; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void GameStartReentryMessage::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required uint32 gameId = 1; + if (has_gameid()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output); + } + + // required uint32 startDealerPlayerId = 2; + if (has_startdealerplayerid()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->startdealerplayerid(), output); + } + + // required uint32 handNum = 3; + if (has_handnum()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->handnum(), output); + } + + // repeated .GameStartReentryMessage.ReentryPlayerData reentryPlayerData = 4; + for (int i = 0; i < this->reentryplayerdata_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->reentryplayerdata(i), output); + } + +} + +int GameStartReentryMessage::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 gameId = 1; + if (has_gameid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->gameid()); + } + + // required uint32 startDealerPlayerId = 2; + if (has_startdealerplayerid()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->startdealerplayerid()); + } + + // required uint32 handNum = 3; + if (has_handnum()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->handnum()); + } + + } + // repeated .GameStartReentryMessage.ReentryPlayerData reentryPlayerData = 4; + total_size += 1 * this->reentryplayerdata_size(); + for (int i = 0; i < this->reentryplayerdata_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->reentryplayerdata(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GameStartReentryMessage::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void GameStartReentryMessage::MergeFrom(const GameStartReentryMessage& from) { + GOOGLE_CHECK_NE(&from, this); + reentryplayerdata_.MergeFrom(from.reentryplayerdata_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_gameid()) { + set_gameid(from.gameid()); + } + if (from.has_startdealerplayerid()) { + set_startdealerplayerid(from.startdealerplayerid()); + } + if (from.has_handnum()) { + set_handnum(from.handnum()); + } + } +} + +void GameStartReentryMessage::CopyFrom(const GameStartReentryMessage& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GameStartReentryMessage::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + for (int i = 0; i < reentryplayerdata_size(); i++) { + if (!this->reentryplayerdata(i).IsInitialized()) return false; + } + return true; +} + +void GameStartReentryMessage::Swap(GameStartReentryMessage* other) { + if (other != this) { + std::swap(gameid_, other->gameid_); + std::swap(startdealerplayerid_, other->startdealerplayerid_); + std::swap(handnum_, other->handnum_); + reentryplayerdata_.Swap(&other->reentryplayerdata_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string GameStartReentryMessage::GetTypeName() const { + return "GameStartReentryMessage"; +} + + // =================================================================== #ifndef _MSC_VER @@ -22273,6 +22758,7 @@ bool PokerTHMessage_PokerTHMessageType_IsValid(int value) { case 79: case 80: case 81: + case 82: return true; default: return false; @@ -22361,6 +22847,7 @@ const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListSpectatorJo const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListSpectatorLeftMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameSpectatorJoinedMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameSpectatorLeftMessage; +const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameStartReentryMessage; const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MIN; const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MAX; const int PokerTHMessage::PokerTHMessageType_ARRAYSIZE; @@ -22448,6 +22935,7 @@ const int PokerTHMessage::kGameListSpectatorJoinedMessageFieldNumber; const int PokerTHMessage::kGameListSpectatorLeftMessageFieldNumber; const int PokerTHMessage::kGameSpectatorJoinedMessageFieldNumber; const int PokerTHMessage::kGameSpectatorLeftMessageFieldNumber; +const int PokerTHMessage::kGameStartReentryMessageFieldNumber; #endif // !_MSC_VER PokerTHMessage::PokerTHMessage() @@ -22942,6 +23430,12 @@ void PokerTHMessage::InitAsDefaultInstance() { #else gamespectatorleftmessage_ = const_cast< ::GameSpectatorLeftMessage*>(&::GameSpectatorLeftMessage::default_instance()); #endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + gamestartreentrymessage_ = const_cast< ::GameStartReentryMessage*>( + ::GameStartReentryMessage::internal_default_instance()); +#else + gamestartreentrymessage_ = const_cast< ::GameStartReentryMessage*>(&::GameStartReentryMessage::default_instance()); +#endif } PokerTHMessage::PokerTHMessage(const PokerTHMessage& from) @@ -23034,6 +23528,7 @@ void PokerTHMessage::SharedCtor() { gamelistspectatorleftmessage_ = NULL; gamespectatorjoinedmessage_ = NULL; gamespectatorleftmessage_ = NULL; + gamestartreentrymessage_ = NULL; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -23128,6 +23623,7 @@ void PokerTHMessage::SharedDtor() { delete gamelistspectatorleftmessage_; delete gamespectatorjoinedmessage_; delete gamespectatorleftmessage_; + delete gamestartreentrymessage_; } } @@ -23417,6 +23913,9 @@ void PokerTHMessage::Clear() { if (has_gamespectatorleftmessage()) { if (gamespectatorleftmessage_ != NULL) gamespectatorleftmessage_->::GameSpectatorLeftMessage::Clear(); } + if (has_gamestartreentrymessage()) { + if (gamestartreentrymessage_ != NULL) gamestartreentrymessage_->::GameStartReentryMessage::Clear(); + } } ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -24575,6 +25074,20 @@ bool PokerTHMessage::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } + if (input->ExpectTag(666)) goto parse_gameStartReentryMessage; + break; + } + + // optional .GameStartReentryMessage gameStartReentryMessage = 83; + case 83: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_gameStartReentryMessage: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_gamestartreentrymessage())); + } else { + goto handle_uninterpreted; + } if (input->ExpectAtEnd()) return true; break; } @@ -25088,6 +25601,12 @@ void PokerTHMessage::SerializeWithCachedSizes( 82, this->gamespectatorleftmessage(), output); } + // optional .GameStartReentryMessage gameStartReentryMessage = 83; + if (has_gamestartreentrymessage()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 83, this->gamestartreentrymessage(), output); + } + } int PokerTHMessage::ByteSize() const { @@ -25687,6 +26206,13 @@ int PokerTHMessage::ByteSize() const { this->gamespectatorleftmessage()); } + // optional .GameStartReentryMessage gameStartReentryMessage = 83; + if (has_gamestartreentrymessage()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->gamestartreentrymessage()); + } + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -25968,6 +26494,9 @@ void PokerTHMessage::MergeFrom(const PokerTHMessage& from) { if (from.has_gamespectatorleftmessage()) { mutable_gamespectatorleftmessage()->::GameSpectatorLeftMessage::MergeFrom(from.gamespectatorleftmessage()); } + if (from.has_gamestartreentrymessage()) { + mutable_gamestartreentrymessage()->::GameStartReentryMessage::MergeFrom(from.gamestartreentrymessage()); + } } } @@ -26214,6 +26743,9 @@ bool PokerTHMessage::IsInitialized() const { if (has_gamespectatorleftmessage()) { if (!this->gamespectatorleftmessage().IsInitialized()) return false; } + if (has_gamestartreentrymessage()) { + if (!this->gamestartreentrymessage().IsInitialized()) return false; + } return true; } @@ -26301,6 +26833,7 @@ void PokerTHMessage::Swap(PokerTHMessage* other) { std::swap(gamelistspectatorleftmessage_, other->gamelistspectatorleftmessage_); std::swap(gamespectatorjoinedmessage_, other->gamespectatorjoinedmessage_); std::swap(gamespectatorleftmessage_, other->gamespectatorleftmessage_); + std::swap(gamestartreentrymessage_, other->gamestartreentrymessage_); std::swap(_has_bits_[0], other->_has_bits_[0]); std::swap(_has_bits_[1], other->_has_bits_[1]); std::swap(_has_bits_[2], other->_has_bits_[2]); diff --git a/src/third_party/protobuf/pokerth.pb.h b/src/third_party/protobuf/pokerth.pb.h index 3c23ad53..9d375689 100644 --- a/src/third_party/protobuf/pokerth.pb.h +++ b/src/third_party/protobuf/pokerth.pb.h @@ -79,6 +79,8 @@ class StartEventAckMessage; class GameStartInitialMessage; class GameStartRejoinMessage; class GameStartRejoinMessage_RejoinPlayerData; +class GameStartReentryMessage; +class GameStartReentryMessage_ReentryPlayerData; class HandStartMessage; class HandStartMessage_PlainCards; class PlayersTurnMessage; @@ -244,11 +246,12 @@ const int RejectGameInvitationMessage_RejectGameInvReason_RejectGameInvReason_AR enum StartEventMessage_StartEventType { StartEventMessage_StartEventType_startEvent = 0, - StartEventMessage_StartEventType_rejoinEvent = 1 + StartEventMessage_StartEventType_rejoinEvent = 1, + StartEventMessage_StartEventType_reentryEvent = 2 }; bool StartEventMessage_StartEventType_IsValid(int value); const StartEventMessage_StartEventType StartEventMessage_StartEventType_StartEventType_MIN = StartEventMessage_StartEventType_startEvent; -const StartEventMessage_StartEventType StartEventMessage_StartEventType_StartEventType_MAX = StartEventMessage_StartEventType_rejoinEvent; +const StartEventMessage_StartEventType StartEventMessage_StartEventType_StartEventType_MAX = StartEventMessage_StartEventType_reentryEvent; const int StartEventMessage_StartEventType_StartEventType_ARRAYSIZE = StartEventMessage_StartEventType_StartEventType_MAX + 1; enum YourActionRejectedMessage_RejectionReason { @@ -468,11 +471,12 @@ enum PokerTHMessage_PokerTHMessageType { PokerTHMessage_PokerTHMessageType_Type_GameListSpectatorJoinedMessage = 78, PokerTHMessage_PokerTHMessageType_Type_GameListSpectatorLeftMessage = 79, PokerTHMessage_PokerTHMessageType_Type_GameSpectatorJoinedMessage = 80, - PokerTHMessage_PokerTHMessageType_Type_GameSpectatorLeftMessage = 81 + PokerTHMessage_PokerTHMessageType_Type_GameSpectatorLeftMessage = 81, + PokerTHMessage_PokerTHMessageType_Type_GameStartReentryMessage = 82 }; bool PokerTHMessage_PokerTHMessageType_IsValid(int value); const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MIN = PokerTHMessage_PokerTHMessageType_Type_AnnounceMessage; -const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX = PokerTHMessage_PokerTHMessageType_Type_GameSpectatorLeftMessage; +const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX = PokerTHMessage_PokerTHMessageType_Type_GameStartReentryMessage; const int PokerTHMessage_PokerTHMessageType_PokerTHMessageType_ARRAYSIZE = PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX + 1; enum NetGameMode { @@ -5426,6 +5430,7 @@ class StartEventMessage : public ::google::protobuf::MessageLite { typedef StartEventMessage_StartEventType StartEventType; static const StartEventType startEvent = StartEventMessage_StartEventType_startEvent; static const StartEventType rejoinEvent = StartEventMessage_StartEventType_rejoinEvent; + static const StartEventType reentryEvent = StartEventMessage_StartEventType_reentryEvent; static inline bool StartEventType_IsValid(int value) { return StartEventMessage_StartEventType_IsValid(value); } @@ -5889,6 +5894,217 @@ class GameStartRejoinMessage : public ::google::protobuf::MessageLite { }; // ------------------------------------------------------------------- +class GameStartReentryMessage_ReentryPlayerData : public ::google::protobuf::MessageLite { + public: + GameStartReentryMessage_ReentryPlayerData(); + virtual ~GameStartReentryMessage_ReentryPlayerData(); + + GameStartReentryMessage_ReentryPlayerData(const GameStartReentryMessage_ReentryPlayerData& from); + + inline GameStartReentryMessage_ReentryPlayerData& operator=(const GameStartReentryMessage_ReentryPlayerData& from) { + CopyFrom(from); + return *this; + } + + static const GameStartReentryMessage_ReentryPlayerData& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const GameStartReentryMessage_ReentryPlayerData* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(GameStartReentryMessage_ReentryPlayerData* other); + + // implements Message ---------------------------------------------- + + GameStartReentryMessage_ReentryPlayerData* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const GameStartReentryMessage_ReentryPlayerData& from); + void MergeFrom(const GameStartReentryMessage_ReentryPlayerData& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 playerId = 1; + inline bool has_playerid() const; + inline void clear_playerid(); + static const int kPlayerIdFieldNumber = 1; + inline ::google::protobuf::uint32 playerid() const; + inline void set_playerid(::google::protobuf::uint32 value); + + // required uint32 playerMoney = 2; + inline bool has_playermoney() const; + inline void clear_playermoney(); + static const int kPlayerMoneyFieldNumber = 2; + inline ::google::protobuf::uint32 playermoney() const; + inline void set_playermoney(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:GameStartReentryMessage.ReentryPlayerData) + private: + inline void set_has_playerid(); + inline void clear_has_playerid(); + inline void set_has_playermoney(); + inline void clear_has_playermoney(); + + ::google::protobuf::uint32 playerid_; + ::google::protobuf::uint32 playermoney_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_pokerth_2eproto_impl(); + #else + friend void protobuf_AddDesc_pokerth_2eproto(); + #endif + friend void protobuf_AssignDesc_pokerth_2eproto(); + friend void protobuf_ShutdownFile_pokerth_2eproto(); + + void InitAsDefaultInstance(); + static GameStartReentryMessage_ReentryPlayerData* default_instance_; +}; +// ------------------------------------------------------------------- + +class GameStartReentryMessage : public ::google::protobuf::MessageLite { + public: + GameStartReentryMessage(); + virtual ~GameStartReentryMessage(); + + GameStartReentryMessage(const GameStartReentryMessage& from); + + inline GameStartReentryMessage& operator=(const GameStartReentryMessage& from) { + CopyFrom(from); + return *this; + } + + static const GameStartReentryMessage& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const GameStartReentryMessage* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(GameStartReentryMessage* other); + + // implements Message ---------------------------------------------- + + GameStartReentryMessage* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const GameStartReentryMessage& from); + void MergeFrom(const GameStartReentryMessage& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + typedef GameStartReentryMessage_ReentryPlayerData ReentryPlayerData; + + // accessors ------------------------------------------------------- + + // required uint32 gameId = 1; + inline bool has_gameid() const; + inline void clear_gameid(); + static const int kGameIdFieldNumber = 1; + inline ::google::protobuf::uint32 gameid() const; + inline void set_gameid(::google::protobuf::uint32 value); + + // required uint32 startDealerPlayerId = 2; + inline bool has_startdealerplayerid() const; + inline void clear_startdealerplayerid(); + static const int kStartDealerPlayerIdFieldNumber = 2; + inline ::google::protobuf::uint32 startdealerplayerid() const; + inline void set_startdealerplayerid(::google::protobuf::uint32 value); + + // required uint32 handNum = 3; + inline bool has_handnum() const; + inline void clear_handnum(); + static const int kHandNumFieldNumber = 3; + inline ::google::protobuf::uint32 handnum() const; + inline void set_handnum(::google::protobuf::uint32 value); + + // repeated .GameStartReentryMessage.ReentryPlayerData reentryPlayerData = 4; + inline int reentryplayerdata_size() const; + inline void clear_reentryplayerdata(); + static const int kReentryPlayerDataFieldNumber = 4; + inline const ::GameStartReentryMessage_ReentryPlayerData& reentryplayerdata(int index) const; + inline ::GameStartReentryMessage_ReentryPlayerData* mutable_reentryplayerdata(int index); + inline ::GameStartReentryMessage_ReentryPlayerData* add_reentryplayerdata(); + inline const ::google::protobuf::RepeatedPtrField< ::GameStartReentryMessage_ReentryPlayerData >& + reentryplayerdata() const; + inline ::google::protobuf::RepeatedPtrField< ::GameStartReentryMessage_ReentryPlayerData >* + mutable_reentryplayerdata(); + + // @@protoc_insertion_point(class_scope:GameStartReentryMessage) + private: + inline void set_has_gameid(); + inline void clear_has_gameid(); + inline void set_has_startdealerplayerid(); + inline void clear_has_startdealerplayerid(); + inline void set_has_handnum(); + inline void clear_has_handnum(); + + ::google::protobuf::uint32 gameid_; + ::google::protobuf::uint32 startdealerplayerid_; + ::google::protobuf::RepeatedPtrField< ::GameStartReentryMessage_ReentryPlayerData > reentryplayerdata_; + ::google::protobuf::uint32 handnum_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_pokerth_2eproto_impl(); + #else + friend void protobuf_AddDesc_pokerth_2eproto(); + #endif + friend void protobuf_AssignDesc_pokerth_2eproto(); + friend void protobuf_ShutdownFile_pokerth_2eproto(); + + void InitAsDefaultInstance(); + static GameStartReentryMessage* default_instance_; +}; +// ------------------------------------------------------------------- + class HandStartMessage_PlainCards : public ::google::protobuf::MessageLite { public: HandStartMessage_PlainCards(); @@ -10339,6 +10555,7 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { static const PokerTHMessageType Type_GameListSpectatorLeftMessage = PokerTHMessage_PokerTHMessageType_Type_GameListSpectatorLeftMessage; static const PokerTHMessageType Type_GameSpectatorJoinedMessage = PokerTHMessage_PokerTHMessageType_Type_GameSpectatorJoinedMessage; static const PokerTHMessageType Type_GameSpectatorLeftMessage = PokerTHMessage_PokerTHMessageType_Type_GameSpectatorLeftMessage; + static const PokerTHMessageType Type_GameStartReentryMessage = PokerTHMessage_PokerTHMessageType_Type_GameStartReentryMessage; static inline bool PokerTHMessageType_IsValid(int value) { return PokerTHMessage_PokerTHMessageType_IsValid(value); } @@ -11087,6 +11304,15 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { inline ::GameSpectatorLeftMessage* release_gamespectatorleftmessage(); inline void set_allocated_gamespectatorleftmessage(::GameSpectatorLeftMessage* gamespectatorleftmessage); + // optional .GameStartReentryMessage gameStartReentryMessage = 83; + inline bool has_gamestartreentrymessage() const; + inline void clear_gamestartreentrymessage(); + static const int kGameStartReentryMessageFieldNumber = 83; + inline const ::GameStartReentryMessage& gamestartreentrymessage() const; + inline ::GameStartReentryMessage* mutable_gamestartreentrymessage(); + inline ::GameStartReentryMessage* release_gamestartreentrymessage(); + inline void set_allocated_gamestartreentrymessage(::GameStartReentryMessage* gamestartreentrymessage); + // @@protoc_insertion_point(class_scope:PokerTHMessage) private: inline void set_has_messagetype(); @@ -11253,6 +11479,8 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { inline void clear_has_gamespectatorjoinedmessage(); inline void set_has_gamespectatorleftmessage(); inline void clear_has_gamespectatorleftmessage(); + inline void set_has_gamestartreentrymessage(); + inline void clear_has_gamestartreentrymessage(); ::AnnounceMessage* announcemessage_; ::InitMessage* initmessage_; @@ -11335,10 +11563,11 @@ class PokerTHMessage : public ::google::protobuf::MessageLite { ::GameListSpectatorLeftMessage* gamelistspectatorleftmessage_; ::GameSpectatorJoinedMessage* gamespectatorjoinedmessage_; ::GameSpectatorLeftMessage* gamespectatorleftmessage_; + ::GameStartReentryMessage* gamestartreentrymessage_; int messagetype_; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(82 + 31) / 32]; + ::google::protobuf::uint32 _has_bits_[(83 + 31) / 32]; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_pokerth_2eproto_impl(); @@ -15806,6 +16035,149 @@ GameStartRejoinMessage::mutable_rejoinplayerdata() { // ------------------------------------------------------------------- +// GameStartReentryMessage_ReentryPlayerData + +// required uint32 playerId = 1; +inline bool GameStartReentryMessage_ReentryPlayerData::has_playerid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameStartReentryMessage_ReentryPlayerData::set_has_playerid() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameStartReentryMessage_ReentryPlayerData::clear_has_playerid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameStartReentryMessage_ReentryPlayerData::clear_playerid() { + playerid_ = 0u; + clear_has_playerid(); +} +inline ::google::protobuf::uint32 GameStartReentryMessage_ReentryPlayerData::playerid() const { + return playerid_; +} +inline void GameStartReentryMessage_ReentryPlayerData::set_playerid(::google::protobuf::uint32 value) { + set_has_playerid(); + playerid_ = value; +} + +// required uint32 playerMoney = 2; +inline bool GameStartReentryMessage_ReentryPlayerData::has_playermoney() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameStartReentryMessage_ReentryPlayerData::set_has_playermoney() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameStartReentryMessage_ReentryPlayerData::clear_has_playermoney() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameStartReentryMessage_ReentryPlayerData::clear_playermoney() { + playermoney_ = 0u; + clear_has_playermoney(); +} +inline ::google::protobuf::uint32 GameStartReentryMessage_ReentryPlayerData::playermoney() const { + return playermoney_; +} +inline void GameStartReentryMessage_ReentryPlayerData::set_playermoney(::google::protobuf::uint32 value) { + set_has_playermoney(); + playermoney_ = value; +} + +// ------------------------------------------------------------------- + +// GameStartReentryMessage + +// required uint32 gameId = 1; +inline bool GameStartReentryMessage::has_gameid() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GameStartReentryMessage::set_has_gameid() { + _has_bits_[0] |= 0x00000001u; +} +inline void GameStartReentryMessage::clear_has_gameid() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GameStartReentryMessage::clear_gameid() { + gameid_ = 0u; + clear_has_gameid(); +} +inline ::google::protobuf::uint32 GameStartReentryMessage::gameid() const { + return gameid_; +} +inline void GameStartReentryMessage::set_gameid(::google::protobuf::uint32 value) { + set_has_gameid(); + gameid_ = value; +} + +// required uint32 startDealerPlayerId = 2; +inline bool GameStartReentryMessage::has_startdealerplayerid() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GameStartReentryMessage::set_has_startdealerplayerid() { + _has_bits_[0] |= 0x00000002u; +} +inline void GameStartReentryMessage::clear_has_startdealerplayerid() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GameStartReentryMessage::clear_startdealerplayerid() { + startdealerplayerid_ = 0u; + clear_has_startdealerplayerid(); +} +inline ::google::protobuf::uint32 GameStartReentryMessage::startdealerplayerid() const { + return startdealerplayerid_; +} +inline void GameStartReentryMessage::set_startdealerplayerid(::google::protobuf::uint32 value) { + set_has_startdealerplayerid(); + startdealerplayerid_ = value; +} + +// required uint32 handNum = 3; +inline bool GameStartReentryMessage::has_handnum() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GameStartReentryMessage::set_has_handnum() { + _has_bits_[0] |= 0x00000004u; +} +inline void GameStartReentryMessage::clear_has_handnum() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GameStartReentryMessage::clear_handnum() { + handnum_ = 0u; + clear_has_handnum(); +} +inline ::google::protobuf::uint32 GameStartReentryMessage::handnum() const { + return handnum_; +} +inline void GameStartReentryMessage::set_handnum(::google::protobuf::uint32 value) { + set_has_handnum(); + handnum_ = value; +} + +// repeated .GameStartReentryMessage.ReentryPlayerData reentryPlayerData = 4; +inline int GameStartReentryMessage::reentryplayerdata_size() const { + return reentryplayerdata_.size(); +} +inline void GameStartReentryMessage::clear_reentryplayerdata() { + reentryplayerdata_.Clear(); +} +inline const ::GameStartReentryMessage_ReentryPlayerData& GameStartReentryMessage::reentryplayerdata(int index) const { + return reentryplayerdata_.Get(index); +} +inline ::GameStartReentryMessage_ReentryPlayerData* GameStartReentryMessage::mutable_reentryplayerdata(int index) { + return reentryplayerdata_.Mutable(index); +} +inline ::GameStartReentryMessage_ReentryPlayerData* GameStartReentryMessage::add_reentryplayerdata() { + return reentryplayerdata_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::GameStartReentryMessage_ReentryPlayerData >& +GameStartReentryMessage::reentryplayerdata() const { + return reentryplayerdata_; +} +inline ::google::protobuf::RepeatedPtrField< ::GameStartReentryMessage_ReentryPlayerData >* +GameStartReentryMessage::mutable_reentryplayerdata() { + return &reentryplayerdata_; +} + +// ------------------------------------------------------------------- + // HandStartMessage_PlainCards // required uint32 plainCard1 = 1; @@ -22156,6 +22528,48 @@ inline void PokerTHMessage::set_allocated_gamespectatorleftmessage(::GameSpectat } } +// optional .GameStartReentryMessage gameStartReentryMessage = 83; +inline bool PokerTHMessage::has_gamestartreentrymessage() const { + return (_has_bits_[2] & 0x00040000u) != 0; +} +inline void PokerTHMessage::set_has_gamestartreentrymessage() { + _has_bits_[2] |= 0x00040000u; +} +inline void PokerTHMessage::clear_has_gamestartreentrymessage() { + _has_bits_[2] &= ~0x00040000u; +} +inline void PokerTHMessage::clear_gamestartreentrymessage() { + if (gamestartreentrymessage_ != NULL) gamestartreentrymessage_->::GameStartReentryMessage::Clear(); + clear_has_gamestartreentrymessage(); +} +inline const ::GameStartReentryMessage& PokerTHMessage::gamestartreentrymessage() const { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return gamestartreentrymessage_ != NULL ? *gamestartreentrymessage_ : *default_instance().gamestartreentrymessage_; +#else + return gamestartreentrymessage_ != NULL ? *gamestartreentrymessage_ : *default_instance_->gamestartreentrymessage_; +#endif +} +inline ::GameStartReentryMessage* PokerTHMessage::mutable_gamestartreentrymessage() { + set_has_gamestartreentrymessage(); + if (gamestartreentrymessage_ == NULL) gamestartreentrymessage_ = new ::GameStartReentryMessage; + return gamestartreentrymessage_; +} +inline ::GameStartReentryMessage* PokerTHMessage::release_gamestartreentrymessage() { + clear_has_gamestartreentrymessage(); + ::GameStartReentryMessage* temp = gamestartreentrymessage_; + gamestartreentrymessage_ = NULL; + return temp; +} +inline void PokerTHMessage::set_allocated_gamestartreentrymessage(::GameStartReentryMessage* gamestartreentrymessage) { + delete gamestartreentrymessage_; + gamestartreentrymessage_ = gamestartreentrymessage; + if (gamestartreentrymessage) { + set_has_gamestartreentrymessage(); + } else { + clear_has_gamestartreentrymessage(); + } +} + // @@protoc_insertion_point(namespace_scope)