chore: add cpp proto generate shell and generate cpp proto

CAPI/proto/Message2Clients.grpc.pb.cc

@@ -0,0 +1,525 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: Message2Clients.proto
+
+#include "Message2Clients.pb.h"
+#include "Message2Clients.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace protobuf {
+
+static const char* AvailableService_method_names[] = {
+  "/protobuf.AvailableService/AddPlayer",
+  "/protobuf.AvailableService/Move",
+  "/protobuf.AvailableService/PickProp",
+  "/protobuf.AvailableService/UseProp",
+  "/protobuf.AvailableService/UseSkill",
+  "/protobuf.AvailableService/SendMessage",
+  "/protobuf.AvailableService/FixMachine",
+  "/protobuf.AvailableService/SaveHuman",
+  "/protobuf.AvailableService/Attack",
+  "/protobuf.AvailableService/CarryHuman",
+  "/protobuf.AvailableService/ReleaseHuman",
+  "/protobuf.AvailableService/HangHuman",
+};
+
+std::unique_ptr< AvailableService::Stub> AvailableService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< AvailableService::Stub> stub(new AvailableService::Stub(channel, options));
+  return stub;
+}
+
+AvailableService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
+  : channel_(channel), rpcmethod_AddPlayer_(AvailableService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
+  , rpcmethod_Move_(AvailableService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_PickProp_(AvailableService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_UseProp_(AvailableService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_UseSkill_(AvailableService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_SendMessage_(AvailableService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_FixMachine_(AvailableService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
+  , rpcmethod_SaveHuman_(AvailableService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
+  , rpcmethod_Attack_(AvailableService_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_CarryHuman_(AvailableService_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_ReleaseHuman_(AvailableService_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_HangHuman_(AvailableService_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::ClientReader< ::protobuf::MessageToClient>* AvailableService::Stub::AddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request) {
+  return ::grpc::internal::ClientReaderFactory< ::protobuf::MessageToClient>::Create(channel_.get(), rpcmethod_AddPlayer_, context, request);
+}
+
+void AvailableService::Stub::async::AddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg* request, ::grpc::ClientReadReactor< ::protobuf::MessageToClient>* reactor) {
+  ::grpc::internal::ClientCallbackReaderFactory< ::protobuf::MessageToClient>::Create(stub_->channel_.get(), stub_->rpcmethod_AddPlayer_, context, request, reactor);
+}
+
+::grpc::ClientAsyncReader< ::protobuf::MessageToClient>* AvailableService::Stub::AsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderFactory< ::protobuf::MessageToClient>::Create(channel_.get(), cq, rpcmethod_AddPlayer_, context, request, true, tag);
+}
+
+::grpc::ClientAsyncReader< ::protobuf::MessageToClient>* AvailableService::Stub::PrepareAsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderFactory< ::protobuf::MessageToClient>::Create(channel_.get(), cq, rpcmethod_AddPlayer_, context, request, false, nullptr);
+}
+
+::grpc::Status AvailableService::Stub::Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::protobuf::MoveRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::MoveMsg, ::protobuf::MoveRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Move_, context, request, response);
+}
+
+void AvailableService::Stub::async::Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::MoveMsg, ::protobuf::MoveRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Move_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Move_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::MoveRes>* AvailableService::Stub::PrepareAsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::MoveRes, ::protobuf::MoveMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Move_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::MoveRes>* AvailableService::Stub::AsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncMoveRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::PickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PickProp_, context, request, response);
+}
+
+void AvailableService::Stub::async::PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::PickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PickProp_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PickProp_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::PickMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PickProp_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncPickPropRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UseProp_, context, request, response);
+}
+
+void AvailableService::Stub::async::UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseProp_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseProp_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UseProp_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncUsePropRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UseSkill_, context, request, response);
+}
+
+void AvailableService::Stub::async::UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseSkill_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseSkill_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UseSkill_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncUseSkillRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::SendMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendMessage_, context, request, response);
+}
+
+void AvailableService::Stub::async::SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::SendMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessage_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendMessage_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::SendMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendMessage_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncSendMessageRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::ClientReaderWriter< ::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::FixMachineRaw(::grpc::ClientContext* context) {
+  return ::grpc::internal::ClientReaderWriterFactory< ::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), rpcmethod_FixMachine_, context);
+}
+
+void AvailableService::Stub::async::FixMachine(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::protobuf::IDMsg,::protobuf::BoolRes>* reactor) {
+  ::grpc::internal::ClientCallbackReaderWriterFactory< ::protobuf::IDMsg,::protobuf::BoolRes>::Create(stub_->channel_.get(), stub_->rpcmethod_FixMachine_, context, reactor);
+}
+
+::grpc::ClientAsyncReaderWriter< ::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::AsyncFixMachineRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), cq, rpcmethod_FixMachine_, context, true, tag);
+}
+
+::grpc::ClientAsyncReaderWriter< ::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncFixMachineRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), cq, rpcmethod_FixMachine_, context, false, nullptr);
+}
+
+::grpc::ClientReaderWriter< ::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::SaveHumanRaw(::grpc::ClientContext* context) {
+  return ::grpc::internal::ClientReaderWriterFactory< ::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), rpcmethod_SaveHuman_, context);
+}
+
+void AvailableService::Stub::async::SaveHuman(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::protobuf::IDMsg,::protobuf::BoolRes>* reactor) {
+  ::grpc::internal::ClientCallbackReaderWriterFactory< ::protobuf::IDMsg,::protobuf::BoolRes>::Create(stub_->channel_.get(), stub_->rpcmethod_SaveHuman_, context, reactor);
+}
+
+::grpc::ClientAsyncReaderWriter< ::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::AsyncSaveHumanRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), cq, rpcmethod_SaveHuman_, context, true, tag);
+}
+
+::grpc::ClientAsyncReaderWriter< ::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncSaveHumanRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncReaderWriterFactory< ::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), cq, rpcmethod_SaveHuman_, context, false, nullptr);
+}
+
+::grpc::Status AvailableService::Stub::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Attack_, context, request, response);
+}
+
+void AvailableService::Stub::async::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Attack_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Attack_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::AttackMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Attack_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncAttackRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CarryHuman_, context, request, response);
+}
+
+void AvailableService::Stub::async::CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CarryHuman_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CarryHuman_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CarryHuman_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncCarryHumanRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ReleaseHuman_, context, request, response);
+}
+
+void AvailableService::Stub::async::ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ReleaseHuman_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ReleaseHuman_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ReleaseHuman_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncReleaseHumanRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status AvailableService::Stub::HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HangHuman_, context, request, response);
+}
+
+void AvailableService::Stub::async::HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HangHuman_, context, request, response, std::move(f));
+}
+
+void AvailableService::Stub::async::HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HangHuman_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HangHuman_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::protobuf::BoolRes>* AvailableService::Stub::AsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncHangHumanRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+AvailableService::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[0],
+      ::grpc::internal::RpcMethod::SERVER_STREAMING,
+      new ::grpc::internal::ServerStreamingHandler< AvailableService::Service, ::protobuf::PlayerMsg, ::protobuf::MessageToClient>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::PlayerMsg* req,
+             ::grpc::ServerWriter<::protobuf::MessageToClient>* writer) {
+               return service->AddPlayer(ctx, req, writer);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[1],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::MoveMsg, ::protobuf::MoveRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::MoveMsg* req,
+             ::protobuf::MoveRes* resp) {
+               return service->Move(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[2],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::PickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::PickMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->PickProp(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[3],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::IDMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->UseProp(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[4],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::IDMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->UseSkill(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[5],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::SendMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::SendMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->SendMessage(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[6],
+      ::grpc::internal::RpcMethod::BIDI_STREAMING,
+      new ::grpc::internal::BidiStreamingHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             ::grpc::ServerReaderWriter<::protobuf::BoolRes,
+             ::protobuf::IDMsg>* stream) {
+               return service->FixMachine(ctx, stream);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[7],
+      ::grpc::internal::RpcMethod::BIDI_STREAMING,
+      new ::grpc::internal::BidiStreamingHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             ::grpc::ServerReaderWriter<::protobuf::BoolRes,
+             ::protobuf::IDMsg>* stream) {
+               return service->SaveHuman(ctx, stream);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[8],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::AttackMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->Attack(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[9],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::IDMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->CarryHuman(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[10],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::IDMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->ReleaseHuman(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      AvailableService_method_names[11],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](AvailableService::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::protobuf::IDMsg* req,
+             ::protobuf::BoolRes* resp) {
+               return service->HangHuman(ctx, req, resp);
+             }, this)));
+}
+
+AvailableService::Service::~Service() {
+}
+
+::grpc::Status AvailableService::Service::AddPlayer(::grpc::ServerContext* context, const ::protobuf::PlayerMsg* request, ::grpc::ServerWriter< ::protobuf::MessageToClient>* writer) {
+  (void) context;
+  (void) request;
+  (void) writer;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::Move(::grpc::ServerContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::PickProp(::grpc::ServerContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::UseProp(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::UseSkill(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::SendMessage(::grpc::ServerContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::FixMachine(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::protobuf::BoolRes, ::protobuf::IDMsg>* stream) {
+  (void) context;
+  (void) stream;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::SaveHuman(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::protobuf::BoolRes, ::protobuf::IDMsg>* stream) {
+  (void) context;
+  (void) stream;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::Attack(::grpc::ServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::CarryHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::ReleaseHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status AvailableService::Service::HangHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace protobuf
+

CAPI/proto/Message2Server.grpc.pb.cc

@@ -0,0 +1,25 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: Message2Server.proto
+
+#include "Message2Server.pb.h"
+#include "Message2Server.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace protobuf {
+
+}  // namespace protobuf
+

CAPI/proto/Message2Server.grpc.pb.h

@@ -0,0 +1,35 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: Message2Server.proto
+// Original file comments:
+// Message2Server
+#ifndef GRPC_Message2Server_2eproto__INCLUDED
+#define GRPC_Message2Server_2eproto__INCLUDED
+
+#include "Message2Server.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace protobuf {
+
+}  // namespace protobuf
+
+
+#endif  // GRPC_Message2Server_2eproto__INCLUDED

CAPI/proto/MessageType.grpc.pb.cc

@@ -0,0 +1,25 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: MessageType.proto
+
+#include "MessageType.pb.h"
+#include "MessageType.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace protobuf {
+
+}  // namespace protobuf
+

CAPI/proto/MessageType.grpc.pb.h

@@ -0,0 +1,35 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: MessageType.proto
+// Original file comments:
+// MessageType
+#ifndef GRPC_MessageType_2eproto__INCLUDED
+#define GRPC_MessageType_2eproto__INCLUDED
+
+#include "MessageType.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace protobuf {
+
+}  // namespace protobuf
+
+
+#endif  // GRPC_MessageType_2eproto__INCLUDED

CAPI/proto/MessageType.pb.cc

@@ -0,0 +1,201 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: MessageType.proto
+
+#include "MessageType.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace protobuf {
+}  // namespace protobuf
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_MessageType_2eproto[8];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_MessageType_2eproto = nullptr;
+const uint32_t TableStruct_MessageType_2eproto::offsets[1] = {};
+static constexpr ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema* schemas = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::Message* const* file_default_instances = nullptr;
+
+const char descriptor_table_protodef_MessageType_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\021MessageType.proto\022\010protobuf*]\n\tPlaceTy"
+  "pe\022\023\n\017NULL_PLACE_TYPE\020\000\022\010\n\004WALL\020\001\022\t\n\005GRA"
+  "SS\020\002\022\013\n\007MACHINE\020\003\022\010\n\004GATE\020\004\022\017\n\013HIDDEN_GA"
+  "TE\020\005*8\n\tShapeType\022\023\n\017NULL_SHAPE_TYPE\020\000\022\n"
+  "\n\006CIRCLE\020\001\022\n\n\006SQUARE\020\002*N\n\010PropType\022\022\n\016NU"
+  "LL_PROP_TYPE\020\000\022\n\n\006PTYPE1\020\001\022\n\n\006PTYPE2\020\002\022\n"
+  "\n\006PTYPE3\020\003\022\n\n\006PTYPE4\020\004*d\n\rHumanBuffType\022"
+  "\023\n\017NULL_HBUFF_TYPE\020\000\022\016\n\nHBUFFTYPE1\020\001\022\016\n\n"
+  "HBUFFTYPE2\020\002\022\016\n\nHBUFFTYPE3\020\003\022\016\n\nHBUFFTYP"
+  "E4\020\004*f\n\017ButcherBuffType\022\023\n\017NULL_BBUFF_TY"
+  "PE\020\000\022\016\n\nBBUFFTYPE1\020\001\022\016\n\nBBUFFTYPE2\020\002\022\016\n\n"
+  "BBUFFTYPE3\020\003\022\016\n\nBBUFFTYPE4\020\004*2\n\nPlayerTy"
+  "pe\022\020\n\014HUMAN_PLAYER\020\000\022\022\n\016BUTCHER_PLAYER\020\001"
+  "*`\n\tHumanType\022\023\n\017NULL_HUMAN_TYPE\020\000\022\016\n\nHU"
+  "MANTYPE1\020\001\022\016\n\nHUMANTYPE2\020\002\022\016\n\nHUMANTYPE3"
+  "\020\003\022\016\n\nHUMANTYPE4\020\004*l\n\013ButcherType\022\025\n\021NUL"
+  "L_BUTCHER_TYPE\020\000\022\020\n\014BUTCHERTYPE1\020\001\022\020\n\014BU"
+  "TCHERTYPE2\020\002\022\020\n\014BUTCHERTYPE3\020\003\022\020\n\014BUTCHE"
+  "RTYPE4\020\004b\006proto3"
+  ;
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_MessageType_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_MessageType_2eproto = {
+  false, false, 736, descriptor_table_protodef_MessageType_2eproto, "MessageType.proto", 
+  &descriptor_table_MessageType_2eproto_once, nullptr, 0, 0,
+  schemas, file_default_instances, TableStruct_MessageType_2eproto::offsets,
+  nullptr, file_level_enum_descriptors_MessageType_2eproto, file_level_service_descriptors_MessageType_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_MessageType_2eproto_getter() {
+  return &descriptor_table_MessageType_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_MessageType_2eproto(&descriptor_table_MessageType_2eproto);
+namespace protobuf {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlaceType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[0];
+}
+bool PlaceType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShapeType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[1];
+}
+bool ShapeType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PropType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[2];
+}
+bool PropType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanBuffType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[3];
+}
+bool HumanBuffType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherBuffType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[4];
+}
+bool ButcherBuffType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayerType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[5];
+}
+bool PlayerType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[6];
+}
+bool HumanType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
+  return file_level_enum_descriptors_MessageType_2eproto[7];
+}
+bool ButcherType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace protobuf
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

CAPI/proto/MessageType.pb.h

@@ -0,0 +1,347 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: MessageType.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_MessageType_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_MessageType_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_MessageType_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_MessageType_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_MessageType_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+namespace protobuf {
+
+enum PlaceType : int {
+  NULL_PLACE_TYPE = 0,
+  WALL = 1,
+  GRASS = 2,
+  MACHINE = 3,
+  GATE = 4,
+  HIDDEN_GATE = 5,
+  PlaceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  PlaceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool PlaceType_IsValid(int value);
+constexpr PlaceType PlaceType_MIN = NULL_PLACE_TYPE;
+constexpr PlaceType PlaceType_MAX = HIDDEN_GATE;
+constexpr int PlaceType_ARRAYSIZE = PlaceType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlaceType_descriptor();
+template<typename T>
+inline const std::string& PlaceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlaceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlaceType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlaceType_descriptor(), enum_t_value);
+}
+inline bool PlaceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlaceType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlaceType>(
+    PlaceType_descriptor(), name, value);
+}
+enum ShapeType : int {
+  NULL_SHAPE_TYPE = 0,
+  CIRCLE = 1,
+  SQUARE = 2,
+  ShapeType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  ShapeType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool ShapeType_IsValid(int value);
+constexpr ShapeType ShapeType_MIN = NULL_SHAPE_TYPE;
+constexpr ShapeType ShapeType_MAX = SQUARE;
+constexpr int ShapeType_ARRAYSIZE = ShapeType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShapeType_descriptor();
+template<typename T>
+inline const std::string& ShapeType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ShapeType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ShapeType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ShapeType_descriptor(), enum_t_value);
+}
+inline bool ShapeType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ShapeType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ShapeType>(
+    ShapeType_descriptor(), name, value);
+}
+enum PropType : int {
+  NULL_PROP_TYPE = 0,
+  PTYPE1 = 1,
+  PTYPE2 = 2,
+  PTYPE3 = 3,
+  PTYPE4 = 4,
+  PropType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  PropType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool PropType_IsValid(int value);
+constexpr PropType PropType_MIN = NULL_PROP_TYPE;
+constexpr PropType PropType_MAX = PTYPE4;
+constexpr int PropType_ARRAYSIZE = PropType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PropType_descriptor();
+template<typename T>
+inline const std::string& PropType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PropType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PropType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PropType_descriptor(), enum_t_value);
+}
+inline bool PropType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PropType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PropType>(
+    PropType_descriptor(), name, value);
+}
+enum HumanBuffType : int {
+  NULL_HBUFF_TYPE = 0,
+  HBUFFTYPE1 = 1,
+  HBUFFTYPE2 = 2,
+  HBUFFTYPE3 = 3,
+  HBUFFTYPE4 = 4,
+  HumanBuffType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  HumanBuffType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool HumanBuffType_IsValid(int value);
+constexpr HumanBuffType HumanBuffType_MIN = NULL_HBUFF_TYPE;
+constexpr HumanBuffType HumanBuffType_MAX = HBUFFTYPE4;
+constexpr int HumanBuffType_ARRAYSIZE = HumanBuffType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanBuffType_descriptor();
+template<typename T>
+inline const std::string& HumanBuffType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HumanBuffType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HumanBuffType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HumanBuffType_descriptor(), enum_t_value);
+}
+inline bool HumanBuffType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HumanBuffType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HumanBuffType>(
+    HumanBuffType_descriptor(), name, value);
+}
+enum ButcherBuffType : int {
+  NULL_BBUFF_TYPE = 0,
+  BBUFFTYPE1 = 1,
+  BBUFFTYPE2 = 2,
+  BBUFFTYPE3 = 3,
+  BBUFFTYPE4 = 4,
+  ButcherBuffType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  ButcherBuffType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool ButcherBuffType_IsValid(int value);
+constexpr ButcherBuffType ButcherBuffType_MIN = NULL_BBUFF_TYPE;
+constexpr ButcherBuffType ButcherBuffType_MAX = BBUFFTYPE4;
+constexpr int ButcherBuffType_ARRAYSIZE = ButcherBuffType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherBuffType_descriptor();
+template<typename T>
+inline const std::string& ButcherBuffType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ButcherBuffType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ButcherBuffType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ButcherBuffType_descriptor(), enum_t_value);
+}
+inline bool ButcherBuffType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ButcherBuffType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ButcherBuffType>(
+    ButcherBuffType_descriptor(), name, value);
+}
+enum PlayerType : int {
+  HUMAN_PLAYER = 0,
+  BUTCHER_PLAYER = 1,
+  PlayerType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  PlayerType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool PlayerType_IsValid(int value);
+constexpr PlayerType PlayerType_MIN = HUMAN_PLAYER;
+constexpr PlayerType PlayerType_MAX = BUTCHER_PLAYER;
+constexpr int PlayerType_ARRAYSIZE = PlayerType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayerType_descriptor();
+template<typename T>
+inline const std::string& PlayerType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayerType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayerType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayerType_descriptor(), enum_t_value);
+}
+inline bool PlayerType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayerType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayerType>(
+    PlayerType_descriptor(), name, value);
+}
+enum HumanType : int {
+  NULL_HUMAN_TYPE = 0,
+  HUMANTYPE1 = 1,
+  HUMANTYPE2 = 2,
+  HUMANTYPE3 = 3,
+  HUMANTYPE4 = 4,
+  HumanType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  HumanType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool HumanType_IsValid(int value);
+constexpr HumanType HumanType_MIN = NULL_HUMAN_TYPE;
+constexpr HumanType HumanType_MAX = HUMANTYPE4;
+constexpr int HumanType_ARRAYSIZE = HumanType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanType_descriptor();
+template<typename T>
+inline const std::string& HumanType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HumanType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HumanType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HumanType_descriptor(), enum_t_value);
+}
+inline bool HumanType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HumanType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HumanType>(
+    HumanType_descriptor(), name, value);
+}
+enum ButcherType : int {
+  NULL_BUTCHER_TYPE = 0,
+  BUTCHERTYPE1 = 1,
+  BUTCHERTYPE2 = 2,
+  BUTCHERTYPE3 = 3,
+  BUTCHERTYPE4 = 4,
+  ButcherType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  ButcherType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool ButcherType_IsValid(int value);
+constexpr ButcherType ButcherType_MIN = NULL_BUTCHER_TYPE;
+constexpr ButcherType ButcherType_MAX = BUTCHERTYPE4;
+constexpr int ButcherType_ARRAYSIZE = ButcherType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherType_descriptor();
+template<typename T>
+inline const std::string& ButcherType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ButcherType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ButcherType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ButcherType_descriptor(), enum_t_value);
+}
+inline bool ButcherType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ButcherType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ButcherType>(
+    ButcherType_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::protobuf::PlaceType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::PlaceType>() {
+  return ::protobuf::PlaceType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::ShapeType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::ShapeType>() {
+  return ::protobuf::ShapeType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::PropType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::PropType>() {
+  return ::protobuf::PropType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::HumanBuffType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::HumanBuffType>() {
+  return ::protobuf::HumanBuffType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::ButcherBuffType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::ButcherBuffType>() {
+  return ::protobuf::ButcherBuffType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::PlayerType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::PlayerType>() {
+  return ::protobuf::PlayerType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::HumanType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::HumanType>() {
+  return ::protobuf::HumanType_descriptor();
+}
+template <> struct is_proto_enum< ::protobuf::ButcherType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::protobuf::ButcherType>() {
+  return ::protobuf::ButcherType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_MessageType_2eproto

dependency/proto/Message2Clients.proto

@@ -4,7 +4,6 @@ package protobuf;
 
 import "MessageType.proto";
 import "Message2Server.proto";
-import "google/protobuf/empty.proto";
 
 message MessageOfHuman
 {

dependency/proto/cpp_output.sh

@@ -0,0 +1,8 @@
+protoc Message2Clients.proto --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin`
+protoc Message2Clients.proto --cpp_out=.
+protoc MessageType.proto --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin`
+protoc MessageType.proto --cpp_out=.
+protoc Message2Server.proto --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin`
+protoc Message2Server.proto --cpp_out=.
+mv -f ./*.h ../../CAPI/proto
+mv -f ./*.cc ../../CAPI/proto