Improving in-game admin functions, implementing reply packets to report results.

src/net/common/netpacketvalidator.cpp

@@ -129,7 +129,9 @@ NetPacketValidator::NetPacketValidator()
 	m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_ReportGameAckMessage, ValidateReportGameAckMessage));
 	m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_ErrorMessage, ValidateErrorMessage));
 	m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameMessage, ValidateAdminRemoveGameMessage));
+	m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameAckMessage, ValidateAdminRemoveGameAckMessage));
 	m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage, ValidateAdminBanPlayerMessage));
+	m_validationMap.insert(make_pair(PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage, ValidateAdminBanPlayerAckMessage));
 }
 
 bool
@@ -1160,6 +1162,19 @@ NetPacketValidator::ValidateAdminRemoveGameMessage(const NetPacket &packet)
 	return retVal;
 }
 
+bool
+NetPacketValidator::ValidateAdminRemoveGameAckMessage(const NetPacket &packet)
+{
+	bool retVal = false;
+	if (packet.GetMsg()->has_adminremovegameackmessage()) {
+		const AdminRemoveGameAckMessage &msg = packet.GetMsg()->adminremovegameackmessage();
+		if (msg.removegameid() != 0) {
+			retVal = true;
+		}
+	}
+	return retVal;
+}
+
 bool
 NetPacketValidator::ValidateAdminBanPlayerMessage(const NetPacket &packet)
 {
@@ -1173,6 +1188,19 @@ NetPacketValidator::ValidateAdminBanPlayerMessage(const NetPacket &packet)
 	return retVal;
 }
 
