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

add reentry messaging

Browse Source
This commit is contained in:
Albert Medela
2020-06-20 21:14:14 +02:00
parent 63fb9bc287
commit eccb3f404e
9 changed files with 1095 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pokerth.proto
+13
View File
@@ -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;
}
src/engine/local_engine/localhand.cpp
+5
View File
@@ -66,7 +66,12 @@ LocalHand::LocalHand(boost::shared_ptr<EngineFactory> 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];
src/net/common/netpacketvalidator.cpp
+17
View File
@@ -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)
{
src/net/common/servergamestate.cpp
+103 -4
View File
@@ -962,7 +962,7 @@ AbstractServerGameStateRunning::HandleNewPlayer(boost::shared_ptr<ServerGame> 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<int>(server->GetNumberPlayersReentry()) < tmpGameData.maxNumberOfPlayers) { // there is a seat available
@@ -1680,19 +1680,91 @@ ServerGameStateHand::PerformReentry(boost::shared_ptr<ServerGame> server, boost:
// check if player already played this game
boost::shared_ptr<PlayerInterface> 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<NetPacket> 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());
}
int seat = getRandomFreeSeat(curGame.getActivePlayerList());
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()); // (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<int> 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<int>::size_type i = 0; i != v.size(); i++) {
if (v[i] == 0) {
seat = i;
break;
}
}
return seat;
}
void
ServerGameStateHand::SendGameData(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session)
{
@@ -1719,6 +1791,33 @@ ServerGameStateHand::SendGameData(boost::shared_ptr<ServerGame> server, boost::s
server->GetLobbyThread().GetSender().Send(session, packet);
}
void
ServerGameStateHand::SendGameDataReentry(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session)
{
Game &curGame = server->GetGame();
// Send game start notification to reentry client.
boost::shared_ptr<NetPacket> 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<PlayerInterface> 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);
}
//-----------------------------------------------------------------------------
src/net/netpacketvalidator.h
+1
View File
@@ -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);
src/net/servergame.h
+1 -1
View File
@@ -113,7 +113,7 @@ public:
void AddReentryPlayer(unsigned playerId);
PlayerIdList GetAndResetReentryPlayers();
int GetNumberPlayersReentry();
unsigned GetNumberPlayersReentry();
void AddReactivatePlayer(unsigned playerId);
PlayerIdList GetAndResetReactivatePlayers();
src/net/servergamestate.h
+3
View File
@@ -36,6 +36,7 @@
#include <boost/asio.hpp>
#include <playerdata.h>
#include <net/sessionmanager.h>
#include <engine/engine_defs.h>
#ifdef _MSC_VER
@@ -197,6 +198,8 @@ protected:
static void PerformRejoin(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session);
static void PerformReentry(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session);
static void SendGameData(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session);
static void SendGameDataReentry(boost::shared_ptr<ServerGame> server, boost::shared_ptr<SessionData> session);
static int GetRandomFreeSeat(const PlayerList playerList);
private:
static ServerGameStateHand s_state;
src/third_party/protobuf/pokerth.pb.cc
Vendored
+533
View File
@@ -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<const GameStartReentryMessage_ReentryPlayerData*>(&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<const GameStartReentryMessage*>(&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]);
src/third_party/protobuf/pokerth.pb.h
Vendored
+419 -5
View File
@@ -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)