THUAI6/CAPI/proto/Message2Clients.grpc.pb.h

// Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: Message2Clients.proto
// Original file comments:
// Message2Client
#ifndef GRPC_Message2Clients_2eproto__INCLUDED
#define GRPC_Message2Clients_2eproto__INCLUDED

#include "Message2Clients.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
{

    class AvailableService final
    {
    public:
        static constexpr char const* service_full_name()
        {
            return "protobuf.AvailableService";
        }
        class StubInterface
        {
        public:
            virtual ~StubInterface()
            {
            }
            // 游戏开局调用一次的服务
            std::unique_ptr<::grpc::ClientReaderInterface<::protobuf::MessageToClient>> AddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request)
            {
                return std::unique_ptr<::grpc::ClientReaderInterface<::protobuf::MessageToClient>>(AddPlayerRaw(context, request));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>> AsyncAddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq, void* tag)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>>(AsyncAddPlayerRaw(context, request, cq, tag));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>> PrepareAsyncAddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>>(PrepareAsyncAddPlayerRaw(context, request, cq));
            }
            // 连接上后等待游戏开始，server会定时通过该服务向所有client发送消息。
            // 游戏过程中玩家执行操作的服务
            virtual ::grpc::Status Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::protobuf::MoveRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>> AsyncMove(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>>(AsyncMoveRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>> PrepareAsyncMove(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>>(PrepareAsyncMoveRaw(context, request, cq));
            }
            virtual ::grpc::Status PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncPickPropRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncPickPropRaw(context, request, cq));
            }
            virtual ::grpc::Status UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncUsePropRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncUsePropRaw(context, request, cq));
            }
            virtual ::grpc::Status UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncUseSkillRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncUseSkillRaw(context, request, cq));
            }
            virtual ::grpc::Status SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncSendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncSendMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncSendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncSendMessageRaw(context, request, cq));
            }
            virtual ::grpc::Status HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncHaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncHaveMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncHaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncHaveMessageRaw(context, request, cq));
            }
            virtual ::grpc::Status GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::MsgRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MsgRes>> AsyncGetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MsgRes>>(AsyncGetMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MsgRes>> PrepareAsyncGetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MsgRes>>(PrepareAsyncGetMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>> FixMachine(::grpc::ClientContext* context)
            {
                return std::unique_ptr<::grpc::ClientReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>>(FixMachineRaw(context));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>> AsyncFixMachine(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>>(AsyncFixMachineRaw(context, cq, tag));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>> PrepareAsyncFixMachine(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>>(PrepareAsyncFixMachineRaw(context, cq));
            }
            // 若正常修复且未被打断则返回修复成功，位置错误/被打断则返回修复失败，下同
            std::unique_ptr<::grpc::ClientReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>> SaveHuman(::grpc::ClientContext* context)
            {
                return std::unique_ptr<::grpc::ClientReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>>(SaveHumanRaw(context));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>> AsyncSaveHuman(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>>(AsyncSaveHumanRaw(context, cq, tag));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>> PrepareAsyncSaveHuman(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>>(PrepareAsyncSaveHumanRaw(context, cq));
            }
            virtual ::grpc::Status Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncAttackRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncAttackRaw(context, request, cq));
            }
            virtual ::grpc::Status CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncCarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncCarryHumanRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncCarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncCarryHumanRaw(context, request, cq));
            }
            virtual ::grpc::Status ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncReleaseHumanRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncReleaseHumanRaw(context, request, cq));
            }
            virtual ::grpc::Status HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncHangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncHangHumanRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncHangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncHangHumanRaw(context, request, cq));
            }
            virtual ::grpc::Status Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncEscape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncEscapeRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncEscape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncEscapeRaw(context, request, cq));
            }
            class async_interface
            {
            public:
                virtual ~async_interface()
                {
                }
                // 游戏开局调用一次的服务
                virtual void AddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg* request, ::grpc::ClientReadReactor<::protobuf::MessageToClient>* reactor) = 0;
                // 连接上后等待游戏开始，server会定时通过该服务向所有client发送消息。
                // 游戏过程中玩家执行操作的服务
                virtual void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void FixMachine(::grpc::ClientContext* context, ::grpc::ClientBidiReactor<::protobuf::IDMsg, ::protobuf::BoolRes>* reactor) = 0;
                // 若正常修复且未被打断则返回修复成功，位置错误/被打断则返回修复失败，下同
                virtual void SaveHuman(::grpc::ClientContext* context, ::grpc::ClientBidiReactor<::protobuf::IDMsg, ::protobuf::BoolRes>* reactor) = 0;
                virtual void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                virtual void Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                virtual void Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
            };
            typedef class async_interface experimental_async_interface;
            virtual class async_interface* async()
            {
                return nullptr;
            }
            class async_interface* experimental_async()
            {
                return async();
            }

        private:
            virtual ::grpc::ClientReaderInterface<::protobuf::MessageToClient>* AddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request) = 0;
            virtual ::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>* AsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
            virtual ::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>* PrepareAsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>* AsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>* PrepareAsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncHaveMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncHaveMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::MsgRes>* AsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::MsgRes>* PrepareAsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>* FixMachineRaw(::grpc::ClientContext* context) = 0;
            virtual ::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>* AsyncFixMachineRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
            virtual ::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>* PrepareAsyncFixMachineRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>* SaveHumanRaw(::grpc::ClientContext* context) = 0;
            virtual ::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>* AsyncSaveHumanRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
            virtual ::grpc::ClientAsyncReaderWriterInterface<::protobuf::IDMsg, ::protobuf::BoolRes>* PrepareAsyncSaveHumanRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncEscapeRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncEscapeRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
        };
        class Stub final : public StubInterface
        {
        public:
            Stub(const std::shared_ptr<::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
            std::unique_ptr<::grpc::ClientReader<::protobuf::MessageToClient>> AddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request)
            {
                return std::unique_ptr<::grpc::ClientReader<::protobuf::MessageToClient>>(AddPlayerRaw(context, request));
            }
            std::unique_ptr<::grpc::ClientAsyncReader<::protobuf::MessageToClient>> AsyncAddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq, void* tag)
            {
                return std::unique_ptr<::grpc::ClientAsyncReader<::protobuf::MessageToClient>>(AsyncAddPlayerRaw(context, request, cq, tag));
            }
            std::unique_ptr<::grpc::ClientAsyncReader<::protobuf::MessageToClient>> PrepareAsyncAddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncReader<::protobuf::MessageToClient>>(PrepareAsyncAddPlayerRaw(context, request, cq));
            }
            ::grpc::Status Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::protobuf::MoveRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>> AsyncMove(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>>(AsyncMoveRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>> PrepareAsyncMove(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>>(PrepareAsyncMoveRaw(context, request, cq));
            }
            ::grpc::Status PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncPickPropRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncPickPropRaw(context, request, cq));
            }
            ::grpc::Status UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncUsePropRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncUsePropRaw(context, request, cq));
            }
            ::grpc::Status UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncUseSkillRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncUseSkillRaw(context, request, cq));
            }
            ::grpc::Status SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncSendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncSendMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncSendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncSendMessageRaw(context, request, cq));
            }
            ::grpc::Status HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncHaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncHaveMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncHaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncHaveMessageRaw(context, request, cq));
            }
            ::grpc::Status GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::MsgRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>> AsyncGetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>>(AsyncGetMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>> PrepareAsyncGetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>>(PrepareAsyncGetMessageRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>> FixMachine(::grpc::ClientContext* context)
            {
                return std::unique_ptr<::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>>(FixMachineRaw(context));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>> AsyncFixMachine(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>>(AsyncFixMachineRaw(context, cq, tag));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>> PrepareAsyncFixMachine(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>>(PrepareAsyncFixMachineRaw(context, cq));
            }
            std::unique_ptr<::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>> SaveHuman(::grpc::ClientContext* context)
            {
                return std::unique_ptr<::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>>(SaveHumanRaw(context));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>> AsyncSaveHuman(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>>(AsyncSaveHumanRaw(context, cq, tag));
            }
            std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>> PrepareAsyncSaveHuman(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>>(PrepareAsyncSaveHumanRaw(context, cq));
            }
            ::grpc::Status Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncAttackRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncAttackRaw(context, request, cq));
            }
            ::grpc::Status CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncCarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncCarryHumanRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncCarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncCarryHumanRaw(context, request, cq));
            }
            ::grpc::Status ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncReleaseHumanRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncReleaseHumanRaw(context, request, cq));
            }
            ::grpc::Status HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncHangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncHangHumanRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncHangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncHangHumanRaw(context, request, cq));
            }
            ::grpc::Status Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncEscape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncEscapeRaw(context, request, cq));
            }
            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncEscape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
            {
                return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncEscapeRaw(context, request, cq));
            }
            class async final :
                public StubInterface::async_interface
            {
            public:
                void AddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg* request, ::grpc::ClientReadReactor<::protobuf::MessageToClient>* reactor) override;
                void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, std::function<void(::grpc::Status)>) override;
                void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response, std::function<void(::grpc::Status)>) override;
                void GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void FixMachine(::grpc::ClientContext* context, ::grpc::ClientBidiReactor<::protobuf::IDMsg, ::protobuf::BoolRes>* reactor) override;
                void SaveHuman(::grpc::ClientContext* context, ::grpc::ClientBidiReactor<::protobuf::IDMsg, ::protobuf::BoolRes>* reactor) override;
                void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                void Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                void Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;

            private:
                friend class Stub;
                explicit async(Stub* stub) :
                    stub_(stub)
                {
                }
                Stub* stub()
                {
                    return stub_;
                }
                Stub* stub_;
            };
            class async* async() override
            {
                return &async_stub_;
            }

        private:
            std::shared_ptr<::grpc::ChannelInterface> channel_;
            class async async_stub_
            {
                this
            };
            ::grpc::ClientReader<::protobuf::MessageToClient>* AddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request) override;
            ::grpc::ClientAsyncReader<::protobuf::MessageToClient>* AsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq, void* tag) override;
            ::grpc::ClientAsyncReader<::protobuf::MessageToClient>* PrepareAsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>* AsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>* PrepareAsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncHaveMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncHaveMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>* AsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>* PrepareAsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* FixMachineRaw(::grpc::ClientContext* context) override;
            ::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* AsyncFixMachineRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
            ::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* PrepareAsyncFixMachineRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* SaveHumanRaw(::grpc::ClientContext* context) override;
            ::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* AsyncSaveHumanRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
            ::grpc::ClientAsyncReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* PrepareAsyncSaveHumanRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncEscapeRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncEscapeRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
            const ::grpc::internal::RpcMethod rpcmethod_AddPlayer_;
            const ::grpc::internal::RpcMethod rpcmethod_Move_;
            const ::grpc::internal::RpcMethod rpcmethod_PickProp_;
            const ::grpc::internal::RpcMethod rpcmethod_UseProp_;
            const ::grpc::internal::RpcMethod rpcmethod_UseSkill_;
            const ::grpc::internal::RpcMethod rpcmethod_SendMessage_;
            const ::grpc::internal::RpcMethod rpcmethod_HaveMessage_;
            const ::grpc::internal::RpcMethod rpcmethod_GetMessage_;
            const ::grpc::internal::RpcMethod rpcmethod_FixMachine_;
            const ::grpc::internal::RpcMethod rpcmethod_SaveHuman_;
            const ::grpc::internal::RpcMethod rpcmethod_Attack_;
            const ::grpc::internal::RpcMethod rpcmethod_CarryHuman_;
            const ::grpc::internal::RpcMethod rpcmethod_ReleaseHuman_;
            const ::grpc::internal::RpcMethod rpcmethod_HangHuman_;
            const ::grpc::internal::RpcMethod rpcmethod_Escape_;
        };
        static std::unique_ptr<Stub> NewStub(const std::shared_ptr<::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

        class Service : public ::grpc::Service
        {
        public:
            Service();
            virtual ~Service();
            // 游戏开局调用一次的服务
            virtual ::grpc::Status AddPlayer(::grpc::ServerContext* context, const ::protobuf::PlayerMsg* request, ::grpc::ServerWriter<::protobuf::MessageToClient>* writer);
            // 连接上后等待游戏开始，server会定时通过该服务向所有client发送消息。
            // 游戏过程中玩家执行操作的服务
            virtual ::grpc::Status Move(::grpc::ServerContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response);
            virtual ::grpc::Status PickProp(::grpc::ServerContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status UseProp(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status UseSkill(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status SendMessage(::grpc::ServerContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status HaveMessage(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status GetMessage(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response);
            virtual ::grpc::Status FixMachine(::grpc::ServerContext* context, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* stream);
            // 若正常修复且未被打断则返回修复成功，位置错误/被打断则返回修复失败，下同
            virtual ::grpc::Status SaveHuman(::grpc::ServerContext* context, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* stream);
            virtual ::grpc::Status Attack(::grpc::ServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status CarryHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status ReleaseHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status HangHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
            virtual ::grpc::Status Escape(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
        };
        template<class BaseClass>
        class WithAsyncMethod_AddPlayer : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_AddPlayer()
            {
                ::grpc::Service::MarkMethodAsync(0);
            }
            ~WithAsyncMethod_AddPlayer() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestAddPlayer(::grpc::ServerContext* context, ::protobuf::PlayerMsg* request, ::grpc::ServerAsyncWriter<::protobuf::MessageToClient>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncServerStreaming(0, context, request, writer, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_Move : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_Move()
            {
                ::grpc::Service::MarkMethodAsync(1);
            }
            ~WithAsyncMethod_Move() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestMove(::grpc::ServerContext* context, ::protobuf::MoveMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::MoveRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_PickProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_PickProp()
            {
                ::grpc::Service::MarkMethodAsync(2);
            }
            ~WithAsyncMethod_PickProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestPickProp(::grpc::ServerContext* context, ::protobuf::PickMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_UseProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_UseProp()
            {
                ::grpc::Service::MarkMethodAsync(3);
            }
            ~WithAsyncMethod_UseProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestUseProp(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_UseSkill : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_UseSkill()
            {
                ::grpc::Service::MarkMethodAsync(4);
            }
            ~WithAsyncMethod_UseSkill() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestUseSkill(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_SendMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_SendMessage()
            {
                ::grpc::Service::MarkMethodAsync(5);
            }
            ~WithAsyncMethod_SendMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestSendMessage(::grpc::ServerContext* context, ::protobuf::SendMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_HaveMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_HaveMessage()
            {
                ::grpc::Service::MarkMethodAsync(6);
            }
            ~WithAsyncMethod_HaveMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HaveMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestHaveMessage(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_GetMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_GetMessage()
            {
                ::grpc::Service::MarkMethodAsync(7);
            }
            ~WithAsyncMethod_GetMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestGetMessage(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::MsgRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_FixMachine : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_FixMachine()
            {
                ::grpc::Service::MarkMethodAsync(8);
            }
            ~WithAsyncMethod_FixMachine() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status FixMachine(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestFixMachine(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncBidiStreaming(8, context, stream, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_SaveHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_SaveHuman()
            {
                ::grpc::Service::MarkMethodAsync(9);
            }
            ~WithAsyncMethod_SaveHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SaveHuman(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestSaveHuman(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncBidiStreaming(9, context, stream, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_Attack : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_Attack()
            {
                ::grpc::Service::MarkMethodAsync(10);
            }
            ~WithAsyncMethod_Attack() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestAttack(::grpc::ServerContext* context, ::protobuf::AttackMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_CarryHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_CarryHuman()
            {
                ::grpc::Service::MarkMethodAsync(11);
            }
            ~WithAsyncMethod_CarryHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status CarryHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestCarryHuman(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_ReleaseHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_ReleaseHuman()
            {
                ::grpc::Service::MarkMethodAsync(12);
            }
            ~WithAsyncMethod_ReleaseHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status ReleaseHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestReleaseHuman(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_HangHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_HangHuman()
            {
                ::grpc::Service::MarkMethodAsync(13);
            }
            ~WithAsyncMethod_HangHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HangHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestHangHuman(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithAsyncMethod_Escape : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithAsyncMethod_Escape()
            {
                ::grpc::Service::MarkMethodAsync(14);
            }
            ~WithAsyncMethod_Escape() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Escape(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestEscape(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        typedef WithAsyncMethod_AddPlayer<WithAsyncMethod_Move<WithAsyncMethod_PickProp<WithAsyncMethod_UseProp<WithAsyncMethod_UseSkill<WithAsyncMethod_SendMessage<WithAsyncMethod_HaveMessage<WithAsyncMethod_GetMessage<WithAsyncMethod_FixMachine<WithAsyncMethod_SaveHuman<WithAsyncMethod_Attack<WithAsyncMethod_CarryHuman<WithAsyncMethod_ReleaseHuman<WithAsyncMethod_HangHuman<WithAsyncMethod_Escape<Service>>>>>>>>>>>>>>> AsyncService;
        template<class BaseClass>
        class WithCallbackMethod_AddPlayer : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_AddPlayer()
            {
                ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackServerStreamingHandler<::protobuf::PlayerMsg, ::protobuf::MessageToClient>([this](::grpc::CallbackServerContext* context, const ::protobuf::PlayerMsg* request)
                                                                                                                                                                { return this->AddPlayer(context, request); }));
            }
            ~WithCallbackMethod_AddPlayer() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerWriteReactor<::protobuf::MessageToClient>* AddPlayer(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_Move : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_Move()
            {
                ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler<::protobuf::MoveMsg, ::protobuf::MoveRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response)
                                                                                                                                            { return this->Move(context, request, response); }));
            }
            void SetMessageAllocatorFor_Move(
                ::grpc::MessageAllocator<::protobuf::MoveMsg, ::protobuf::MoveRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::MoveMsg, ::protobuf::MoveRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_Move() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* Move(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_PickProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_PickProp()
            {
                ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler<::protobuf::PickMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                            { return this->PickProp(context, request, response); }));
            }
            void SetMessageAllocatorFor_PickProp(
                ::grpc::MessageAllocator<::protobuf::PickMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::PickMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_PickProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* PickProp(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_UseProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_UseProp()
            {
                ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                          { return this->UseProp(context, request, response); }));
            }
            void SetMessageAllocatorFor_UseProp(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_UseProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* UseProp(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_UseSkill : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_UseSkill()
            {
                ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                          { return this->UseSkill(context, request, response); }));
            }
            void SetMessageAllocatorFor_UseSkill(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_UseSkill() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* UseSkill(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_SendMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_SendMessage()
            {
                ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler<::protobuf::SendMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                            { return this->SendMessage(context, request, response); }));
            }
            void SetMessageAllocatorFor_SendMessage(
                ::grpc::MessageAllocator<::protobuf::SendMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::SendMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_SendMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* SendMessage(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_HaveMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_HaveMessage()
            {
                ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                          { return this->HaveMessage(context, request, response); }));
            }
            void SetMessageAllocatorFor_HaveMessage(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_HaveMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HaveMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* HaveMessage(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_GetMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_GetMessage()
            {
                ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::MsgRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response)
                                                                                                                                         { return this->GetMessage(context, request, response); }));
            }
            void SetMessageAllocatorFor_GetMessage(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::MsgRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(7);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::MsgRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_GetMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* GetMessage(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_FixMachine : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_FixMachine()
            {
                ::grpc::Service::MarkMethodCallback(8, new ::grpc::internal::CallbackBidiHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context)
                                                                                                                                         { return this->FixMachine(context); }));
            }
            ~WithCallbackMethod_FixMachine() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status FixMachine(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerBidiReactor<::protobuf::IDMsg, ::protobuf::BoolRes>* FixMachine(
                ::grpc::CallbackServerContext* /*context*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_SaveHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_SaveHuman()
            {
                ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackBidiHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context)
                                                                                                                                         { return this->SaveHuman(context); }));
            }
            ~WithCallbackMethod_SaveHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SaveHuman(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerBidiReactor<::protobuf::IDMsg, ::protobuf::BoolRes>* SaveHuman(
                ::grpc::CallbackServerContext* /*context*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_Attack : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_Attack()
            {
                ::grpc::Service::MarkMethodCallback(10, new ::grpc::internal::CallbackUnaryHandler<::protobuf::AttackMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                               { return this->Attack(context, request, response); }));
            }
            void SetMessageAllocatorFor_Attack(
                ::grpc::MessageAllocator<::protobuf::AttackMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(10);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::AttackMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_Attack() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* Attack(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_CarryHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_CarryHuman()
            {
                ::grpc::Service::MarkMethodCallback(11, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                           { return this->CarryHuman(context, request, response); }));
            }
            void SetMessageAllocatorFor_CarryHuman(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(11);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_CarryHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status CarryHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* CarryHuman(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_ReleaseHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_ReleaseHuman()
            {
                ::grpc::Service::MarkMethodCallback(12, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                           { return this->ReleaseHuman(context, request, response); }));
            }
            void SetMessageAllocatorFor_ReleaseHuman(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(12);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_ReleaseHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status ReleaseHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* ReleaseHuman(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_HangHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_HangHuman()
            {
                ::grpc::Service::MarkMethodCallback(13, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                           { return this->HangHuman(context, request, response); }));
            }
            void SetMessageAllocatorFor_HangHuman(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(13);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_HangHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HangHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* HangHuman(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithCallbackMethod_Escape : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithCallbackMethod_Escape()
            {
                ::grpc::Service::MarkMethodCallback(14, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
                                                                                                                                           { return this->Escape(context, request, response); }));
            }
            void SetMessageAllocatorFor_Escape(
                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
            )
            {
                ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(14);
                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
                    ->SetMessageAllocator(allocator);
            }
            ~WithCallbackMethod_Escape() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Escape(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* Escape(
                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
            )
            {
                return nullptr;
            }
        };
        typedef WithCallbackMethod_AddPlayer<WithCallbackMethod_Move<WithCallbackMethod_PickProp<WithCallbackMethod_UseProp<WithCallbackMethod_UseSkill<WithCallbackMethod_SendMessage<WithCallbackMethod_HaveMessage<WithCallbackMethod_GetMessage<WithCallbackMethod_FixMachine<WithCallbackMethod_SaveHuman<WithCallbackMethod_Attack<WithCallbackMethod_CarryHuman<WithCallbackMethod_ReleaseHuman<WithCallbackMethod_HangHuman<WithCallbackMethod_Escape<Service>>>>>>>>>>>>>>> CallbackService;
        typedef CallbackService ExperimentalCallbackService;
        template<class BaseClass>
        class WithGenericMethod_AddPlayer : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_AddPlayer()
            {
                ::grpc::Service::MarkMethodGeneric(0);
            }
            ~WithGenericMethod_AddPlayer() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_Move : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_Move()
            {
                ::grpc::Service::MarkMethodGeneric(1);
            }
            ~WithGenericMethod_Move() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_PickProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_PickProp()
            {
                ::grpc::Service::MarkMethodGeneric(2);
            }
            ~WithGenericMethod_PickProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_UseProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_UseProp()
            {
                ::grpc::Service::MarkMethodGeneric(3);
            }
            ~WithGenericMethod_UseProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_UseSkill : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_UseSkill()
            {
                ::grpc::Service::MarkMethodGeneric(4);
            }
            ~WithGenericMethod_UseSkill() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_SendMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_SendMessage()
            {
                ::grpc::Service::MarkMethodGeneric(5);
            }
            ~WithGenericMethod_SendMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_HaveMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_HaveMessage()
            {
                ::grpc::Service::MarkMethodGeneric(6);
            }
            ~WithGenericMethod_HaveMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HaveMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_GetMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_GetMessage()
            {
                ::grpc::Service::MarkMethodGeneric(7);
            }
            ~WithGenericMethod_GetMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_FixMachine : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_FixMachine()
            {
                ::grpc::Service::MarkMethodGeneric(8);
            }
            ~WithGenericMethod_FixMachine() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status FixMachine(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_SaveHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_SaveHuman()
            {
                ::grpc::Service::MarkMethodGeneric(9);
            }
            ~WithGenericMethod_SaveHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SaveHuman(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_Attack : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_Attack()
            {
                ::grpc::Service::MarkMethodGeneric(10);
            }
            ~WithGenericMethod_Attack() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_CarryHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_CarryHuman()
            {
                ::grpc::Service::MarkMethodGeneric(11);
            }
            ~WithGenericMethod_CarryHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status CarryHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_ReleaseHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_ReleaseHuman()
            {
                ::grpc::Service::MarkMethodGeneric(12);
            }
            ~WithGenericMethod_ReleaseHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status ReleaseHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_HangHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_HangHuman()
            {
                ::grpc::Service::MarkMethodGeneric(13);
            }
            ~WithGenericMethod_HangHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HangHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithGenericMethod_Escape : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithGenericMethod_Escape()
            {
                ::grpc::Service::MarkMethodGeneric(14);
            }
            ~WithGenericMethod_Escape() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Escape(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
        };
        template<class BaseClass>
        class WithRawMethod_AddPlayer : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_AddPlayer()
            {
                ::grpc::Service::MarkMethodRaw(0);
            }
            ~WithRawMethod_AddPlayer() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestAddPlayer(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter<::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncServerStreaming(0, context, request, writer, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_Move : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_Move()
            {
                ::grpc::Service::MarkMethodRaw(1);
            }
            ~WithRawMethod_Move() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestMove(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_PickProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_PickProp()
            {
                ::grpc::Service::MarkMethodRaw(2);
            }
            ~WithRawMethod_PickProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestPickProp(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_UseProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_UseProp()
            {
                ::grpc::Service::MarkMethodRaw(3);
            }
            ~WithRawMethod_UseProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestUseProp(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_UseSkill : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_UseSkill()
            {
                ::grpc::Service::MarkMethodRaw(4);
            }
            ~WithRawMethod_UseSkill() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestUseSkill(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_SendMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_SendMessage()
            {
                ::grpc::Service::MarkMethodRaw(5);
            }
            ~WithRawMethod_SendMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestSendMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_HaveMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_HaveMessage()
            {
                ::grpc::Service::MarkMethodRaw(6);
            }
            ~WithRawMethod_HaveMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HaveMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestHaveMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_GetMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_GetMessage()
            {
                ::grpc::Service::MarkMethodRaw(7);
            }
            ~WithRawMethod_GetMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestGetMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_FixMachine : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_FixMachine()
            {
                ::grpc::Service::MarkMethodRaw(8);
            }
            ~WithRawMethod_FixMachine() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status FixMachine(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestFixMachine(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter<::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncBidiStreaming(8, context, stream, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_SaveHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_SaveHuman()
            {
                ::grpc::Service::MarkMethodRaw(9);
            }
            ~WithRawMethod_SaveHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SaveHuman(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestSaveHuman(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter<::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncBidiStreaming(9, context, stream, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_Attack : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_Attack()
            {
                ::grpc::Service::MarkMethodRaw(10);
            }
            ~WithRawMethod_Attack() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestAttack(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_CarryHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_CarryHuman()
            {
                ::grpc::Service::MarkMethodRaw(11);
            }
            ~WithRawMethod_CarryHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status CarryHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestCarryHuman(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_ReleaseHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_ReleaseHuman()
            {
                ::grpc::Service::MarkMethodRaw(12);
            }
            ~WithRawMethod_ReleaseHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status ReleaseHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestReleaseHuman(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_HangHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_HangHuman()
            {
                ::grpc::Service::MarkMethodRaw(13);
            }
            ~WithRawMethod_HangHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HangHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestHangHuman(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawMethod_Escape : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawMethod_Escape()
            {
                ::grpc::Service::MarkMethodRaw(14);
            }
            ~WithRawMethod_Escape() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Escape(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            void RequestEscape(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
            {
                ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag);
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_AddPlayer : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_AddPlayer()
            {
                ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackServerStreamingHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request)
                                                                                                                                                       { return this->AddPlayer(context, request); }));
            }
            ~WithRawCallbackMethod_AddPlayer() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerWriteReactor<::grpc::ByteBuffer>* AddPlayer(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_Move : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_Move()
            {
                ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->Move(context, request, response); }));
            }
            ~WithRawCallbackMethod_Move() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* Move(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_PickProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_PickProp()
            {
                ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->PickProp(context, request, response); }));
            }
            ~WithRawCallbackMethod_PickProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* PickProp(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_UseProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_UseProp()
            {
                ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->UseProp(context, request, response); }));
            }
            ~WithRawCallbackMethod_UseProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* UseProp(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_UseSkill : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_UseSkill()
            {
                ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->UseSkill(context, request, response); }));
            }
            ~WithRawCallbackMethod_UseSkill() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* UseSkill(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_SendMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_SendMessage()
            {
                ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->SendMessage(context, request, response); }));
            }
            ~WithRawCallbackMethod_SendMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* SendMessage(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_HaveMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_HaveMessage()
            {
                ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->HaveMessage(context, request, response); }));
            }
            ~WithRawCallbackMethod_HaveMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HaveMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* HaveMessage(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_GetMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_GetMessage()
            {
                ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                             { return this->GetMessage(context, request, response); }));
            }
            ~WithRawCallbackMethod_GetMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* GetMessage(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_FixMachine : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_FixMachine()
            {
                ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackBidiHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context)
                                                                                                                                            { return this->FixMachine(context); }));
            }
            ~WithRawCallbackMethod_FixMachine() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status FixMachine(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerBidiReactor<::grpc::ByteBuffer, ::grpc::ByteBuffer>* FixMachine(
                ::grpc::CallbackServerContext* /*context*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_SaveHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_SaveHuman()
            {
                ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackBidiHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context)
                                                                                                                                            { return this->SaveHuman(context); }));
            }
            ~WithRawCallbackMethod_SaveHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status SaveHuman(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* /*stream*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerBidiReactor<::grpc::ByteBuffer, ::grpc::ByteBuffer>* SaveHuman(
                ::grpc::CallbackServerContext* /*context*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_Attack : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_Attack()
            {
                ::grpc::Service::MarkMethodRawCallback(10, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                              { return this->Attack(context, request, response); }));
            }
            ~WithRawCallbackMethod_Attack() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* Attack(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_CarryHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_CarryHuman()
            {
                ::grpc::Service::MarkMethodRawCallback(11, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                              { return this->CarryHuman(context, request, response); }));
            }
            ~WithRawCallbackMethod_CarryHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status CarryHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* CarryHuman(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_ReleaseHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_ReleaseHuman()
            {
                ::grpc::Service::MarkMethodRawCallback(12, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                              { return this->ReleaseHuman(context, request, response); }));
            }
            ~WithRawCallbackMethod_ReleaseHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status ReleaseHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* ReleaseHuman(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_HangHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_HangHuman()
            {
                ::grpc::Service::MarkMethodRawCallback(13, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                              { return this->HangHuman(context, request, response); }));
            }
            ~WithRawCallbackMethod_HangHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status HangHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* HangHuman(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithRawCallbackMethod_Escape : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithRawCallbackMethod_Escape()
            {
                ::grpc::Service::MarkMethodRawCallback(14, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response)
                                                                                                                                              { return this->Escape(context, request, response); }));
            }
            ~WithRawCallbackMethod_Escape() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable synchronous version of this method
            ::grpc::Status Escape(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            virtual ::grpc::ServerUnaryReactor* Escape(
                ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/
            )
            {
                return nullptr;
            }
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_Move : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_Move()
            {
                ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler<::protobuf::MoveMsg, ::protobuf::MoveRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::MoveMsg, ::protobuf::MoveRes>* streamer)
                                                                                                                                            { return this->StreamedMove(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_Move() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedMove(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::MoveMsg, ::protobuf::MoveRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_PickProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_PickProp()
            {
                ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler<::protobuf::PickMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PickMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                            { return this->StreamedPickProp(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_PickProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedPickProp(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PickMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_UseProp : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_UseProp()
            {
                ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                          { return this->StreamedUseProp(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_UseProp() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedUseProp(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_UseSkill : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_UseSkill()
            {
                ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                          { return this->StreamedUseSkill(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_UseSkill() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedUseSkill(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_SendMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_SendMessage()
            {
                ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler<::protobuf::SendMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::SendMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                            { return this->StreamedSendMessage(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_SendMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedSendMessage(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::SendMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_HaveMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_HaveMessage()
            {
                ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                          { return this->StreamedHaveMessage(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_HaveMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status HaveMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedHaveMessage(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_GetMessage : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_GetMessage()
            {
                ::grpc::Service::MarkMethodStreamed(7, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::MsgRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::MsgRes>* streamer)
                                                                                                                                         { return this->StreamedGetMessage(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_GetMessage() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::MsgRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedGetMessage(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::MsgRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_Attack : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_Attack()
            {
                ::grpc::Service::MarkMethodStreamed(10, new ::grpc::internal::StreamedUnaryHandler<::protobuf::AttackMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::AttackMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                               { return this->StreamedAttack(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_Attack() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedAttack(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::AttackMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_CarryHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_CarryHuman()
            {
                ::grpc::Service::MarkMethodStreamed(11, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                           { return this->StreamedCarryHuman(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_CarryHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status CarryHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedCarryHuman(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_ReleaseHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_ReleaseHuman()
            {
                ::grpc::Service::MarkMethodStreamed(12, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                           { return this->StreamedReleaseHuman(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_ReleaseHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status ReleaseHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedReleaseHuman(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_HangHuman : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_HangHuman()
            {
                ::grpc::Service::MarkMethodStreamed(13, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                           { return this->StreamedHangHuman(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_HangHuman() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status HangHuman(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedHangHuman(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        template<class BaseClass>
        class WithStreamedUnaryMethod_Escape : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithStreamedUnaryMethod_Escape()
            {
                ::grpc::Service::MarkMethodStreamed(14, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
                                                                                                                                           { return this->StreamedEscape(context, streamer); }));
            }
            ~WithStreamedUnaryMethod_Escape() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status Escape(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with streamed unary
            virtual ::grpc::Status StreamedEscape(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
        };
        typedef WithStreamedUnaryMethod_Move<WithStreamedUnaryMethod_PickProp<WithStreamedUnaryMethod_UseProp<WithStreamedUnaryMethod_UseSkill<WithStreamedUnaryMethod_SendMessage<WithStreamedUnaryMethod_HaveMessage<WithStreamedUnaryMethod_GetMessage<WithStreamedUnaryMethod_Attack<WithStreamedUnaryMethod_CarryHuman<WithStreamedUnaryMethod_ReleaseHuman<WithStreamedUnaryMethod_HangHuman<WithStreamedUnaryMethod_Escape<Service>>>>>>>>>>>> StreamedUnaryService;
        template<class BaseClass>
        class WithSplitStreamingMethod_AddPlayer : public BaseClass
        {
        private:
            void BaseClassMustBeDerivedFromService(const Service* /*service*/)
            {
            }

        public:
            WithSplitStreamingMethod_AddPlayer()
            {
                ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::SplitServerStreamingHandler<::protobuf::PlayerMsg, ::protobuf::MessageToClient>([this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer<::protobuf::PlayerMsg, ::protobuf::MessageToClient>* streamer)
                                                                                                                                                             { return this->StreamedAddPlayer(context, streamer); }));
            }
            ~WithSplitStreamingMethod_AddPlayer() override
            {
                BaseClassMustBeDerivedFromService(this);
            }
            // disable regular version of this method
            ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override
            {
                abort();
                return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
            }
            // replace default version of method with split streamed
            virtual ::grpc::Status StreamedAddPlayer(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer<::protobuf::PlayerMsg, ::protobuf::MessageToClient>* server_split_streamer) = 0;
        };
        typedef WithSplitStreamingMethod_AddPlayer<Service> SplitStreamedService;
        typedef WithSplitStreamingMethod_AddPlayer<WithStreamedUnaryMethod_Move<WithStreamedUnaryMethod_PickProp<WithStreamedUnaryMethod_UseProp<WithStreamedUnaryMethod_UseSkill<WithStreamedUnaryMethod_SendMessage<WithStreamedUnaryMethod_HaveMessage<WithStreamedUnaryMethod_GetMessage<WithStreamedUnaryMethod_Attack<WithStreamedUnaryMethod_CarryHuman<WithStreamedUnaryMethod_ReleaseHuman<WithStreamedUnaryMethod_HangHuman<WithStreamedUnaryMethod_Escape<Service>>>>>>>>>>>>> StreamedService;
    };

}  // namespace protobuf

#endif  // GRPC_Message2Clients_2eproto__INCLUDED