+bool
+NetPacketValidator::ValidateAdminBanPlayerAckMessage(const NetPacket &packet)
+{
+	bool retVal = false;
+	if (packet.GetMsg()->has_adminbanplayerackmessage()) {
+		const AdminBanPlayerAckMessage &msg = packet.GetMsg()->adminbanplayerackmessage();
+		if (msg.banplayerid() != 0) {
+			retVal = true;
+		}
+	}
+	return retVal;
+}
+
 bool
 NetPacketValidator::ValidateGameInfo(const NetGameInfo &gameInfo)
 {

src/net/common/servergamestate.cpp

@@ -657,6 +657,10 @@ ServerGameStateInit::InternalProcessPacket(boost::shared_ptr<ServerGame> server,
 		if (session->GetPlayerData()->IsGameAdmin()) {
 			RegisterAdminTimer(server);
 		}
+	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AdminRemoveGameMessage) {
+		server->GetLobbyThread().HandleAdminRemoveGame(session, packet->GetMsg()->adminremovegamemessage());
+	} else if (packet->GetMsg()->messagetype() == PokerTHMessage::Type_AdminBanPlayerMessage) {
+		server->GetLobbyThread().HandleAdminBanPlayer(session, packet->GetMsg()->adminbanplayermessage());
 	} else {
 		server->SessionError(session, ERR_SOCK_INVALID_PACKET);
 	}

src/net/common/serverlobbythread.cpp

@@ -516,6 +516,20 @@ ServerLobbyThread::HandleChatRequest(boost::shared_ptr<SessionData> session, con
 	HandleNetPacketChatRequest(session, chatRequest);
 }
 
+void
+ServerLobbyThread::HandleAdminRemoveGame(boost::shared_ptr<SessionData> session, const AdminRemoveGameMessage &removeGame)
+{
+	// An admin within a game sent a remove game message.
+	HandleNetPacketAdminRemoveGame(session, removeGame);
+}
+
+void
+ServerLobbyThread::HandleAdminBanPlayer(boost::shared_ptr<SessionData> session, const AdminBanPlayerMessage &banPlayer)
+{
+	// An admin within a game sent a ban player message.
+	HandleNetPacketAdminBanPlayer(session, banPlayer);
+}
+
 bool
 ServerLobbyThread::KickPlayerByName(const std::string &playerName)
 {
@@ -1478,9 +1492,20 @@ ServerLobbyThread::HandleNetPacketAdminRemoveGame(boost::shared_ptr<SessionData>
 {
 	GameMap::iterator pos = m_gameMap.find(removeGame.removegameid());
 
+	// Create Ack-Packet.
+	boost::shared_ptr<NetPacket> packet(new NetPacket);
+	packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AdminRemoveGameAckMessage);
+	AdminRemoveGameAckMessage *netRemoveAck = packet->GetMsg()->mutable_adminremovegameackmessage();
+	netRemoveAck->set_removegameid(removeGame.removegameid());
+
+	// Check whether game id is valid and whether the player is an admin.
 	if (pos != m_gameMap.end() && session->GetPlayerData() && GetBanManager().IsAdminPlayer(session->GetPlayerData()->GetDBId())) {
 		InternalRemoveGame(pos->second);
+		netRemoveAck->set_removegameresult(AdminRemoveGameAckMessage::gameRemoveAccepted);
+	} else {
+		netRemoveAck->set_removegameresult(AdminRemoveGameAckMessage::gameRemoveInvalid);
 	}
+	GetSender().Send(session, packet);
 }
 
 void

src/net/netpacketvalidator.h

@@ -120,7 +120,9 @@ protected:
 	static bool ValidateReportGameAckMessage(const NetPacket &packet);
 	static bool ValidateErrorMessage(const NetPacket &packet);
 	static bool ValidateAdminRemoveGameMessage(const NetPacket &packet);
+	static bool ValidateAdminRemoveGameAckMessage(const NetPacket &packet);
 	static bool ValidateAdminBanPlayerMessage(const NetPacket &packet);
+	static bool ValidateAdminBanPlayerAckMessage(const NetPacket &packet);
 
 	static bool ValidateGameInfo(const NetGameInfo &gameInfo);
 

src/net/serverlobbythread.h

@@ -88,6 +88,8 @@ public:
 	void HandleGameRetrieveAvatar(boost::shared_ptr<SessionData> session, const AvatarRequestMessage &retrieveAvatar);
 	void HandleGameReportGame(boost::shared_ptr<SessionData> session, const ReportGameMessage &reportGame);
 	void HandleChatRequest(boost::shared_ptr<SessionData> session, const ChatRequestMessage &chatRequest);
+	void HandleAdminRemoveGame(boost::shared_ptr<SessionData> session, const AdminRemoveGameMessage &removeGame);
+	void HandleAdminBanPlayer(boost::shared_ptr<SessionData> session, const AdminBanPlayerMessage &banPlayer);
 
 	bool KickPlayerByName(const std::string &playerName);
 	bool RemoveGameByPlayerName(const std::string &playerName);

src/third_party/protobuf/pokerth.pb.cc

@@ -94,7 +94,9 @@ void protobuf_ShutdownFile_pokerth_2eproto() {
   delete ReportGameAckMessage::default_instance_;
   delete ErrorMessage::default_instance_;
   delete AdminRemoveGameMessage::default_instance_;
+  delete AdminRemoveGameAckMessage::default_instance_;
   delete AdminBanPlayerMessage::default_instance_;
+  delete AdminBanPlayerAckMessage::default_instance_;
   delete PokerTHMessage::default_instance_;
 }
 
@@ -187,7 +189,9 @@ void protobuf_AddDesc_pokerth_2eproto() {
   ReportGameAckMessage::default_instance_ = new ReportGameAckMessage();
   ErrorMessage::default_instance_ = new ErrorMessage();
   AdminRemoveGameMessage::default_instance_ = new AdminRemoveGameMessage();
+  AdminRemoveGameAckMessage::default_instance_ = new AdminRemoveGameAckMessage();
   AdminBanPlayerMessage::default_instance_ = new AdminBanPlayerMessage();
+  AdminBanPlayerAckMessage::default_instance_ = new AdminBanPlayerAckMessage();
   PokerTHMessage::default_instance_ = new PokerTHMessage();
   NetGameInfo::default_instance_->InitAsDefaultInstance();
   PlayerResult::default_instance_->InitAsDefaultInstance();
@@ -272,7 +276,9 @@ void protobuf_AddDesc_pokerth_2eproto() {
   ReportGameAckMessage::default_instance_->InitAsDefaultInstance();
   ErrorMessage::default_instance_->InitAsDefaultInstance();
   AdminRemoveGameMessage::default_instance_->InitAsDefaultInstance();
+  AdminRemoveGameAckMessage::default_instance_->InitAsDefaultInstance();
   AdminBanPlayerMessage::default_instance_->InitAsDefaultInstance();
+  AdminBanPlayerAckMessage::default_instance_->InitAsDefaultInstance();
   PokerTHMessage::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pokerth_2eproto);
 }
@@ -19546,6 +19552,220 @@ void AdminRemoveGameMessage::Swap(AdminRemoveGameMessage* other) {
 }
 
 
+// ===================================================================
+
+bool AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::gameRemoveAccepted;
+const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::gameRemoveInvalid;
+const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::AdminRemoveGameResult_MIN;
+const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::AdminRemoveGameResult_MAX;
+const int AdminRemoveGameAckMessage::AdminRemoveGameResult_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int AdminRemoveGameAckMessage::kRemoveGameIdFieldNumber;
+const int AdminRemoveGameAckMessage::kRemoveGameResultFieldNumber;
+#endif  // !_MSC_VER
+
+AdminRemoveGameAckMessage::AdminRemoveGameAckMessage()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void AdminRemoveGameAckMessage::InitAsDefaultInstance() {
+}
+
+AdminRemoveGameAckMessage::AdminRemoveGameAckMessage(const AdminRemoveGameAckMessage& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void AdminRemoveGameAckMessage::SharedCtor() {
+  _cached_size_ = 0;
+  removegameid_ = 0u;
+  removegameresult_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AdminRemoveGameAckMessage::~AdminRemoveGameAckMessage() {
+  SharedDtor();
+}
+
+void AdminRemoveGameAckMessage::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AdminRemoveGameAckMessage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const AdminRemoveGameAckMessage& AdminRemoveGameAckMessage::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();  return *default_instance_;
+}
+
+AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::default_instance_ = NULL;
+
+AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::New() const {
+  return new AdminRemoveGameAckMessage;
+}
+
+void AdminRemoveGameAckMessage::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    removegameid_ = 0u;
+    removegameresult_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool AdminRemoveGameAckMessage::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 removeGameId = 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, &removegameid_)));
+          set_has_removegameid();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_removeGameResult;
+        break;
+      }
+      
+      // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_removeGameResult:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value)) {
+            set_removegameresult(static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(value));
+          }
+        } 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 AdminRemoveGameAckMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required uint32 removeGameId = 1;
+  if (has_removegameid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->removegameid(), output);
+  }
+  
+  // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
+  if (has_removegameresult()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->removegameresult(), output);
+  }
+  
+}
+
+int AdminRemoveGameAckMessage::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 removeGameId = 1;
+    if (has_removegameid()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->removegameid());
+    }
+    
+    // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
+    if (has_removegameresult()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->removegameresult());
+    }
+    
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AdminRemoveGameAckMessage::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const AdminRemoveGameAckMessage*>(&from));
+}
+
+void AdminRemoveGameAckMessage::MergeFrom(const AdminRemoveGameAckMessage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_removegameid()) {
+      set_removegameid(from.removegameid());
+    }
+    if (from.has_removegameresult()) {
+      set_removegameresult(from.removegameresult());
+    }
+  }
+}
+
+void AdminRemoveGameAckMessage::CopyFrom(const AdminRemoveGameAckMessage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdminRemoveGameAckMessage::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  return true;
+}
+
+void AdminRemoveGameAckMessage::Swap(AdminRemoveGameAckMessage* other) {
+  if (other != this) {
+    std::swap(removegameid_, other->removegameid_);
+    std::swap(removegameresult_, other->removegameresult_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string AdminRemoveGameAckMessage::GetTypeName() const {
+  return "AdminRemoveGameAckMessage";
+}
+
+
 // ===================================================================
 
 #ifndef _MSC_VER
@@ -19705,6 +19925,224 @@ void AdminBanPlayerMessage::Swap(AdminBanPlayerMessage* other) {
 }
 
 
+// ===================================================================
+
+bool AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerAccepted;
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerInvalid;
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerNoDB;
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerDBError;
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::AdminBanPlayerResult_MIN;
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::AdminBanPlayerResult_MAX;
+const int AdminBanPlayerAckMessage::AdminBanPlayerResult_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int AdminBanPlayerAckMessage::kBanPlayerIdFieldNumber;
+const int AdminBanPlayerAckMessage::kBanPlayerResultFieldNumber;
+#endif  // !_MSC_VER
+
+AdminBanPlayerAckMessage::AdminBanPlayerAckMessage()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void AdminBanPlayerAckMessage::InitAsDefaultInstance() {
+}
+
+AdminBanPlayerAckMessage::AdminBanPlayerAckMessage(const AdminBanPlayerAckMessage& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void AdminBanPlayerAckMessage::SharedCtor() {
+  _cached_size_ = 0;
+  banplayerid_ = 0u;
+  banplayerresult_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AdminBanPlayerAckMessage::~AdminBanPlayerAckMessage() {
+  SharedDtor();
+}
+
+void AdminBanPlayerAckMessage::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AdminBanPlayerAckMessage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const AdminBanPlayerAckMessage& AdminBanPlayerAckMessage::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();  return *default_instance_;
+}
+
+AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::default_instance_ = NULL;
+
+AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::New() const {
+  return new AdminBanPlayerAckMessage;
+}
+
+void AdminBanPlayerAckMessage::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    banplayerid_ = 0u;
+    banplayerresult_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool AdminBanPlayerAckMessage::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 banPlayerId = 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, &banplayerid_)));
+          set_has_banplayerid();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_banPlayerResult;
+        break;
+      }
+      
+      // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_banPlayerResult:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value)) {
+            set_banplayerresult(static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(value));
+          }
+        } 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 AdminBanPlayerAckMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required uint32 banPlayerId = 1;
+  if (has_banplayerid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->banplayerid(), output);
+  }
+  
+  // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
+  if (has_banplayerresult()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->banplayerresult(), output);
+  }
+  
+}
+
+int AdminBanPlayerAckMessage::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 banPlayerId = 1;
+    if (has_banplayerid()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->banplayerid());
+    }
+    
+    // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
+    if (has_banplayerresult()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->banplayerresult());
+    }
+    
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AdminBanPlayerAckMessage::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const AdminBanPlayerAckMessage*>(&from));
+}
+
+void AdminBanPlayerAckMessage::MergeFrom(const AdminBanPlayerAckMessage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_banplayerid()) {
+      set_banplayerid(from.banplayerid());
+    }
+    if (from.has_banplayerresult()) {
+      set_banplayerresult(from.banplayerresult());
+    }
+  }
+}
+
+void AdminBanPlayerAckMessage::CopyFrom(const AdminBanPlayerAckMessage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdminBanPlayerAckMessage::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  return true;
+}
+
+void AdminBanPlayerAckMessage::Swap(AdminBanPlayerAckMessage* other) {
+  if (other != this) {
+    std::swap(banplayerid_, other->banplayerid_);
+    std::swap(banplayerresult_, other->banplayerresult_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string AdminBanPlayerAckMessage::GetTypeName() const {
+  return "AdminBanPlayerAckMessage";
+}
+
+
 // ===================================================================
 
 bool PokerTHMessage_PokerTHMessageType_IsValid(int value) {
@@ -19784,6 +20222,8 @@ bool PokerTHMessage_PokerTHMessageType_IsValid(int value) {
     case 73:
     case 74:
     case 75:
+    case 76:
+    case 77:
       return true;
     default:
       return false;
@@ -19865,7 +20305,9 @@ const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportGameMessage;
 const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportGameAckMessage;
 const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ErrorMessage;
 const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminRemoveGameMessage;
+const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminRemoveGameAckMessage;
 const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminBanPlayerMessage;
+const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminBanPlayerAckMessage;
 const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MIN;
 const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MAX;
 const int PokerTHMessage::PokerTHMessageType_ARRAYSIZE;
@@ -19946,7 +20388,9 @@ const int PokerTHMessage::kReportGameMessageFieldNumber;
 const int PokerTHMessage::kReportGameAckMessageFieldNumber;
 const int PokerTHMessage::kErrorMessageFieldNumber;
 const int PokerTHMessage::kAdminRemoveGameMessageFieldNumber;
+const int PokerTHMessage::kAdminRemoveGameAckMessageFieldNumber;
 const int PokerTHMessage::kAdminBanPlayerMessageFieldNumber;
+const int PokerTHMessage::kAdminBanPlayerAckMessageFieldNumber;
 #endif  // !_MSC_VER
 
 PokerTHMessage::PokerTHMessage()
@@ -20029,7 +20473,9 @@ void PokerTHMessage::InitAsDefaultInstance() {
   reportgameackmessage_ = const_cast< ::ReportGameAckMessage*>(&::ReportGameAckMessage::default_instance());
   errormessage_ = const_cast< ::ErrorMessage*>(&::ErrorMessage::default_instance());
   adminremovegamemessage_ = const_cast< ::AdminRemoveGameMessage*>(&::AdminRemoveGameMessage::default_instance());
+  adminremovegameackmessage_ = const_cast< ::AdminRemoveGameAckMessage*>(&::AdminRemoveGameAckMessage::default_instance());
   adminbanplayermessage_ = const_cast< ::AdminBanPlayerMessage*>(&::AdminBanPlayerMessage::default_instance());
+  adminbanplayerackmessage_ = const_cast< ::AdminBanPlayerAckMessage*>(&::AdminBanPlayerAckMessage::default_instance());
 }
 
 PokerTHMessage::PokerTHMessage(const PokerTHMessage& from)
@@ -20115,7 +20561,9 @@ void PokerTHMessage::SharedCtor() {
   reportgameackmessage_ = NULL;
   errormessage_ = NULL;
   adminremovegamemessage_ = NULL;
+  adminremovegameackmessage_ = NULL;
   adminbanplayermessage_ = NULL;
+  adminbanplayerackmessage_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -20199,7 +20647,9 @@ void PokerTHMessage::SharedDtor() {
     delete reportgameackmessage_;
     delete errormessage_;
     delete adminremovegamemessage_;
+    delete adminremovegameackmessage_;
     delete adminbanplayermessage_;
+    delete adminbanplayerackmessage_;
   }
 }
 
@@ -20461,9 +20911,15 @@ void PokerTHMessage::Clear() {
     if (has_adminremovegamemessage()) {
       if (adminremovegamemessage_ != NULL) adminremovegamemessage_->::AdminRemoveGameMessage::Clear();
     }
+    if (has_adminremovegameackmessage()) {
+      if (adminremovegameackmessage_ != NULL) adminremovegameackmessage_->::AdminRemoveGameAckMessage::Clear();
+    }
     if (has_adminbanplayermessage()) {
       if (adminbanplayermessage_ != NULL) adminbanplayermessage_->::AdminBanPlayerMessage::Clear();
     }
+    if (has_adminbanplayerackmessage()) {
+      if (adminbanplayerackmessage_ != NULL) adminbanplayerackmessage_->::AdminBanPlayerAckMessage::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
@@ -21524,12 +21980,26 @@ bool PokerTHMessage::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
-        if (input->ExpectTag(610)) goto parse_adminBanPlayerMessage;
+        if (input->ExpectTag(610)) goto parse_adminRemoveGameAckMessage;
         break;
       }
       
-      // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76;
+      // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
       case 76: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_adminRemoveGameAckMessage:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_adminremovegameackmessage()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(618)) goto parse_adminBanPlayerMessage;
+        break;
+      }
+      
+      // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
+      case 77: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          parse_adminBanPlayerMessage:
@@ -21538,6 +22008,20 @@ bool PokerTHMessage::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(626)) goto parse_adminBanPlayerAckMessage;
+        break;
+      }
+      
+      // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
+      case 78: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_adminBanPlayerAckMessage:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_adminbanplayerackmessage()));
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -22009,10 +22493,22 @@ void PokerTHMessage::SerializeWithCachedSizes(
       75, this->adminremovegamemessage(), output);
   }
   
-  // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76;
+  // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
+  if (has_adminremovegameackmessage()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      76, this->adminremovegameackmessage(), output);
+  }
+  
+  // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
   if (has_adminbanplayermessage()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
-      76, this->adminbanplayermessage(), output);
+      77, this->adminbanplayermessage(), output);
+  }
+  
+  // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
+  if (has_adminbanplayerackmessage()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      78, this->adminbanplayerackmessage(), output);
   }
   
 }
@@ -22563,13 +23059,27 @@ int PokerTHMessage::ByteSize() const {
           this->adminremovegamemessage());
     }
     
-    // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76;
+    // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
+    if (has_adminremovegameackmessage()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->adminremovegameackmessage());
+    }
+    
+    // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
     if (has_adminbanplayermessage()) {
       total_size += 2 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->adminbanplayermessage());
     }
     
+    // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
+    if (has_adminbanplayerackmessage()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->adminbanplayerackmessage());
+    }
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -22828,9 +23338,15 @@ void PokerTHMessage::MergeFrom(const PokerTHMessage& from) {
     if (from.has_adminremovegamemessage()) {
       mutable_adminremovegamemessage()->::AdminRemoveGameMessage::MergeFrom(from.adminremovegamemessage());
     }
+    if (from.has_adminremovegameackmessage()) {
+      mutable_adminremovegameackmessage()->::AdminRemoveGameAckMessage::MergeFrom(from.adminremovegameackmessage());
+    }
     if (from.has_adminbanplayermessage()) {
       mutable_adminbanplayermessage()->::AdminBanPlayerMessage::MergeFrom(from.adminbanplayermessage());
     }
+    if (from.has_adminbanplayerackmessage()) {
+      mutable_adminbanplayerackmessage()->::AdminBanPlayerAckMessage::MergeFrom(from.adminbanplayerackmessage());
+    }
   }
 }
 
@@ -23056,9 +23572,15 @@ bool PokerTHMessage::IsInitialized() const {
   if (has_adminremovegamemessage()) {
     if (!this->adminremovegamemessage().IsInitialized()) return false;
   }
+  if (has_adminremovegameackmessage()) {
+    if (!this->adminremovegameackmessage().IsInitialized()) return false;
+  }
   if (has_adminbanplayermessage()) {
     if (!this->adminbanplayermessage().IsInitialized()) return false;
   }
+  if (has_adminbanplayerackmessage()) {
+    if (!this->adminbanplayerackmessage().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -23139,7 +23661,9 @@ void PokerTHMessage::Swap(PokerTHMessage* other) {
     std::swap(reportgameackmessage_, other->reportgameackmessage_);
     std::swap(errormessage_, other->errormessage_);
     std::swap(adminremovegamemessage_, other->adminremovegamemessage_);
+    std::swap(adminremovegameackmessage_, other->adminremovegameackmessage_);
     std::swap(adminbanplayermessage_, other->adminbanplayermessage_);
+    std::swap(adminbanplayerackmessage_, other->adminbanplayerackmessage_);
     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

@@ -112,7 +112,9 @@ class ReportGameMessage;
 class ReportGameAckMessage;
 class ErrorMessage;
 class AdminRemoveGameMessage;
+class AdminRemoveGameAckMessage;
 class AdminBanPlayerMessage;
+class AdminBanPlayerAckMessage;
 class PokerTHMessage;
 
 enum NetGameInfo_NetGameType {
@@ -357,6 +359,26 @@ const ErrorMessage_ErrorReason ErrorMessage_ErrorReason_ErrorReason_MIN = ErrorM
 const ErrorMessage_ErrorReason ErrorMessage_ErrorReason_ErrorReason_MAX = ErrorMessage_ErrorReason_sessionTimeout;
 const int ErrorMessage_ErrorReason_ErrorReason_ARRAYSIZE = ErrorMessage_ErrorReason_ErrorReason_MAX + 1;
 
+enum AdminRemoveGameAckMessage_AdminRemoveGameResult {
+  AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveAccepted = 0,
+  AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveInvalid = 1
+};
+bool AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(int value);
+const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MIN = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveAccepted;
+const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MAX = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveInvalid;
+const int AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_ARRAYSIZE = AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MAX + 1;
+
+enum AdminBanPlayerAckMessage_AdminBanPlayerResult {
+  AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerAccepted = 0,
+  AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerInvalid = 1,
+  AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerNoDB = 2,
+  AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerDBError = 3
+};
+bool AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(int value);
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MIN = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerAccepted;
+const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MAX = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerDBError;
+const int AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_ARRAYSIZE = AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MAX + 1;
+
 enum PokerTHMessage_PokerTHMessageType {
   PokerTHMessage_PokerTHMessageType_Type_AnnounceMessage = 1,
   PokerTHMessage_PokerTHMessageType_Type_InitMessage = 2,
@@ -432,11 +454,13 @@ enum PokerTHMessage_PokerTHMessageType {
   PokerTHMessage_PokerTHMessageType_Type_ReportGameAckMessage = 72,
   PokerTHMessage_PokerTHMessageType_Type_ErrorMessage = 73,
   PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameMessage = 74,
-  PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage = 75
+  PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameAckMessage = 75,
+  PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage = 76,
+  PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage = 77
 };
 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_AdminBanPlayerMessage;
+const PokerTHMessage_PokerTHMessageType PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage;
 const int PokerTHMessage_PokerTHMessageType_PokerTHMessageType_ARRAYSIZE = PokerTHMessage_PokerTHMessageType_PokerTHMessageType_MAX + 1;
 
 enum NetGameMode {
@@ -8198,6 +8222,98 @@ class AdminRemoveGameMessage : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
+class AdminRemoveGameAckMessage : public ::google::protobuf::MessageLite {
+ public:
+  AdminRemoveGameAckMessage();
+  virtual ~AdminRemoveGameAckMessage();
+  
+  AdminRemoveGameAckMessage(const AdminRemoveGameAckMessage& from);
+  
+  inline AdminRemoveGameAckMessage& operator=(const AdminRemoveGameAckMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  static const AdminRemoveGameAckMessage& default_instance();
+  
+  void Swap(AdminRemoveGameAckMessage* other);
+  
+  // implements Message ----------------------------------------------
+  
+  AdminRemoveGameAckMessage* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const AdminRemoveGameAckMessage& from);
+  void MergeFrom(const AdminRemoveGameAckMessage& 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 AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameResult;
+  static const AdminRemoveGameResult gameRemoveAccepted = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveAccepted;
+  static const AdminRemoveGameResult gameRemoveInvalid = AdminRemoveGameAckMessage_AdminRemoveGameResult_gameRemoveInvalid;
+  static inline bool AdminRemoveGameResult_IsValid(int value) {
+    return AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value);
+  }
+  static const AdminRemoveGameResult AdminRemoveGameResult_MIN =
+    AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MIN;
+  static const AdminRemoveGameResult AdminRemoveGameResult_MAX =
+    AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_MAX;
+  static const int AdminRemoveGameResult_ARRAYSIZE =
+    AdminRemoveGameAckMessage_AdminRemoveGameResult_AdminRemoveGameResult_ARRAYSIZE;
+  
+  // accessors -------------------------------------------------------
+  
+  // required uint32 removeGameId = 1;
+  inline bool has_removegameid() const;
+  inline void clear_removegameid();
+  static const int kRemoveGameIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 removegameid() const;
+  inline void set_removegameid(::google::protobuf::uint32 value);
+  
+  // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
+  inline bool has_removegameresult() const;
+  inline void clear_removegameresult();
+  static const int kRemoveGameResultFieldNumber = 2;
+  inline ::AdminRemoveGameAckMessage_AdminRemoveGameResult removegameresult() const;
+  inline void set_removegameresult(::AdminRemoveGameAckMessage_AdminRemoveGameResult value);
+  
+  // @@protoc_insertion_point(class_scope:AdminRemoveGameAckMessage)
+ private:
+  inline void set_has_removegameid();
+  inline void clear_has_removegameid();
+  inline void set_has_removegameresult();
+  inline void clear_has_removegameresult();
+  
+  ::google::protobuf::uint32 removegameid_;
+  int removegameresult_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pokerth_2eproto();
+  friend void protobuf_AssignDesc_pokerth_2eproto();
+  friend void protobuf_ShutdownFile_pokerth_2eproto();
+  
+  void InitAsDefaultInstance();
+  static AdminRemoveGameAckMessage* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class AdminBanPlayerMessage : public ::google::protobuf::MessageLite {
  public:
   AdminBanPlayerMessage();
@@ -8267,6 +8383,100 @@ class AdminBanPlayerMessage : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
+class AdminBanPlayerAckMessage : public ::google::protobuf::MessageLite {
+ public:
+  AdminBanPlayerAckMessage();
+  virtual ~AdminBanPlayerAckMessage();
+  
+  AdminBanPlayerAckMessage(const AdminBanPlayerAckMessage& from);
+  
+  inline AdminBanPlayerAckMessage& operator=(const AdminBanPlayerAckMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  static const AdminBanPlayerAckMessage& default_instance();
+  
+  void Swap(AdminBanPlayerAckMessage* other);
+  
+  // implements Message ----------------------------------------------
+  
+  AdminBanPlayerAckMessage* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const AdminBanPlayerAckMessage& from);
+  void MergeFrom(const AdminBanPlayerAckMessage& 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 AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerResult;
+  static const AdminBanPlayerResult banPlayerAccepted = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerAccepted;
+  static const AdminBanPlayerResult banPlayerInvalid = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerInvalid;
+  static const AdminBanPlayerResult banPlayerNoDB = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerNoDB;
+  static const AdminBanPlayerResult banPlayerDBError = AdminBanPlayerAckMessage_AdminBanPlayerResult_banPlayerDBError;
+  static inline bool AdminBanPlayerResult_IsValid(int value) {
+    return AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value);
+  }
+  static const AdminBanPlayerResult AdminBanPlayerResult_MIN =
+    AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MIN;
+  static const AdminBanPlayerResult AdminBanPlayerResult_MAX =
+    AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_MAX;
+  static const int AdminBanPlayerResult_ARRAYSIZE =
+    AdminBanPlayerAckMessage_AdminBanPlayerResult_AdminBanPlayerResult_ARRAYSIZE;
+  
+  // accessors -------------------------------------------------------
+  
+  // required uint32 banPlayerId = 1;
+  inline bool has_banplayerid() const;
+  inline void clear_banplayerid();
+  static const int kBanPlayerIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 banplayerid() const;
+  inline void set_banplayerid(::google::protobuf::uint32 value);
+  
+  // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
+  inline bool has_banplayerresult() const;
+  inline void clear_banplayerresult();
+  static const int kBanPlayerResultFieldNumber = 2;
+  inline ::AdminBanPlayerAckMessage_AdminBanPlayerResult banplayerresult() const;
+  inline void set_banplayerresult(::AdminBanPlayerAckMessage_AdminBanPlayerResult value);
+  
+  // @@protoc_insertion_point(class_scope:AdminBanPlayerAckMessage)
+ private:
+  inline void set_has_banplayerid();
+  inline void clear_has_banplayerid();
+  inline void set_has_banplayerresult();
+  inline void clear_has_banplayerresult();
+  
+  ::google::protobuf::uint32 banplayerid_;
+  int banplayerresult_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_pokerth_2eproto();
+  friend void protobuf_AssignDesc_pokerth_2eproto();
+  friend void protobuf_ShutdownFile_pokerth_2eproto();
+  
+  void InitAsDefaultInstance();
+  static AdminBanPlayerAckMessage* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class PokerTHMessage : public ::google::protobuf::MessageLite {
  public:
   PokerTHMessage();
@@ -8383,7 +8593,9 @@ class PokerTHMessage : public ::google::protobuf::MessageLite {
   static const PokerTHMessageType Type_ReportGameAckMessage = PokerTHMessage_PokerTHMessageType_Type_ReportGameAckMessage;
   static const PokerTHMessageType Type_ErrorMessage = PokerTHMessage_PokerTHMessageType_Type_ErrorMessage;
   static const PokerTHMessageType Type_AdminRemoveGameMessage = PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameMessage;
+  static const PokerTHMessageType Type_AdminRemoveGameAckMessage = PokerTHMessage_PokerTHMessageType_Type_AdminRemoveGameAckMessage;
   static const PokerTHMessageType Type_AdminBanPlayerMessage = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerMessage;
+  static const PokerTHMessageType Type_AdminBanPlayerAckMessage = PokerTHMessage_PokerTHMessageType_Type_AdminBanPlayerAckMessage;
   static inline bool PokerTHMessageType_IsValid(int value) {
     return PokerTHMessage_PokerTHMessageType_IsValid(value);
   }
@@ -8995,14 +9207,30 @@ class PokerTHMessage : public ::google::protobuf::MessageLite {
   inline ::AdminRemoveGameMessage* mutable_adminremovegamemessage();
   inline ::AdminRemoveGameMessage* release_adminremovegamemessage();
   
-  // optional .AdminBanPlayerMessage adminBanPlayerMessage = 76;
+  // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
+  inline bool has_adminremovegameackmessage() const;
+  inline void clear_adminremovegameackmessage();
+  static const int kAdminRemoveGameAckMessageFieldNumber = 76;
+  inline const ::AdminRemoveGameAckMessage& adminremovegameackmessage() const;
+  inline ::AdminRemoveGameAckMessage* mutable_adminremovegameackmessage();
+  inline ::AdminRemoveGameAckMessage* release_adminremovegameackmessage();
+  
+  // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
   inline bool has_adminbanplayermessage() const;
   inline void clear_adminbanplayermessage();
-  static const int kAdminBanPlayerMessageFieldNumber = 76;
+  static const int kAdminBanPlayerMessageFieldNumber = 77;
   inline const ::AdminBanPlayerMessage& adminbanplayermessage() const;
   inline ::AdminBanPlayerMessage* mutable_adminbanplayermessage();
   inline ::AdminBanPlayerMessage* release_adminbanplayermessage();
   
+  // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
+  inline bool has_adminbanplayerackmessage() const;
+  inline void clear_adminbanplayerackmessage();
+  static const int kAdminBanPlayerAckMessageFieldNumber = 78;
+  inline const ::AdminBanPlayerAckMessage& adminbanplayerackmessage() const;
+  inline ::AdminBanPlayerAckMessage* mutable_adminbanplayerackmessage();
+  inline ::AdminBanPlayerAckMessage* release_adminbanplayerackmessage();
+  
   // @@protoc_insertion_point(class_scope:PokerTHMessage)
  private:
   inline void set_has_messagetype();
@@ -9155,8 +9383,12 @@ class PokerTHMessage : public ::google::protobuf::MessageLite {
   inline void clear_has_errormessage();
   inline void set_has_adminremovegamemessage();
   inline void clear_has_adminremovegamemessage();
+  inline void set_has_adminremovegameackmessage();
+  inline void clear_has_adminremovegameackmessage();
   inline void set_has_adminbanplayermessage();
   inline void clear_has_adminbanplayermessage();
+  inline void set_has_adminbanplayerackmessage();
+  inline void clear_has_adminbanplayerackmessage();
   
   ::AnnounceMessage* announcemessage_;
   ::InitMessage* initmessage_;
@@ -9232,11 +9464,13 @@ class PokerTHMessage : public ::google::protobuf::MessageLite {
   ::ReportGameAckMessage* reportgameackmessage_;
   ::ErrorMessage* errormessage_;
   ::AdminRemoveGameMessage* adminremovegamemessage_;
+  ::AdminRemoveGameAckMessage* adminremovegameackmessage_;
   ::AdminBanPlayerMessage* adminbanplayermessage_;
+  ::AdminBanPlayerAckMessage* adminbanplayerackmessage_;
   int messagetype_;
   
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(76 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(78 + 31) / 32];
   
   friend void  protobuf_AddDesc_pokerth_2eproto();
   friend void protobuf_AssignDesc_pokerth_2eproto();
@@ -15665,6 +15899,55 @@ inline void AdminRemoveGameMessage::set_removegameid(::google::protobuf::uint32
 
 // -------------------------------------------------------------------
 
+// AdminRemoveGameAckMessage
+
+// required uint32 removeGameId = 1;
+inline bool AdminRemoveGameAckMessage::has_removegameid() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AdminRemoveGameAckMessage::set_has_removegameid() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AdminRemoveGameAckMessage::clear_has_removegameid() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AdminRemoveGameAckMessage::clear_removegameid() {
+  removegameid_ = 0u;
+  clear_has_removegameid();
+}
+inline ::google::protobuf::uint32 AdminRemoveGameAckMessage::removegameid() const {
+  return removegameid_;
+}
+inline void AdminRemoveGameAckMessage::set_removegameid(::google::protobuf::uint32 value) {
+  set_has_removegameid();
+  removegameid_ = value;
+}
+
+// required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
+inline bool AdminRemoveGameAckMessage::has_removegameresult() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AdminRemoveGameAckMessage::set_has_removegameresult() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AdminRemoveGameAckMessage::clear_has_removegameresult() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AdminRemoveGameAckMessage::clear_removegameresult() {
+  removegameresult_ = 0;
+  clear_has_removegameresult();
+}
+inline ::AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::removegameresult() const {
+  return static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(removegameresult_);
+}
+inline void AdminRemoveGameAckMessage::set_removegameresult(::AdminRemoveGameAckMessage_AdminRemoveGameResult value) {
+  GOOGLE_DCHECK(::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value));
+  set_has_removegameresult();
+  removegameresult_ = value;
+}
+
+// -------------------------------------------------------------------
+
 // AdminBanPlayerMessage
 
 // required uint32 banPlayerId = 1;
@@ -15691,6 +15974,55 @@ inline void AdminBanPlayerMessage::set_banplayerid(::google::protobuf::uint32 va
 
 // -------------------------------------------------------------------
 
+// AdminBanPlayerAckMessage
+
+// required uint32 banPlayerId = 1;
+inline bool AdminBanPlayerAckMessage::has_banplayerid() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AdminBanPlayerAckMessage::set_has_banplayerid() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AdminBanPlayerAckMessage::clear_has_banplayerid() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AdminBanPlayerAckMessage::clear_banplayerid() {
+  banplayerid_ = 0u;
+  clear_has_banplayerid();
+}
+inline ::google::protobuf::uint32 AdminBanPlayerAckMessage::banplayerid() const {
+  return banplayerid_;
+}
+inline void AdminBanPlayerAckMessage::set_banplayerid(::google::protobuf::uint32 value) {
+  set_has_banplayerid();
+  banplayerid_ = value;
+}
+
+// required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
+inline bool AdminBanPlayerAckMessage::has_banplayerresult() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AdminBanPlayerAckMessage::set_has_banplayerresult() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AdminBanPlayerAckMessage::clear_has_banplayerresult() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AdminBanPlayerAckMessage::clear_banplayerresult() {
+  banplayerresult_ = 0;
+  clear_has_banplayerresult();
+}
+inline ::AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banplayerresult() const {
+  return static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(banplayerresult_);
+}
+inline void AdminBanPlayerAckMessage::set_banplayerresult(::AdminBanPlayerAckMessage_AdminBanPlayerResult value) {
+  GOOGLE_DCHECK(::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value));
+  set_has_banplayerresult();
+  banplayerresult_ = value;
+}
+
+// -------------------------------------------------------------------
+
 // PokerTHMessage
 
 // required .PokerTHMessage.PokerTHMessageType messageType = 1;
@@ -17862,16 +18194,45 @@ inline ::AdminRemoveGameMessage* PokerTHMessage::release_adminremovegamemessage(
   return temp;
 }
 
-// optional .AdminBanPlayerMessage adminBanPlayerMessage = 76;
-inline bool PokerTHMessage::has_adminbanplayermessage() const {
+// optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
+inline bool PokerTHMessage::has_adminremovegameackmessage() const {
   return (_has_bits_[2] & 0x00000800u) != 0;
 }
-inline void PokerTHMessage::set_has_adminbanplayermessage() {
+inline void PokerTHMessage::set_has_adminremovegameackmessage() {
   _has_bits_[2] |= 0x00000800u;
 }
-inline void PokerTHMessage::clear_has_adminbanplayermessage() {
+inline void PokerTHMessage::clear_has_adminremovegameackmessage() {
   _has_bits_[2] &= ~0x00000800u;
 }
+inline void PokerTHMessage::clear_adminremovegameackmessage() {
+  if (adminremovegameackmessage_ != NULL) adminremovegameackmessage_->::AdminRemoveGameAckMessage::Clear();
+  clear_has_adminremovegameackmessage();
+}
+inline const ::AdminRemoveGameAckMessage& PokerTHMessage::adminremovegameackmessage() const {
+  return adminremovegameackmessage_ != NULL ? *adminremovegameackmessage_ : *default_instance_->adminremovegameackmessage_;
+}
+inline ::AdminRemoveGameAckMessage* PokerTHMessage::mutable_adminremovegameackmessage() {
+  set_has_adminremovegameackmessage();
+  if (adminremovegameackmessage_ == NULL) adminremovegameackmessage_ = new ::AdminRemoveGameAckMessage;
+  return adminremovegameackmessage_;
+}
+inline ::AdminRemoveGameAckMessage* PokerTHMessage::release_adminremovegameackmessage() {
+  clear_has_adminremovegameackmessage();
+  ::AdminRemoveGameAckMessage* temp = adminremovegameackmessage_;
+  adminremovegameackmessage_ = NULL;
+  return temp;
+}
+
+// optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
+inline bool PokerTHMessage::has_adminbanplayermessage() const {
+  return (_has_bits_[2] & 0x00001000u) != 0;
+}
+inline void PokerTHMessage::set_has_adminbanplayermessage() {
+  _has_bits_[2] |= 0x00001000u;
+}
+inline void PokerTHMessage::clear_has_adminbanplayermessage() {
+  _has_bits_[2] &= ~0x00001000u;
+}
 inline void PokerTHMessage::clear_adminbanplayermessage() {
   if (adminbanplayermessage_ != NULL) adminbanplayermessage_->::AdminBanPlayerMessage::Clear();
   clear_has_adminbanplayermessage();
@@ -17891,6 +18252,35 @@ inline ::AdminBanPlayerMessage* PokerTHMessage::release_adminbanplayermessage()
   return temp;
 }
 
+// optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
+inline bool PokerTHMessage::has_adminbanplayerackmessage() const {
+  return (_has_bits_[2] & 0x00002000u) != 0;
+}
+inline void PokerTHMessage::set_has_adminbanplayerackmessage() {
+  _has_bits_[2] |= 0x00002000u;
+}
+inline void PokerTHMessage::clear_has_adminbanplayerackmessage() {
+  _has_bits_[2] &= ~0x00002000u;
+}
+inline void PokerTHMessage::clear_adminbanplayerackmessage() {
+  if (adminbanplayerackmessage_ != NULL) adminbanplayerackmessage_->::AdminBanPlayerAckMessage::Clear();
+  clear_has_adminbanplayerackmessage();
+}
+inline const ::AdminBanPlayerAckMessage& PokerTHMessage::adminbanplayerackmessage() const {
+  return adminbanplayerackmessage_ != NULL ? *adminbanplayerackmessage_ : *default_instance_->adminbanplayerackmessage_;
+}
+inline ::AdminBanPlayerAckMessage* PokerTHMessage::mutable_adminbanplayerackmessage() {
+  set_has_adminbanplayerackmessage();
+  if (adminbanplayerackmessage_ == NULL) adminbanplayerackmessage_ = new ::AdminBanPlayerAckMessage;
+  return adminbanplayerackmessage_;
+}
+inline ::AdminBanPlayerAckMessage* PokerTHMessage::release_adminbanplayerackmessage() {
+  clear_has_adminbanplayerackmessage();
+  ::AdminBanPlayerAckMessage* temp = adminbanplayerackmessage_;
+  adminbanplayerackmessage_ = NULL;
+  return temp;
+}
+
 
 // @@protoc_insertion_point(namespace_scope)