refactor(proto): 🎨 rename proto messages

CAPI/API/include/constants.h

@@ -4,5 +4,15 @@
 
 namespace Constants
 {
-}
+    static const constexpr inline numOfGridPerCell = 1000;
+
+    struct HumanConstants
+    {
+    };
+
+    struct ButcherConstants
+    {
+    };
+
+}  // namespace Constants
 #endif

CAPI/proto/Message2Server.pb.cc

@@ -110,28 +110,28 @@ namespace protobuf
         };
     };
     PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SendMsgDefaultTypeInternal _SendMsg_default_instance_;
-    PROTOBUF_CONSTEXPR AttackMsg::AttackMsg(
+    PROTOBUF_CONSTEXPR TrickMsg::TrickMsg(
         ::_pbi::ConstantInitialized
     ) :
         _impl_{
             /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.angle_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}}
     {
     }
-    struct AttackMsgDefaultTypeInternal
+    struct TrickMsgDefaultTypeInternal
     {
-        PROTOBUF_CONSTEXPR AttackMsgDefaultTypeInternal() :
+        PROTOBUF_CONSTEXPR TrickMsgDefaultTypeInternal() :
             _instance(::_pbi::ConstantInitialized{})
         {
         }
-        ~AttackMsgDefaultTypeInternal()
+        ~TrickMsgDefaultTypeInternal()
         {
         }
         union
         {
-            AttackMsg _instance;
+            TrickMsg _instance;
         };
     };
-    PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttackMsgDefaultTypeInternal _AttackMsg_default_instance_;
+    PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrickMsgDefaultTypeInternal _TrickMsg_default_instance_;
     PROTOBUF_CONSTEXPR IDMsg::IDMsg(
         ::_pbi::ConstantInitialized
     ) :
@@ -198,13 +198,13 @@ const uint32_t TableStruct_Message2Server_2eproto::offsets[] PROTOBUF_SECTION_VA
     PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.to_player_id_),
     PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.message_),
     ~0u,  // no _has_bits_
-    PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::TrickMsg, _internal_metadata_),
     ~0u,  // no _extensions_
     ~0u,  // no _oneof_case_
     ~0u,  // no _weak_field_map_
     ~0u,  // no _inlined_string_donated_
-    PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _impl_.player_id_),
-    PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _impl_.angle_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::TrickMsg, _impl_.player_id_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::TrickMsg, _impl_.angle_),
     ~0u,  // no _has_bits_
     PROTOBUF_FIELD_OFFSET(::protobuf::IDMsg, _internal_metadata_),
     ~0u,  // no _extensions_
@@ -218,7 +218,7 @@ static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protode
     {11, -1, -1, sizeof(::protobuf::MoveMsg)},
     {20, -1, -1, sizeof(::protobuf::PickMsg)},
     {28, -1, -1, sizeof(::protobuf::SendMsg)},
-    {37, -1, -1, sizeof(::protobuf::AttackMsg)},
+    {37, -1, -1, sizeof(::protobuf::TrickMsg)},
     {45, -1, -1, sizeof(::protobuf::IDMsg)},
 };
 
@@ -227,25 +227,25 @@ static const ::_pb::Message* const file_default_instances[] = {
     &::protobuf::_MoveMsg_default_instance_._instance,
     &::protobuf::_PickMsg_default_instance_._instance,
     &::protobuf::_SendMsg_default_instance_._instance,
-    &::protobuf::_AttackMsg_default_instance_._instance,
+    &::protobuf::_TrickMsg_default_instance_._instance,
     &::protobuf::_IDMsg_default_instance_._instance,
 };
 
 const char descriptor_table_protodef_Message2Server_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
     "\n\024Message2Server.proto\022\010protobuf\032\021Messag"
-    "eType.proto\"\257\001\n\tPlayerMsg\022\021\n\tplayer_id\030\001"
+    "eType.proto\"\263\001\n\tPlayerMsg\022\021\n\tplayer_id\030\001"
     " \001(\003\022)\n\013player_type\030\002 \001(\0162\024.protobuf.Pla"
-    "yerType\022)\n\nhuman_type\030\003 \001(\0162\023.protobuf.H"
-    "umanTypeH\000\022-\n\014butcher_type\030\004 \001(\0162\025.proto"
-    "buf.ButcherTypeH\000B\n\n\010job_type\"I\n\007MoveMsg"
-    "\022\021\n\tplayer_id\030\001 \001(\003\022\r\n\005angle\030\002 \001(\001\022\034\n\024ti"
-    "me_in_milliseconds\030\003 \001(\003\"C\n\007PickMsg\022\021\n\tp"
-    "layer_id\030\001 \001(\003\022%\n\tprop_type\030\002 \001(\0162\022.prot"
-    "obuf.PropType\"C\n\007SendMsg\022\021\n\tplayer_id\030\001 "
-    "\001(\003\022\024\n\014to_player_id\030\002 \001(\003\022\017\n\007message\030\003 \001"
-    "(\t\"-\n\tAttackMsg\022\021\n\tplayer_id\030\001 \001(\003\022\r\n\005an"
-    "gle\030\002 \001(\001\"\032\n\005IDMsg\022\021\n\tplayer_id\030\001 \001(\003b\006p"
-    "roto3";
+    "yerType\022-\n\014student_type\030\003 \001(\0162\025.protobuf"
+    ".StudentTypeH\000\022-\n\014tricker_type\030\004 \001(\0162\025.p"
+    "rotobuf.TrickerTypeH\000B\n\n\010job_type\"I\n\007Mov"
+    "eMsg\022\021\n\tplayer_id\030\001 \001(\003\022\r\n\005angle\030\002 \001(\001\022\034"
+    "\n\024time_in_milliseconds\030\003 \001(\003\"C\n\007PickMsg\022"
+    "\021\n\tplayer_id\030\001 \001(\003\022%\n\tprop_type\030\002 \001(\0162\022."
+    "protobuf.PropType\"C\n\007SendMsg\022\021\n\tplayer_i"
+    "d\030\001 \001(\003\022\024\n\014to_player_id\030\002 \001(\003\022\017\n\007message"
+    "\030\003 \001(\t\",\n\010TrickMsg\022\021\n\tplayer_id\030\001 \001(\003\022\r\n"
+    "\005angle\030\002 \001(\001\"\032\n\005IDMsg\022\021\n\tplayer_id\030\001 \001(\003"
+    "b\006proto3";
 static const ::_pbi::DescriptorTable* const descriptor_table_Message2Server_2eproto_deps[1] = {
     &::descriptor_table_MessageType_2eproto,
 };
@@ -253,7 +253,7 @@ static ::_pbi::once_flag descriptor_table_Message2Server_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_Message2Server_2eproto = {
     false,
     false,
-    525,
+    528,
     descriptor_table_protodef_Message2Server_2eproto,
     "Message2Server.proto",
     &descriptor_table_Message2Server_2eproto_once,
@@ -303,14 +303,14 @@ namespace protobuf
         clear_has_job_type();
         switch (from.job_type_case())
         {
-            case kHumanType:
+            case kStudentType:
                 {
-                    _this->_internal_set_human_type(from._internal_human_type());
+                    _this->_internal_set_student_type(from._internal_student_type());
                     break;
                 }
-            case kButcherType:
+            case kTrickerType:
                 {
-                    _this->_internal_set_butcher_type(from._internal_butcher_type());
+                    _this->_internal_set_tricker_type(from._internal_tricker_type());
                     break;
                 }
             case JOB_TYPE_NOT_SET:
@@ -362,12 +362,12 @@ namespace protobuf
         // @@protoc_insertion_point(one_of_clear_start:protobuf.PlayerMsg)
         switch (job_type_case())
         {
-            case kHumanType:
+            case kStudentType:
                 {
                     // No need to clear
                     break;
                 }
-            case kButcherType:
+            case kTrickerType:
                 {
                     // No need to clear
                     break;
@@ -424,24 +424,24 @@ namespace protobuf
                     else
                         goto handle_unusual;
                     continue;
-                // .protobuf.HumanType human_type = 3;
+                // .protobuf.StudentType student_type = 3;
                 case 3:
                     if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24))
                     {
                         uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
                         CHK_(ptr);
-                        _internal_set_human_type(static_cast<::protobuf::HumanType>(val));
+                        _internal_set_student_type(static_cast<::protobuf::StudentType>(val));
                     }
                     else
                         goto handle_unusual;
                     continue;
-                // .protobuf.ButcherType butcher_type = 4;
+                // .protobuf.TrickerType tricker_type = 4;
                 case 4:
                     if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32))
                     {
                         uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
                         CHK_(ptr);
-                        _internal_set_butcher_type(static_cast<::protobuf::ButcherType>(val));
+                        _internal_set_tricker_type(static_cast<::protobuf::TrickerType>(val));
                     }
                     else
                         goto handle_unusual;
@@ -496,21 +496,21 @@ namespace protobuf
             );
         }
 
-        // .protobuf.HumanType human_type = 3;
-        if (_internal_has_human_type())
+        // .protobuf.StudentType student_type = 3;
+        if (_internal_has_student_type())
         {
             target = stream->EnsureSpace(target);
             target = ::_pbi::WireFormatLite::WriteEnumToArray(
-                3, this->_internal_human_type(), target
+                3, this->_internal_student_type(), target
             );
         }
 
-        // .protobuf.ButcherType butcher_type = 4;
-        if (_internal_has_butcher_type())
+        // .protobuf.TrickerType tricker_type = 4;
+        if (_internal_has_tricker_type())
         {
             target = stream->EnsureSpace(target);
             target = ::_pbi::WireFormatLite::WriteEnumToArray(
-                4, this->_internal_butcher_type(), target
+                4, this->_internal_tricker_type(), target
             );
         }
 
@@ -548,18 +548,18 @@ namespace protobuf
 
         switch (job_type_case())
         {
-            // .protobuf.HumanType human_type = 3;
-            case kHumanType:
+            // .protobuf.StudentType student_type = 3;
+            case kStudentType:
                 {
                     total_size += 1 +
-                                  ::_pbi::WireFormatLite::EnumSize(this->_internal_human_type());
+                                  ::_pbi::WireFormatLite::EnumSize(this->_internal_student_type());
                     break;
                 }
-            // .protobuf.ButcherType butcher_type = 4;
-            case kButcherType:
+            // .protobuf.TrickerType tricker_type = 4;
+            case kTrickerType:
                 {
                     total_size += 1 +
-                                  ::_pbi::WireFormatLite::EnumSize(this->_internal_butcher_type());
+                                  ::_pbi::WireFormatLite::EnumSize(this->_internal_tricker_type());
                     break;
                 }
             case JOB_TYPE_NOT_SET:
@@ -597,14 +597,14 @@ namespace protobuf
         }
         switch (from.job_type_case())
         {
-            case kHumanType:
+            case kStudentType:
                 {
-                    _this->_internal_set_human_type(from._internal_human_type());
+                    _this->_internal_set_student_type(from._internal_student_type());
                     break;
                 }
-            case kButcherType:
+            case kTrickerType:
                 {
-                    _this->_internal_set_butcher_type(from._internal_butcher_type());
+                    _this->_internal_set_tricker_type(from._internal_tricker_type());
                     break;
                 }
             case JOB_TYPE_NOT_SET:
@@ -1472,31 +1472,31 @@ namespace protobuf
 
     // ===================================================================
 
-    class AttackMsg::_Internal
+    class TrickMsg::_Internal
     {
     public:
     };
 
-    AttackMsg::AttackMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) :
+    TrickMsg::TrickMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) :
         ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned)
     {
         SharedCtor(arena, is_message_owned);
-        // @@protoc_insertion_point(arena_constructor:protobuf.AttackMsg)
+        // @@protoc_insertion_point(arena_constructor:protobuf.TrickMsg)
     }
-    AttackMsg::AttackMsg(const AttackMsg& from) :
+    TrickMsg::TrickMsg(const TrickMsg& from) :
         ::PROTOBUF_NAMESPACE_ID::Message()
     {
-        AttackMsg* const _this = this;
+        TrickMsg* const _this = this;
         (void)_this;
         new (&_impl_) Impl_{
             decltype(_impl_.player_id_){}, decltype(_impl_.angle_){}, /*decltype(_impl_._cached_size_)*/ {}};
 
         _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
         ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast<size_t>(reinterpret_cast<char*>(&_impl_.angle_) - reinterpret_cast<char*>(&_impl_.player_id_)) + sizeof(_impl_.angle_));
-        // @@protoc_insertion_point(copy_constructor:protobuf.AttackMsg)
+        // @@protoc_insertion_point(copy_constructor:protobuf.TrickMsg)
     }
 
-    inline void AttackMsg::SharedCtor(
+    inline void TrickMsg::SharedCtor(
         ::_pb::Arena* arena, bool is_message_owned
     )
     {
@@ -1506,9 +1506,9 @@ namespace protobuf
             decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.angle_){0}, /*decltype(_impl_._cached_size_)*/ {}};
     }
 
-    AttackMsg::~AttackMsg()
+    TrickMsg::~TrickMsg()
     {
-        // @@protoc_insertion_point(destructor:protobuf.AttackMsg)
+        // @@protoc_insertion_point(destructor:protobuf.TrickMsg)
         if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>())
         {
             (void)arena;
@@ -1517,19 +1517,19 @@ namespace protobuf
         SharedDtor();
     }
 
-    inline void AttackMsg::SharedDtor()
+    inline void TrickMsg::SharedDtor()
     {
         GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
     }
 
-    void AttackMsg::SetCachedSize(int size) const
+    void TrickMsg::SetCachedSize(int size) const
     {
         _impl_._cached_size_.Set(size);
     }
 
-    void AttackMsg::Clear()
+    void TrickMsg::Clear()
     {
-        // @@protoc_insertion_point(message_clear_start:protobuf.AttackMsg)
+        // @@protoc_insertion_point(message_clear_start:protobuf.TrickMsg)
         uint32_t cached_has_bits = 0;
         // Prevent compiler warnings about cached_has_bits being unused
         (void)cached_has_bits;
@@ -1538,7 +1538,7 @@ namespace protobuf
         _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
     }
 
-    const char* AttackMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
+    const char* TrickMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
     {
 #define CHK_(x)                       \
     if (PROTOBUF_PREDICT_FALSE(!(x))) \
@@ -1595,11 +1595,11 @@ namespace protobuf
 #undef CHK_
     }
 
-    uint8_t* AttackMsg::_InternalSerialize(
+    uint8_t* TrickMsg::_InternalSerialize(
         uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
     ) const
     {
-        // @@protoc_insertion_point(serialize_to_array_start:protobuf.AttackMsg)
+        // @@protoc_insertion_point(serialize_to_array_start:protobuf.TrickMsg)
         uint32_t cached_has_bits = 0;
         (void)cached_has_bits;
 
@@ -1627,13 +1627,13 @@ namespace protobuf
                 _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream
             );
         }
-        // @@protoc_insertion_point(serialize_to_array_end:protobuf.AttackMsg)
+        // @@protoc_insertion_point(serialize_to_array_end:protobuf.TrickMsg)
         return target;
     }
 
-    size_t AttackMsg::ByteSizeLong() const
+    size_t TrickMsg::ByteSizeLong() const
     {
-        // @@protoc_insertion_point(message_byte_size_start:protobuf.AttackMsg)
+        // @@protoc_insertion_point(message_byte_size_start:protobuf.TrickMsg)
         size_t total_size = 0;
 
         uint32_t cached_has_bits = 0;
@@ -1659,19 +1659,19 @@ namespace protobuf
         return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
     }
 
-    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AttackMsg::_class_data_ = {
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TrickMsg::_class_data_ = {
         ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-        AttackMsg::MergeImpl};
-    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* AttackMsg::GetClassData() const
+        TrickMsg::MergeImpl};
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* TrickMsg::GetClassData() const
     {
         return &_class_data_;
     }
 
-    void AttackMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg)
+    void TrickMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg)
     {
-        auto* const _this = static_cast<AttackMsg*>(&to_msg);
-        auto& from = static_cast<const AttackMsg&>(from_msg);
-        // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.AttackMsg)
+        auto* const _this = static_cast<TrickMsg*>(&to_msg);
+        auto& from = static_cast<const TrickMsg&>(from_msg);
+        // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.TrickMsg)
         GOOGLE_DCHECK_NE(&from, _this);
         uint32_t cached_has_bits = 0;
         (void)cached_has_bits;
@@ -1691,32 +1691,32 @@ namespace protobuf
         _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
     }
 
-    void AttackMsg::CopyFrom(const AttackMsg& from)
+    void TrickMsg::CopyFrom(const TrickMsg& from)
     {
-        // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.AttackMsg)
+        // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.TrickMsg)
         if (&from == this)
             return;
         Clear();
         MergeFrom(from);
     }
 
-    bool AttackMsg::IsInitialized() const
+    bool TrickMsg::IsInitialized() const
     {
         return true;
     }
 
-    void AttackMsg::InternalSwap(AttackMsg* other)
+    void TrickMsg::InternalSwap(TrickMsg* other)
     {
         using std::swap;
         _internal_metadata_.InternalSwap(&other->_internal_metadata_);
         ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-            PROTOBUF_FIELD_OFFSET(AttackMsg, _impl_.angle_) + sizeof(AttackMsg::_impl_.angle_) - PROTOBUF_FIELD_OFFSET(AttackMsg, _impl_.player_id_)>(
+            PROTOBUF_FIELD_OFFSET(TrickMsg, _impl_.angle_) + sizeof(TrickMsg::_impl_.angle_) - PROTOBUF_FIELD_OFFSET(TrickMsg, _impl_.player_id_)>(
             reinterpret_cast<char*>(&_impl_.player_id_),
             reinterpret_cast<char*>(&other->_impl_.player_id_)
         );
     }
 
-    ::PROTOBUF_NAMESPACE_ID::Metadata AttackMsg::GetMetadata() const
+    ::PROTOBUF_NAMESPACE_ID::Metadata TrickMsg::GetMetadata() const
     {
         return ::_pbi::AssignDescriptors(
             &descriptor_table_Message2Server_2eproto_getter, &descriptor_table_Message2Server_2eproto_once, file_level_metadata_Message2Server_2eproto[4]
@@ -1961,10 +1961,10 @@ PROTOBUF_NOINLINE ::protobuf::SendMsg*
     return Arena::CreateMessageInternal<::protobuf::SendMsg>(arena);
 }
 template<>
-PROTOBUF_NOINLINE ::protobuf::AttackMsg*
-    Arena::CreateMaybeMessage<::protobuf::AttackMsg>(Arena* arena)
+PROTOBUF_NOINLINE ::protobuf::TrickMsg*
+    Arena::CreateMaybeMessage<::protobuf::TrickMsg>(Arena* arena)
 {
-    return Arena::CreateMessageInternal<::protobuf::AttackMsg>(arena);
+    return Arena::CreateMessageInternal<::protobuf::TrickMsg>(arena);
 }
 template<>
 PROTOBUF_NOINLINE ::protobuf::IDMsg*

CAPI/proto/Message2Server.pb.h

@@ -13,7 +13,7 @@
 #error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.
@@ -49,9 +49,6 @@ struct TableStruct_Message2Server_2eproto
 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Message2Server_2eproto;
 namespace protobuf
 {
-    class AttackMsg;
-    struct AttackMsgDefaultTypeInternal;
-    extern AttackMsgDefaultTypeInternal _AttackMsg_default_instance_;
     class IDMsg;
     struct IDMsgDefaultTypeInternal;
     extern IDMsgDefaultTypeInternal _IDMsg_default_instance_;
@@ -67,11 +64,12 @@ namespace protobuf
     class SendMsg;
     struct SendMsgDefaultTypeInternal;
     extern SendMsgDefaultTypeInternal _SendMsg_default_instance_;
+    class TrickMsg;
+    struct TrickMsgDefaultTypeInternal;
+    extern TrickMsgDefaultTypeInternal _TrickMsg_default_instance_;
 }  // namespace protobuf
 PROTOBUF_NAMESPACE_OPEN
 template<>
-::protobuf::AttackMsg* Arena::CreateMaybeMessage<::protobuf::AttackMsg>(Arena*);
-template<>
 ::protobuf::IDMsg* Arena::CreateMaybeMessage<::protobuf::IDMsg>(Arena*);
 template<>
 ::protobuf::MoveMsg* Arena::CreateMaybeMessage<::protobuf::MoveMsg>(Arena*);
@@ -81,6 +79,8 @@ template<>
 ::protobuf::PlayerMsg* Arena::CreateMaybeMessage<::protobuf::PlayerMsg>(Arena*);
 template<>
 ::protobuf::SendMsg* Arena::CreateMaybeMessage<::protobuf::SendMsg>(Arena*);
+template<>
+::protobuf::TrickMsg* Arena::CreateMaybeMessage<::protobuf::TrickMsg>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace protobuf
 {
@@ -148,8 +148,8 @@ namespace protobuf
         }
         enum JobTypeCase
         {
-            kHumanType = 3,
-            kButcherType = 4,
+            kStudentType = 3,
+            kTrickerType = 4,
             JOB_TYPE_NOT_SET = 0,
         };
 
@@ -254,8 +254,8 @@ namespace protobuf
         {
             kPlayerIdFieldNumber = 1,
             kPlayerTypeFieldNumber = 2,
-            kHumanTypeFieldNumber = 3,
-            kButcherTypeFieldNumber = 4,
+            kStudentTypeFieldNumber = 3,
+            kTrickerTypeFieldNumber = 4,
         };
         // int64 player_id = 1;
         void clear_player_id();
@@ -277,36 +277,36 @@ namespace protobuf
         void _internal_set_player_type(::protobuf::PlayerType value);
 
     public:
-        // .protobuf.HumanType human_type = 3;
-        bool has_human_type() const;
+        // .protobuf.StudentType student_type = 3;
+        bool has_student_type() const;
 
     private:
-        bool _internal_has_human_type() const;
+        bool _internal_has_student_type() const;
 
     public:
-        void clear_human_type();
-        ::protobuf::HumanType human_type() const;
-        void set_human_type(::protobuf::HumanType value);
+        void clear_student_type();
+        ::protobuf::StudentType student_type() const;
+        void set_student_type(::protobuf::StudentType value);
 
     private:
-        ::protobuf::HumanType _internal_human_type() const;
-        void _internal_set_human_type(::protobuf::HumanType value);
+        ::protobuf::StudentType _internal_student_type() const;
+        void _internal_set_student_type(::protobuf::StudentType value);
 
     public:
-        // .protobuf.ButcherType butcher_type = 4;
-        bool has_butcher_type() const;
+        // .protobuf.TrickerType tricker_type = 4;
+        bool has_tricker_type() const;
 
     private:
-        bool _internal_has_butcher_type() const;
+        bool _internal_has_tricker_type() const;
 
     public:
-        void clear_butcher_type();
-        ::protobuf::ButcherType butcher_type() const;
-        void set_butcher_type(::protobuf::ButcherType value);
+        void clear_tricker_type();
+        ::protobuf::TrickerType tricker_type() const;
+        void set_tricker_type(::protobuf::TrickerType value);
 
     private:
-        ::protobuf::ButcherType _internal_butcher_type() const;
-        void _internal_set_butcher_type(::protobuf::ButcherType value);
+        ::protobuf::TrickerType _internal_tricker_type() const;
+        void _internal_set_tricker_type(::protobuf::TrickerType value);
 
     public:
         void clear_job_type();
@@ -315,8 +315,8 @@ namespace protobuf
 
     private:
         class _Internal;
-        void set_has_human_type();
-        void set_has_butcher_type();
+        void set_has_student_type();
+        void set_has_tricker_type();
 
         inline bool has_job_type() const;
         inline void clear_has_job_type();
@@ -336,8 +336,8 @@ namespace protobuf
                 {
                 }
                 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-                int human_type_;
-                int butcher_type_;
+                int student_type_;
+                int tricker_type_;
             } job_type_;
             mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
             uint32_t _oneof_case_[1];
@@ -991,31 +991,31 @@ namespace protobuf
     };
     // -------------------------------------------------------------------
 
-    class AttackMsg final :
-        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.AttackMsg) */
+    class TrickMsg final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.TrickMsg) */
     {
     public:
-        inline AttackMsg() :
-            AttackMsg(nullptr)
+        inline TrickMsg() :
+            TrickMsg(nullptr)
         {
         }
-        ~AttackMsg() override;
-        explicit PROTOBUF_CONSTEXPR AttackMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+        ~TrickMsg() override;
+        explicit PROTOBUF_CONSTEXPR TrickMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-        AttackMsg(const AttackMsg& from);
-        AttackMsg(AttackMsg&& from) noexcept
+        TrickMsg(const TrickMsg& from);
+        TrickMsg(TrickMsg&& from) noexcept
             :
-            AttackMsg()
+            TrickMsg()
         {
             *this = ::std::move(from);
         }
 
-        inline AttackMsg& operator=(const AttackMsg& from)
+        inline TrickMsg& operator=(const TrickMsg& from)
         {
             CopyFrom(from);
             return *this;
         }
-        inline AttackMsg& operator=(AttackMsg&& from) noexcept
+        inline TrickMsg& operator=(TrickMsg&& from) noexcept
         {
             if (this == &from)
                 return *this;
@@ -1046,24 +1046,24 @@ namespace protobuf
         {
             return default_instance().GetMetadata().reflection;
         }
-        static const AttackMsg& default_instance()
+        static const TrickMsg& default_instance()
         {
             return *internal_default_instance();
         }
-        static inline const AttackMsg* internal_default_instance()
+        static inline const TrickMsg* internal_default_instance()
         {
-            return reinterpret_cast<const AttackMsg*>(
-                &_AttackMsg_default_instance_
+            return reinterpret_cast<const TrickMsg*>(
+                &_TrickMsg_default_instance_
             );
         }
         static constexpr int kIndexInFileMessages =
             4;
 
-        friend void swap(AttackMsg& a, AttackMsg& b)
+        friend void swap(TrickMsg& a, TrickMsg& b)
         {
             a.Swap(&b);
         }
-        inline void Swap(AttackMsg* other)
+        inline void Swap(TrickMsg* other)
         {
             if (other == this)
                 return;
@@ -1082,7 +1082,7 @@ namespace protobuf
                 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
             }
         }
-        void UnsafeArenaSwap(AttackMsg* other)
+        void UnsafeArenaSwap(TrickMsg* other)
         {
             if (other == this)
                 return;
@@ -1092,16 +1092,16 @@ namespace protobuf
 
         // implements Message ----------------------------------------------
 
-        AttackMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        TrickMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
         {
-            return CreateMaybeMessage<AttackMsg>(arena);
+            return CreateMaybeMessage<TrickMsg>(arena);
         }
         using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-        void CopyFrom(const AttackMsg& from);
+        void CopyFrom(const TrickMsg& from);
         using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-        void MergeFrom(const AttackMsg& from)
+        void MergeFrom(const TrickMsg& from)
         {
-            AttackMsg::MergeImpl(*this, from);
+            TrickMsg::MergeImpl(*this, from);
         }
 
     private:
@@ -1125,17 +1125,17 @@ namespace protobuf
         void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
         void SharedDtor();
         void SetCachedSize(int size) const final;
-        void InternalSwap(AttackMsg* other);
+        void InternalSwap(TrickMsg* other);
 
     private:
         friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
         static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
         {
-            return "protobuf.AttackMsg";
+            return "protobuf.TrickMsg";
         }
 
     protected:
-        explicit AttackMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+        explicit TrickMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
 
     public:
         static const ClassData _class_data_;
@@ -1172,7 +1172,7 @@ namespace protobuf
         void _internal_set_angle(double value);
 
     public:
-        // @@protoc_insertion_point(class_scope:protobuf.AttackMsg)
+        // @@protoc_insertion_point(class_scope:protobuf.TrickMsg)
 
     private:
         class _Internal;
@@ -1443,102 +1443,102 @@ namespace protobuf
         // @@protoc_insertion_point(field_set:protobuf.PlayerMsg.player_type)
     }
 
-    // .protobuf.HumanType human_type = 3;
-    inline bool PlayerMsg::_internal_has_human_type() const
+    // .protobuf.StudentType student_type = 3;
+    inline bool PlayerMsg::_internal_has_student_type() const
     {
-        return job_type_case() == kHumanType;
+        return job_type_case() == kStudentType;
     }
-    inline bool PlayerMsg::has_human_type() const
+    inline bool PlayerMsg::has_student_type() const
     {
-        return _internal_has_human_type();
+        return _internal_has_student_type();
     }
-    inline void PlayerMsg::set_has_human_type()
+    inline void PlayerMsg::set_has_student_type()
     {
-        _impl_._oneof_case_[0] = kHumanType;
+        _impl_._oneof_case_[0] = kStudentType;
     }
-    inline void PlayerMsg::clear_human_type()
+    inline void PlayerMsg::clear_student_type()
     {
-        if (_internal_has_human_type())
+        if (_internal_has_student_type())
         {
-            _impl_.job_type_.human_type_ = 0;
+            _impl_.job_type_.student_type_ = 0;
             clear_has_job_type();
         }
     }
-    inline ::protobuf::HumanType PlayerMsg::_internal_human_type() const
+    inline ::protobuf::StudentType PlayerMsg::_internal_student_type() const
     {
-        if (_internal_has_human_type())
+        if (_internal_has_student_type())
         {
-            return static_cast<::protobuf::HumanType>(_impl_.job_type_.human_type_);
+            return static_cast<::protobuf::StudentType>(_impl_.job_type_.student_type_);
         }
-        return static_cast<::protobuf::HumanType>(0);
+        return static_cast<::protobuf::StudentType>(0);
     }
-    inline ::protobuf::HumanType PlayerMsg::human_type() const
+    inline ::protobuf::StudentType PlayerMsg::student_type() const
     {
-        // @@protoc_insertion_point(field_get:protobuf.PlayerMsg.human_type)
-        return _internal_human_type();
+        // @@protoc_insertion_point(field_get:protobuf.PlayerMsg.student_type)
+        return _internal_student_type();
     }
-    inline void PlayerMsg::_internal_set_human_type(::protobuf::HumanType value)
+    inline void PlayerMsg::_internal_set_student_type(::protobuf::StudentType value)
     {
-        if (!_internal_has_human_type())
+        if (!_internal_has_student_type())
         {
             clear_job_type();
-            set_has_human_type();
+            set_has_student_type();
         }
-        _impl_.job_type_.human_type_ = value;
+        _impl_.job_type_.student_type_ = value;
     }
-    inline void PlayerMsg::set_human_type(::protobuf::HumanType value)
+    inline void PlayerMsg::set_student_type(::protobuf::StudentType value)
     {
-        _internal_set_human_type(value);
-        // @@protoc_insertion_point(field_set:protobuf.PlayerMsg.human_type)
+        _internal_set_student_type(value);
+        // @@protoc_insertion_point(field_set:protobuf.PlayerMsg.student_type)
     }
 
-    // .protobuf.ButcherType butcher_type = 4;
-    inline bool PlayerMsg::_internal_has_butcher_type() const
+    // .protobuf.TrickerType tricker_type = 4;
+    inline bool PlayerMsg::_internal_has_tricker_type() const
     {
-        return job_type_case() == kButcherType;
+        return job_type_case() == kTrickerType;
     }
-    inline bool PlayerMsg::has_butcher_type() const
+    inline bool PlayerMsg::has_tricker_type() const
     {
-        return _internal_has_butcher_type();
+        return _internal_has_tricker_type();
     }
-    inline void PlayerMsg::set_has_butcher_type()
+    inline void PlayerMsg::set_has_tricker_type()
     {
-        _impl_._oneof_case_[0] = kButcherType;
+        _impl_._oneof_case_[0] = kTrickerType;
     }
-    inline void PlayerMsg::clear_butcher_type()
+    inline void PlayerMsg::clear_tricker_type()
     {
-        if (_internal_has_butcher_type())
+        if (_internal_has_tricker_type())
         {
-            _impl_.job_type_.butcher_type_ = 0;
+            _impl_.job_type_.tricker_type_ = 0;
             clear_has_job_type();
         }
     }
-    inline ::protobuf::ButcherType PlayerMsg::_internal_butcher_type() const
+    inline ::protobuf::TrickerType PlayerMsg::_internal_tricker_type() const
     {
-        if (_internal_has_butcher_type())
+        if (_internal_has_tricker_type())
         {
-            return static_cast<::protobuf::ButcherType>(_impl_.job_type_.butcher_type_);
+            return static_cast<::protobuf::TrickerType>(_impl_.job_type_.tricker_type_);
         }
-        return static_cast<::protobuf::ButcherType>(0);
+        return static_cast<::protobuf::TrickerType>(0);
     }
-    inline ::protobuf::ButcherType PlayerMsg::butcher_type() const
+    inline ::protobuf::TrickerType PlayerMsg::tricker_type() const
     {
-        // @@protoc_insertion_point(field_get:protobuf.PlayerMsg.butcher_type)
-        return _internal_butcher_type();
+        // @@protoc_insertion_point(field_get:protobuf.PlayerMsg.tricker_type)
+        return _internal_tricker_type();
     }
-    inline void PlayerMsg::_internal_set_butcher_type(::protobuf::ButcherType value)
+    inline void PlayerMsg::_internal_set_tricker_type(::protobuf::TrickerType value)
     {
-        if (!_internal_has_butcher_type())
+        if (!_internal_has_tricker_type())
         {
             clear_job_type();
-            set_has_butcher_type();
+            set_has_tricker_type();
         }
-        _impl_.job_type_.butcher_type_ = value;
+        _impl_.job_type_.tricker_type_ = value;
     }
-    inline void PlayerMsg::set_butcher_type(::protobuf::ButcherType value)
+    inline void PlayerMsg::set_tricker_type(::protobuf::TrickerType value)
     {
-        _internal_set_butcher_type(value);
-        // @@protoc_insertion_point(field_set:protobuf.PlayerMsg.butcher_type)
+        _internal_set_tricker_type(value);
+        // @@protoc_insertion_point(field_set:protobuf.PlayerMsg.tricker_type)
     }
 
     inline bool PlayerMsg::has_job_type() const
@@ -1792,54 +1792,54 @@ namespace protobuf
 
     // -------------------------------------------------------------------
 
-    // AttackMsg
+    // TrickMsg
 
     // int64 player_id = 1;
-    inline void AttackMsg::clear_player_id()
+    inline void TrickMsg::clear_player_id()
     {
         _impl_.player_id_ = int64_t{0};
     }
-    inline int64_t AttackMsg::_internal_player_id() const
+    inline int64_t TrickMsg::_internal_player_id() const
     {
         return _impl_.player_id_;
     }
-    inline int64_t AttackMsg::player_id() const
+    inline int64_t TrickMsg::player_id() const
     {
-        // @@protoc_insertion_point(field_get:protobuf.AttackMsg.player_id)
+        // @@protoc_insertion_point(field_get:protobuf.TrickMsg.player_id)
         return _internal_player_id();
     }
-    inline void AttackMsg::_internal_set_player_id(int64_t value)
+    inline void TrickMsg::_internal_set_player_id(int64_t value)
     {
         _impl_.player_id_ = value;
     }
-    inline void AttackMsg::set_player_id(int64_t value)
+    inline void TrickMsg::set_player_id(int64_t value)
     {
         _internal_set_player_id(value);
-        // @@protoc_insertion_point(field_set:protobuf.AttackMsg.player_id)
+        // @@protoc_insertion_point(field_set:protobuf.TrickMsg.player_id)
     }
 
     // double angle = 2;
-    inline void AttackMsg::clear_angle()
+    inline void TrickMsg::clear_angle()
     {
         _impl_.angle_ = 0;
     }
-    inline double AttackMsg::_internal_angle() const
+    inline double TrickMsg::_internal_angle() const
     {
         return _impl_.angle_;
     }
-    inline double AttackMsg::angle() const
+    inline double TrickMsg::angle() const
     {
-        // @@protoc_insertion_point(field_get:protobuf.AttackMsg.angle)
+        // @@protoc_insertion_point(field_get:protobuf.TrickMsg.angle)
         return _internal_angle();
     }
-    inline void AttackMsg::_internal_set_angle(double value)
+    inline void TrickMsg::_internal_set_angle(double value)
     {
         _impl_.angle_ = value;
     }
-    inline void AttackMsg::set_angle(double value)
+    inline void TrickMsg::set_angle(double value)
     {
         _internal_set_angle(value);
-        // @@protoc_insertion_point(field_set:protobuf.AttackMsg.angle)
+        // @@protoc_insertion_point(field_set:protobuf.TrickMsg.angle)
     }
 
     // -------------------------------------------------------------------

CAPI/proto/MessageType.pb.cc

@@ -30,35 +30,36 @@ static constexpr ::_pbi::MigrationSchema* schemas = nullptr;
 static constexpr ::_pb::Message* const* file_default_instances = nullptr;
 
 const char descriptor_table_protodef_MessageType_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
-    "\n\021MessageType.proto\022\010protobuf*g\n\tPlaceTy"
+    "\n\021MessageType.proto\022\010protobuf*x\n\tPlaceTy"
     "pe\022\023\n\017NULL_PLACE_TYPE\020\000\022\010\n\004LAND\020\001\022\010\n\004WAL"
-    "L\020\002\022\t\n\005GRASS\020\003\022\013\n\007MACHINE\020\004\022\010\n\004GATE\020\005\022\017\n"
-    "\013HIDDEN_GATE\020\006*8\n\tShapeType\022\023\n\017NULL_SHAP"
-    "E_TYPE\020\000\022\n\n\006CIRCLE\020\001\022\n\n\006SQUARE\020\002*N\n\010Prop"
-    "Type\022\022\n\016NULL_PROP_TYPE\020\000\022\n\n\006PTYPE1\020\001\022\n\n\006"
-    "PTYPE2\020\002\022\n\n\006PTYPE3\020\003\022\n\n\006PTYPE4\020\004*d\n\rHuma"
-    "nBuffType\022\023\n\017NULL_HBUFF_TYPE\020\000\022\016\n\nHBUFFT"
-    "YPE1\020\001\022\016\n\nHBUFFTYPE2\020\002\022\016\n\nHBUFFTYPE3\020\003\022\016"
-    "\n\nHBUFFTYPE4\020\004*V\n\nHumanState\022\017\n\013NULL_STA"
-    "TUS\020\000\022\010\n\004IDLE\020\001\022\n\n\006FIXING\020\002\022\t\n\005DYING\020\003\022\014"
-    "\n\010ON_CHAIR\020\004\022\010\n\004DEAD\020\005*f\n\017ButcherBuffTyp"
-    "e\022\023\n\017NULL_BBUFF_TYPE\020\000\022\016\n\nBBUFFTYPE1\020\001\022\016"
-    "\n\nBBUFFTYPE2\020\002\022\016\n\nBBUFFTYPE3\020\003\022\016\n\nBBUFFT"
-    "YPE4\020\004*H\n\nPlayerType\022\024\n\020NULL_PLAYER_TYPE"
-    "\020\000\022\020\n\014HUMAN_PLAYER\020\001\022\022\n\016BUTCHER_PLAYER\020\002"
-    "*`\n\tHumanType\022\023\n\017NULL_HUMAN_TYPE\020\000\022\016\n\nHU"
-    "MANTYPE1\020\001\022\016\n\nHUMANTYPE2\020\002\022\016\n\nHUMANTYPE3"
-    "\020\003\022\016\n\nHUMANTYPE4\020\004*l\n\013ButcherType\022\025\n\021NUL"
-    "L_BUTCHER_TYPE\020\000\022\020\n\014BUTCHERTYPE1\020\001\022\020\n\014BU"
-    "TCHERTYPE2\020\002\022\020\n\014BUTCHERTYPE3\020\003\022\020\n\014BUTCHE"
-    "RTYPE4\020\004*P\n\tGameState\022\023\n\017NULL_GAME_STATE"
-    "\020\000\022\016\n\nGAME_START\020\001\022\020\n\014GAME_RUNNING\020\002\022\014\n\010"
-    "GAME_END\020\003b\006proto3";
+    "L\020\002\022\t\n\005GRASS\020\003\022\r\n\tCLASSROOM\020\004\022\r\n\tBLACKRO"
+    "OM\020\005\022\010\n\004GATE\020\006\022\017\n\013HIDDEN_GATE\020\007*8\n\tShape"
+    "Type\022\023\n\017NULL_SHAPE_TYPE\020\000\022\n\n\006CIRCLE\020\001\022\n\n"
+    "\006SQUARE\020\002*N\n\010PropType\022\022\n\016NULL_PROP_TYPE\020"
+    "\000\022\n\n\006PTYPE1\020\001\022\n\n\006PTYPE2\020\002\022\n\n\006PTYPE3\020\003\022\n\n"
+    "\006PTYPE4\020\004*f\n\017StudentBuffType\022\023\n\017NULL_SBU"
+    "FF_TYPE\020\000\022\016\n\nSBUFFTYPE1\020\001\022\016\n\nSBUFFTYPE2\020"
+    "\002\022\016\n\nSBUFFTYPE3\020\003\022\016\n\nSBUFFTYPE4\020\004*i\n\014Stu"
+    "dentState\022\017\n\013NULL_STATUS\020\000\022\010\n\004IDLE\020\001\022\014\n\010"
+    "LEARNING\020\002\022\010\n\004FAIL\020\003\022\r\n\tEMOTIONAL\020\004\022\010\n\004Q"
+    "UIT\020\005\022\r\n\tGRADUATED\020\006*f\n\017TrickerBuffType\022"
+    "\023\n\017NULL_TBUFF_TYPE\020\000\022\016\n\nTBUFFTYPE1\020\001\022\016\n\n"
+    "TBUFFTYPE2\020\002\022\016\n\nTBUFFTYPE3\020\003\022\016\n\nTBUFFTYP"
+    "E4\020\004*J\n\nPlayerType\022\024\n\020NULL_PLAYER_TYPE\020\000"
+    "\022\022\n\016STUDENT_PLAYER\020\001\022\022\n\016TRICKER_PLAYER\020\002"
+    "*l\n\013StudentType\022\025\n\021NULL_STUDENT_TYPE\020\000\022\020"
+    "\n\014STUDENTTYPE1\020\001\022\020\n\014STUDENTTYPE2\020\002\022\020\n\014ST"
+    "UDENTTYPE3\020\003\022\020\n\014STUDENTTYPE4\020\004*l\n\013Tricke"
+    "rType\022\025\n\021NULL_TRICKER_TYPE\020\000\022\020\n\014TRICKERT"
+    "YPE1\020\001\022\020\n\014TRICKERTYPE2\020\002\022\020\n\014TRICKERTYPE3"
+    "\020\003\022\020\n\014TRICKERTYPE4\020\004*P\n\tGameState\022\023\n\017NUL"
+    "L_GAME_STATE\020\000\022\016\n\nGAME_START\020\001\022\020\n\014GAME_R"
+    "UNNING\020\002\022\014\n\010GAME_END\020\003b\006proto3";
 static ::_pbi::once_flag descriptor_table_MessageType_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_MessageType_2eproto = {
     false,
     false,
-    938,
+    990,
     descriptor_table_protodef_MessageType_2eproto,
     "MessageType.proto",
     &descriptor_table_MessageType_2eproto_once,
@@ -97,6 +98,7 @@ namespace protobuf
             case 4:
             case 5:
             case 6:
+            case 7:
                 return true;
             default:
                 return false;
@@ -141,12 +143,12 @@ namespace protobuf
         }
     }
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanBuffType_descriptor()
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentBuffType_descriptor()
     {
         ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
         return file_level_enum_descriptors_MessageType_2eproto[3];
     }
-    bool HumanBuffType_IsValid(int value)
+    bool StudentBuffType_IsValid(int value)
     {
         switch (value)
         {
@@ -161,12 +163,12 @@ namespace protobuf
         }
     }
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanState_descriptor()
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentState_descriptor()
     {
         ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
         return file_level_enum_descriptors_MessageType_2eproto[4];
     }
-    bool HumanState_IsValid(int value)
+    bool StudentState_IsValid(int value)
     {
         switch (value)
         {
@@ -176,18 +178,19 @@ namespace protobuf
             case 3:
             case 4:
             case 5:
+            case 6:
                 return true;
             default:
                 return false;
         }
     }
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherBuffType_descriptor()
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TrickerBuffType_descriptor()
     {
         ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
         return file_level_enum_descriptors_MessageType_2eproto[5];
     }
-    bool ButcherBuffType_IsValid(int value)
+    bool TrickerBuffType_IsValid(int value)
     {
         switch (value)
         {
@@ -220,12 +223,12 @@ namespace protobuf
         }
     }
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanType_descriptor()
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentType_descriptor()
     {
         ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
         return file_level_enum_descriptors_MessageType_2eproto[7];
     }
-    bool HumanType_IsValid(int value)
+    bool StudentType_IsValid(int value)
     {
         switch (value)
         {
@@ -240,12 +243,12 @@ namespace protobuf
         }
     }
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherType_descriptor()
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TrickerType_descriptor()
     {
         ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto);
         return file_level_enum_descriptors_MessageType_2eproto[8];
     }
-    bool ButcherType_IsValid(int value)
+    bool TrickerType_IsValid(int value)
     {
         switch (value)
         {

CAPI/proto/MessageType.pb.h

@@ -13,7 +13,7 @@
 #error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.
@@ -56,9 +56,10 @@ namespace protobuf
         LAND = 1,
         WALL = 2,
         GRASS = 3,
-        MACHINE = 4,
-        GATE = 5,
-        HIDDEN_GATE = 6,
+        CLASSROOM = 4,
+        BLACKROOM = 5,
+        GATE = 6,
+        HIDDEN_GATE = 7,
         PlaceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
         PlaceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
@@ -146,114 +147,115 @@ namespace protobuf
             PropType_descriptor(), name, value
         );
     }
-    enum HumanBuffType : int
+    enum StudentBuffType : int
     {
-        NULL_HBUFF_TYPE = 0,
-        HBUFFTYPE1 = 1,
-        HBUFFTYPE2 = 2,
-        HBUFFTYPE3 = 3,
-        HBUFFTYPE4 = 4,
-        HumanBuffType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-        HumanBuffType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+        NULL_SBUFF_TYPE = 0,
+        SBUFFTYPE1 = 1,
+        SBUFFTYPE2 = 2,
+        SBUFFTYPE3 = 3,
+        SBUFFTYPE4 = 4,
+        StudentBuffType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+        StudentBuffType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
-    bool HumanBuffType_IsValid(int value);
-    constexpr HumanBuffType HumanBuffType_MIN = NULL_HBUFF_TYPE;
-    constexpr HumanBuffType HumanBuffType_MAX = HBUFFTYPE4;
-    constexpr int HumanBuffType_ARRAYSIZE = HumanBuffType_MAX + 1;
+    bool StudentBuffType_IsValid(int value);
+    constexpr StudentBuffType StudentBuffType_MIN = NULL_SBUFF_TYPE;
+    constexpr StudentBuffType StudentBuffType_MAX = SBUFFTYPE4;
+    constexpr int StudentBuffType_ARRAYSIZE = StudentBuffType_MAX + 1;
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanBuffType_descriptor();
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentBuffType_descriptor();
     template<typename T>
-    inline const std::string& HumanBuffType_Name(T enum_t_value)
+    inline const std::string& StudentBuffType_Name(T enum_t_value)
     {
-        static_assert(::std::is_same<T, HumanBuffType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function HumanBuffType_Name.");
+        static_assert(::std::is_same<T, StudentBuffType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function StudentBuffType_Name.");
         return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-            HumanBuffType_descriptor(), enum_t_value
+            StudentBuffType_descriptor(), enum_t_value
         );
     }
-    inline bool HumanBuffType_Parse(
-        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HumanBuffType* value
+    inline bool StudentBuffType_Parse(
+        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StudentBuffType* value
     )
     {
-        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HumanBuffType>(
-            HumanBuffType_descriptor(), name, value
+        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StudentBuffType>(
+            StudentBuffType_descriptor(), name, value
         );
     }
-    enum HumanState : int
+    enum StudentState : int
     {
         NULL_STATUS = 0,
         IDLE = 1,
-        FIXING = 2,
-        DYING = 3,
-        ON_CHAIR = 4,
-        DEAD = 5,
-        HumanState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-        HumanState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+        LEARNING = 2,
+        FAIL = 3,
+        EMOTIONAL = 4,
+        QUIT = 5,
+        GRADUATED = 6,
+        StudentState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+        StudentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
-    bool HumanState_IsValid(int value);
-    constexpr HumanState HumanState_MIN = NULL_STATUS;
-    constexpr HumanState HumanState_MAX = DEAD;
-    constexpr int HumanState_ARRAYSIZE = HumanState_MAX + 1;
+    bool StudentState_IsValid(int value);
+    constexpr StudentState StudentState_MIN = NULL_STATUS;
+    constexpr StudentState StudentState_MAX = GRADUATED;
+    constexpr int StudentState_ARRAYSIZE = StudentState_MAX + 1;
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanState_descriptor();
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentState_descriptor();
     template<typename T>
-    inline const std::string& HumanState_Name(T enum_t_value)
+    inline const std::string& StudentState_Name(T enum_t_value)
     {
-        static_assert(::std::is_same<T, HumanState>::value || ::std::is_integral<T>::value, "Incorrect type passed to function HumanState_Name.");
+        static_assert(::std::is_same<T, StudentState>::value || ::std::is_integral<T>::value, "Incorrect type passed to function StudentState_Name.");
         return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-            HumanState_descriptor(), enum_t_value
+            StudentState_descriptor(), enum_t_value
         );
     }
-    inline bool HumanState_Parse(
-        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HumanState* value
+    inline bool StudentState_Parse(
+        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StudentState* value
     )
     {
-        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HumanState>(
-            HumanState_descriptor(), name, value
+        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StudentState>(
+            StudentState_descriptor(), name, value
         );
     }
-    enum ButcherBuffType : int
+    enum TrickerBuffType : int
     {
-        NULL_BBUFF_TYPE = 0,
-        BBUFFTYPE1 = 1,
-        BBUFFTYPE2 = 2,
-        BBUFFTYPE3 = 3,
-        BBUFFTYPE4 = 4,
-        ButcherBuffType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-        ButcherBuffType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+        NULL_TBUFF_TYPE = 0,
+        TBUFFTYPE1 = 1,
+        TBUFFTYPE2 = 2,
+        TBUFFTYPE3 = 3,
+        TBUFFTYPE4 = 4,
+        TrickerBuffType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+        TrickerBuffType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
-    bool ButcherBuffType_IsValid(int value);
-    constexpr ButcherBuffType ButcherBuffType_MIN = NULL_BBUFF_TYPE;
-    constexpr ButcherBuffType ButcherBuffType_MAX = BBUFFTYPE4;
-    constexpr int ButcherBuffType_ARRAYSIZE = ButcherBuffType_MAX + 1;
+    bool TrickerBuffType_IsValid(int value);
+    constexpr TrickerBuffType TrickerBuffType_MIN = NULL_TBUFF_TYPE;
+    constexpr TrickerBuffType TrickerBuffType_MAX = TBUFFTYPE4;
+    constexpr int TrickerBuffType_ARRAYSIZE = TrickerBuffType_MAX + 1;
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherBuffType_descriptor();
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TrickerBuffType_descriptor();
     template<typename T>
-    inline const std::string& ButcherBuffType_Name(T enum_t_value)
+    inline const std::string& TrickerBuffType_Name(T enum_t_value)
     {
-        static_assert(::std::is_same<T, ButcherBuffType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function ButcherBuffType_Name.");
+        static_assert(::std::is_same<T, TrickerBuffType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function TrickerBuffType_Name.");
         return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-            ButcherBuffType_descriptor(), enum_t_value
+            TrickerBuffType_descriptor(), enum_t_value
         );
     }
-    inline bool ButcherBuffType_Parse(
-        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ButcherBuffType* value
+    inline bool TrickerBuffType_Parse(
+        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TrickerBuffType* value
     )
     {
-        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ButcherBuffType>(
-            ButcherBuffType_descriptor(), name, value
+        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TrickerBuffType>(
+            TrickerBuffType_descriptor(), name, value
         );
     }
     enum PlayerType : int
     {
         NULL_PLAYER_TYPE = 0,
-        HUMAN_PLAYER = 1,
-        BUTCHER_PLAYER = 2,
+        STUDENT_PLAYER = 1,
+        TRICKER_PLAYER = 2,
         PlayerType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
         PlayerType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
     bool PlayerType_IsValid(int value);
     constexpr PlayerType PlayerType_MIN = NULL_PLAYER_TYPE;
-    constexpr PlayerType PlayerType_MAX = BUTCHER_PLAYER;
+    constexpr PlayerType PlayerType_MAX = TRICKER_PLAYER;
     constexpr int PlayerType_ARRAYSIZE = PlayerType_MAX + 1;
 
     const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayerType_descriptor();
@@ -273,68 +275,68 @@ namespace protobuf
             PlayerType_descriptor(), name, value
         );
     }
-    enum HumanType : int
+    enum StudentType : int
     {
-        NULL_HUMAN_TYPE = 0,
-        HUMANTYPE1 = 1,
-        HUMANTYPE2 = 2,
-        HUMANTYPE3 = 3,
-        HUMANTYPE4 = 4,
-        HumanType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-        HumanType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+        NULL_STUDENT_TYPE = 0,
+        STUDENTTYPE1 = 1,
+        STUDENTTYPE2 = 2,
+        STUDENTTYPE3 = 3,
+        STUDENTTYPE4 = 4,
+        StudentType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+        StudentType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
-    bool HumanType_IsValid(int value);
-    constexpr HumanType HumanType_MIN = NULL_HUMAN_TYPE;
-    constexpr HumanType HumanType_MAX = HUMANTYPE4;
-    constexpr int HumanType_ARRAYSIZE = HumanType_MAX + 1;
+    bool StudentType_IsValid(int value);
+    constexpr StudentType StudentType_MIN = NULL_STUDENT_TYPE;
+    constexpr StudentType StudentType_MAX = STUDENTTYPE4;
+    constexpr int StudentType_ARRAYSIZE = StudentType_MAX + 1;
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HumanType_descriptor();
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentType_descriptor();
     template<typename T>
-    inline const std::string& HumanType_Name(T enum_t_value)
+    inline const std::string& StudentType_Name(T enum_t_value)
     {
-        static_assert(::std::is_same<T, HumanType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function HumanType_Name.");
+        static_assert(::std::is_same<T, StudentType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function StudentType_Name.");
         return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-            HumanType_descriptor(), enum_t_value
+            StudentType_descriptor(), enum_t_value
         );
     }
-    inline bool HumanType_Parse(
-        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HumanType* value
+    inline bool StudentType_Parse(
+        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StudentType* value
     )
     {
-        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HumanType>(
-            HumanType_descriptor(), name, value
+        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StudentType>(
+            StudentType_descriptor(), name, value
         );
     }
-    enum ButcherType : int
+    enum TrickerType : int
     {
-        NULL_BUTCHER_TYPE = 0,
-        BUTCHERTYPE1 = 1,
-        BUTCHERTYPE2 = 2,
-        BUTCHERTYPE3 = 3,
-        BUTCHERTYPE4 = 4,
-        ButcherType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-        ButcherType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+        NULL_TRICKER_TYPE = 0,
+        TRICKERTYPE1 = 1,
+        TRICKERTYPE2 = 2,
+        TRICKERTYPE3 = 3,
+        TRICKERTYPE4 = 4,
+        TrickerType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+        TrickerType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
     };
-    bool ButcherType_IsValid(int value);
-    constexpr ButcherType ButcherType_MIN = NULL_BUTCHER_TYPE;
-    constexpr ButcherType ButcherType_MAX = BUTCHERTYPE4;
-    constexpr int ButcherType_ARRAYSIZE = ButcherType_MAX + 1;
+    bool TrickerType_IsValid(int value);
+    constexpr TrickerType TrickerType_MIN = NULL_TRICKER_TYPE;
+    constexpr TrickerType TrickerType_MAX = TRICKERTYPE4;
+    constexpr int TrickerType_ARRAYSIZE = TrickerType_MAX + 1;
 
-    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ButcherType_descriptor();
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TrickerType_descriptor();
     template<typename T>
-    inline const std::string& ButcherType_Name(T enum_t_value)
+    inline const std::string& TrickerType_Name(T enum_t_value)
     {
-        static_assert(::std::is_same<T, ButcherType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function ButcherType_Name.");
+        static_assert(::std::is_same<T, TrickerType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function TrickerType_Name.");
         return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-            ButcherType_descriptor(), enum_t_value
+            TrickerType_descriptor(), enum_t_value
         );
     }
-    inline bool ButcherType_Parse(
-        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ButcherType* value
+    inline bool TrickerType_Parse(
+        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TrickerType* value
     )
     {
-        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ButcherType>(
-            ButcherType_descriptor(), name, value
+        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TrickerType>(
+            TrickerType_descriptor(), name, value
         );
     }
     enum GameState : int
@@ -416,31 +418,31 @@ inline const EnumDescriptor* GetEnumDescriptor<::protobuf::PropType>()
     return ::protobuf::PropType_descriptor();
 }
 template<>
-struct is_proto_enum<::protobuf::HumanBuffType> : ::std::true_type
+struct is_proto_enum<::protobuf::StudentBuffType> : ::std::true_type
 {
 };
 template<>
-inline const EnumDescriptor* GetEnumDescriptor<::protobuf::HumanBuffType>()
+inline const EnumDescriptor* GetEnumDescriptor<::protobuf::StudentBuffType>()
 {
-    return ::protobuf::HumanBuffType_descriptor();
+    return ::protobuf::StudentBuffType_descriptor();
 }
 template<>
-struct is_proto_enum<::protobuf::HumanState> : ::std::true_type
+struct is_proto_enum<::protobuf::StudentState> : ::std::true_type
 {
 };
 template<>
-inline const EnumDescriptor* GetEnumDescriptor<::protobuf::HumanState>()
+inline const EnumDescriptor* GetEnumDescriptor<::protobuf::StudentState>()
 {
-    return ::protobuf::HumanState_descriptor();
+    return ::protobuf::StudentState_descriptor();
 }
 template<>
-struct is_proto_enum<::protobuf::ButcherBuffType> : ::std::true_type
+struct is_proto_enum<::protobuf::TrickerBuffType> : ::std::true_type
 {
 };
 template<>
-inline const EnumDescriptor* GetEnumDescriptor<::protobuf::ButcherBuffType>()
+inline const EnumDescriptor* GetEnumDescriptor<::protobuf::TrickerBuffType>()
 {
-    return ::protobuf::ButcherBuffType_descriptor();
+    return ::protobuf::TrickerBuffType_descriptor();
 }
 template<>
 struct is_proto_enum<::protobuf::PlayerType> : ::std::true_type
@@ -452,22 +454,22 @@ inline const EnumDescriptor* GetEnumDescriptor<::protobuf::PlayerType>()
     return ::protobuf::PlayerType_descriptor();
 }
 template<>
-struct is_proto_enum<::protobuf::HumanType> : ::std::true_type
+struct is_proto_enum<::protobuf::StudentType> : ::std::true_type
 {
 };
 template<>
-inline const EnumDescriptor* GetEnumDescriptor<::protobuf::HumanType>()
+inline const EnumDescriptor* GetEnumDescriptor<::protobuf::StudentType>()
 {
-    return ::protobuf::HumanType_descriptor();
+    return ::protobuf::StudentType_descriptor();
 }
 template<>
-struct is_proto_enum<::protobuf::ButcherType> : ::std::true_type
+struct is_proto_enum<::protobuf::TrickerType> : ::std::true_type
 {
 };
 template<>
-inline const EnumDescriptor* GetEnumDescriptor<::protobuf::ButcherType>()
+inline const EnumDescriptor* GetEnumDescriptor<::protobuf::TrickerType>()
 {
-    return ::protobuf::ButcherType_descriptor();
+    return ::protobuf::TrickerType_descriptor();
 }
 template<>
 struct is_proto_enum<::protobuf::GameState> : ::std::true_type

CAPI/proto/Services.grpc.pb.cc

@@ -31,15 +31,15 @@ namespace protobuf
         "/protobuf.AvailableService/UseSkill",
         "/protobuf.AvailableService/SendMessage",
         "/protobuf.AvailableService/GetMessage",
-        "/protobuf.AvailableService/StartFixMachine",
-        "/protobuf.AvailableService/EndFixMachine",
-        "/protobuf.AvailableService/StartSaveHuman",
-        "/protobuf.AvailableService/EndSaveHuman",
-        "/protobuf.AvailableService/Attack",
-        "/protobuf.AvailableService/CarryHuman",
-        "/protobuf.AvailableService/ReleaseHuman",
-        "/protobuf.AvailableService/HangHuman",
-        "/protobuf.AvailableService/Escape",
+        "/protobuf.AvailableService/StartLearning",
+        "/protobuf.AvailableService/EndLearning",
+        "/protobuf.AvailableService/StartHelpMate",
+        "/protobuf.AvailableService/EndHelpMate",
+        "/protobuf.AvailableService/Trick",
+        "/protobuf.AvailableService/StartExam",
+        "/protobuf.AvailableService/EndExam",
+        "/protobuf.AvailableService/MakeFail",
+        "/protobuf.AvailableService/Graduate",
     };
 
     std::unique_ptr<AvailableService::Stub> AvailableService::NewStub(const std::shared_ptr<::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
@@ -59,15 +59,15 @@ namespace protobuf
         rpcmethod_UseSkill_(AvailableService_method_names[5], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
         rpcmethod_SendMessage_(AvailableService_method_names[6], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
         rpcmethod_GetMessage_(AvailableService_method_names[7], options.suffix_for_stats(), ::grpc::internal::RpcMethod::SERVER_STREAMING, channel),
-        rpcmethod_StartFixMachine_(AvailableService_method_names[8], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_EndFixMachine_(AvailableService_method_names[9], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_StartSaveHuman_(AvailableService_method_names[10], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_EndSaveHuman_(AvailableService_method_names[11], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_Attack_(AvailableService_method_names[12], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_CarryHuman_(AvailableService_method_names[13], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_ReleaseHuman_(AvailableService_method_names[14], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_HangHuman_(AvailableService_method_names[15], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_Escape_(AvailableService_method_names[16], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+        rpcmethod_StartLearning_(AvailableService_method_names[8], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_EndLearning_(AvailableService_method_names[9], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_StartHelpMate_(AvailableService_method_names[10], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_EndHelpMate_(AvailableService_method_names[11], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_Trick_(AvailableService_method_names[12], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_StartExam_(AvailableService_method_names[13], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_EndExam_(AvailableService_method_names[14], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_MakeFail_(AvailableService_method_names[15], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_Graduate_(AvailableService_method_names[16], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
     {
     }
 
@@ -279,254 +279,254 @@ namespace protobuf
         return ::grpc::internal::ClientAsyncReaderFactory<::protobuf::MsgRes>::Create(channel_.get(), cq, rpcmethod_GetMessage_, context, request, false, nullptr);
     }
 
-    ::grpc::Status AvailableService::Stub::StartFixMachine(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartFixMachine_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartLearning_, context, request, response);
     }
 
-    void AvailableService::Stub::async::StartFixMachine(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartFixMachine_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartLearning_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::StartFixMachine(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartFixMachine_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartLearning_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartFixMachineRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartFixMachine_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartLearning_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartFixMachineRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncStartFixMachineRaw(context, request, cq);
+            this->PrepareAsyncStartLearningRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::EndFixMachine(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::EndLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EndFixMachine_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EndLearning_, context, request, response);
     }
 
-    void AvailableService::Stub::async::EndFixMachine(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::EndLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndFixMachine_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndLearning_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::EndFixMachine(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::EndLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndFixMachine_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndLearning_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEndFixMachineRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEndLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EndFixMachine_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EndLearning_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEndFixMachineRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEndLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncEndFixMachineRaw(context, request, cq);
+            this->PrepareAsyncEndLearningRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::StartSaveHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartSaveHuman_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartHelpMate_, context, request, response);
     }
 
-    void AvailableService::Stub::async::StartSaveHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartSaveHuman_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartHelpMate_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::StartSaveHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartSaveHuman_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartHelpMate_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartSaveHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartSaveHuman_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartHelpMate_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartSaveHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncStartSaveHumanRaw(context, request, cq);
+            this->PrepareAsyncStartHelpMateRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::EndSaveHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::EndHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EndSaveHuman_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EndHelpMate_, context, request, response);
     }
 
-    void AvailableService::Stub::async::EndSaveHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::EndHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndSaveHuman_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndHelpMate_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::EndSaveHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::EndHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndSaveHuman_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndHelpMate_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEndSaveHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEndHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EndSaveHuman_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EndHelpMate_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEndSaveHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEndHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncEndSaveHumanRaw(context, request, cq);
+            this->PrepareAsyncEndHelpMateRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Attack_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::TrickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Trick_, context, request, response);
     }
 
-    void AvailableService::Stub::async::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Attack_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::TrickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Trick_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Attack_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Trick_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::AttackMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Attack_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::TrickMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Trick_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncAttackRaw(context, request, cq);
+            this->PrepareAsyncTrickRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::StartExam(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CarryHuman_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartExam_, context, request, response);
     }
 
-    void AvailableService::Stub::async::CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::StartExam(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CarryHuman_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartExam_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::CarryHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::StartExam(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CarryHuman_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartExam_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartExamRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CarryHuman_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartExam_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncCarryHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartExamRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncCarryHumanRaw(context, request, cq);
+            this->PrepareAsyncStartExamRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::EndExam(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ReleaseHuman_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EndExam_, context, request, response);
     }
 
-    void AvailableService::Stub::async::ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::EndExam(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ReleaseHuman_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndExam_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::ReleaseHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::EndExam(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ReleaseHuman_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndExam_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEndExamRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ReleaseHuman_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EndExam_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncReleaseHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEndExamRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncReleaseHumanRaw(context, request, cq);
+            this->PrepareAsyncEndExamRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::MakeFail(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HangHuman_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_MakeFail_, context, request, response);
     }
 
-    void AvailableService::Stub::async::HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::MakeFail(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HangHuman_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_MakeFail_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::HangHuman(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::MakeFail(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HangHuman_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_MakeFail_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncMakeFailRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HangHuman_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_MakeFail_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncHangHumanRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncMakeFailRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncHangHumanRaw(context, request, cq);
+            this->PrepareAsyncMakeFailRaw(context, request, cq);
         result->StartCall();
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Escape_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Graduate_, context, request, response);
     }
 
-    void AvailableService::Stub::async::Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
     {
-        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Escape_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Graduate_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::Escape(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
-        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Escape_, context, request, response, reactor);
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Graduate_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEscapeRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncGraduateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Escape_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Graduate_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEscapeRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncGraduateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
-            this->PrepareAsyncEscapeRaw(context, request, cq);
+            this->PrepareAsyncGraduateRaw(context, request, cq);
         result->StartCall();
         return result;
     }
@@ -654,7 +654,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->StartFixMachine(ctx, req, resp);
+                    return service->StartLearning(ctx, req, resp);
                 },
                 this
             )
@@ -668,7 +668,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->EndFixMachine(ctx, req, resp);
+                    return service->EndLearning(ctx, req, resp);
                 },
                 this
             )
@@ -682,7 +682,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->StartSaveHuman(ctx, req, resp);
+                    return service->StartHelpMate(ctx, req, resp);
                 },
                 this
             )
@@ -696,7 +696,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->EndSaveHuman(ctx, req, resp);
+                    return service->EndHelpMate(ctx, req, resp);
                 },
                 this
             )
@@ -704,13 +704,13 @@ namespace protobuf
         AddMethod(new ::grpc::internal::RpcServiceMethod(
             AvailableService_method_names[12],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
-            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::TrickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
                    ::grpc::ServerContext* ctx,
-                   const ::protobuf::AttackMsg* req,
+                   const ::protobuf::TrickMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->Attack(ctx, req, resp);
+                    return service->Trick(ctx, req, resp);
                 },
                 this
             )
@@ -724,7 +724,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->CarryHuman(ctx, req, resp);
+                    return service->StartExam(ctx, req, resp);
                 },
                 this
             )
@@ -738,7 +738,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->ReleaseHuman(ctx, req, resp);
+                    return service->EndExam(ctx, req, resp);
                 },
                 this
             )
@@ -752,7 +752,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->HangHuman(ctx, req, resp);
+                    return service->MakeFail(ctx, req, resp);
                 },
                 this
             )
@@ -766,7 +766,7 @@ namespace protobuf
                    const ::protobuf::IDMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
-                    return service->Escape(ctx, req, resp);
+                    return service->Graduate(ctx, req, resp);
                 },
                 this
             )
@@ -841,7 +841,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::StartFixMachine(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::StartLearning(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -849,7 +849,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::EndFixMachine(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::EndLearning(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -857,7 +857,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::StartSaveHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::StartHelpMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -865,7 +865,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::EndSaveHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::EndHelpMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -873,7 +873,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::Attack(::grpc::ServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::Trick(::grpc::ServerContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -881,7 +881,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::CarryHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::StartExam(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -889,7 +889,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::ReleaseHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::EndExam(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -897,7 +897,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::HangHuman(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::MakeFail(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -905,7 +905,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::Escape(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::Graduate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;

CAPI/proto/Services.pb.cc

@@ -31,7 +31,7 @@ static constexpr ::_pb::Message* const* file_default_instances = nullptr;
 
 const char descriptor_table_protodef_Services_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
     "\n\016Services.proto\022\010protobuf\032\025Message2Clie"
-    "nts.proto\032\024Message2Server.proto2\372\006\n\020Avai"
+    "nts.proto\032\024Message2Server.proto2\355\006\n\020Avai"
     "lableService\0223\n\rTryConnection\022\017.protobuf"
     ".IDMsg\032\021.protobuf.BoolRes\022=\n\tAddPlayer\022\023"
     ".protobuf.PlayerMsg\032\031.protobuf.MessageTo"
@@ -42,19 +42,18 @@ const char descriptor_table_protodef_Services_2eproto[] PROTOBUF_SECTION_VARIABL
     "ill\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\022"
     "3\n\013SendMessage\022\021.protobuf.SendMsg\032\021.prot"
     "obuf.BoolRes\0221\n\nGetMessage\022\017.protobuf.ID"
-    "Msg\032\020.protobuf.MsgRes0\001\0225\n\017StartFixMachi"
-    "ne\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\0223"
-    "\n\rEndFixMachine\022\017.protobuf.IDMsg\032\021.proto"
-    "buf.BoolRes\0224\n\016StartSaveHuman\022\017.protobuf"
-    ".IDMsg\032\021.protobuf.BoolRes\0222\n\014EndSaveHuma"
-    "n\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\0220\n"
-    "\006Attack\022\023.protobuf.AttackMsg\032\021.protobuf."
-    "BoolRes\0220\n\nCarryHuman\022\017.protobuf.IDMsg\032\021"
-    ".protobuf.BoolRes\0222\n\014ReleaseHuman\022\017.prot"
-    "obuf.IDMsg\032\021.protobuf.BoolRes\022/\n\tHangHum"
-    "an\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\022,"
-    "\n\006Escape\022\017.protobuf.IDMsg\032\021.protobuf.Boo"
-    "lResb\006proto3";
+    "Msg\032\020.protobuf.MsgRes0\001\0223\n\rStartLearning"
+    "\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\0221\n\013"
+    "EndLearning\022\017.protobuf.IDMsg\032\021.protobuf."
+    "BoolRes\0223\n\rStartHelpMate\022\017.protobuf.IDMs"
+    "g\032\021.protobuf.BoolRes\0221\n\013EndHelpMate\022\017.pr"
+    "otobuf.IDMsg\032\021.protobuf.BoolRes\022.\n\005Trick"
+    "\022\022.protobuf.TrickMsg\032\021.protobuf.BoolRes\022"
+    "/\n\tStartExam\022\017.protobuf.IDMsg\032\021.protobuf"
+    ".BoolRes\022-\n\007EndExam\022\017.protobuf.IDMsg\032\021.p"
+    "rotobuf.BoolRes\022.\n\010MakeFail\022\017.protobuf.I"
+    "DMsg\032\021.protobuf.BoolRes\022.\n\010Graduate\022\017.pr"
+    "otobuf.IDMsg\032\021.protobuf.BoolResb\006proto3";
 static const ::_pbi::DescriptorTable* const descriptor_table_Services_2eproto_deps[2] = {
     &::descriptor_table_Message2Clients_2eproto,
     &::descriptor_table_Message2Server_2eproto,
@@ -63,7 +62,7 @@ static ::_pbi::once_flag descriptor_table_Services_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_Services_2eproto = {
     false,
     false,
-    972,
+    959,
     descriptor_table_protodef_Services_2eproto,
     "Services.proto",
     &descriptor_table_Services_2eproto_once,

CAPI/proto/Services.pb.h

@@ -13,7 +13,7 @@
 #error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
 #error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.

dependency/proto/Message2Clients.proto

@@ -4,43 +4,43 @@ package protobuf;
 
 import "MessageType.proto";
 
-message MessageOfHuman
+message MessageOfStudent
 {
     int32 x = 1;
     int32 y = 2;
     int32 speed = 3;
-    int32 life = 4; // 本次未倒地前的血量，也即还可以受的伤害
-    int32 hanged_time = 5; // 被挂上的次数
+    int32 determination = 4; // 剩余的学习毅力，相当于血量
+    int32 fail_num = 5; // 挂科的科目数
     double time_until_skill_available = 6;
     PlaceType place = 7;
     PropType prop = 8;
-    HumanType human_type = 9;
+    StudentType student_type = 9;
     int64 guid = 10;
-    HumanState state = 11;
-    double chair_time = 12; // 被挂的时间
-    double ground_time = 14; // 倒地时间
+    StudentState state = 11;
+    double fail_time = 12; // 挂科的时间
+    double emo_time = 14; // EMO的时间
     int64 player_id = 15;
     int32 view_range = 16; // 视野距离
     int32 radius = 17; // 半径
-    repeated HumanBuffType buff = 18;
+    repeated StudentBuffType buff = 18;
 }
 
-message MessageOfButcher
+message MessageOfTricker
 {
     int32 x = 1;
     int32 y = 2;
     int32 speed = 3;
-    int32 damage = 4;
+    int32 damage = 4; // 对学生造成的心理伤害
     double time_until_skill_available = 5;
     PlaceType place = 6;
     PropType prop = 7;
-    ButcherType butcher_type = 8;
+    TrickerType tricker_type = 8;
     int64 guid = 9;
     bool movable = 10; // 是否进入了攻击后摇
     int64 player_id = 11;
     int32 view_range = 12; // 视野距离
     int32 radius = 13; // 半径
-    repeated ButcherBuffType buff = 14;
+    repeated TrickerBuffType buff = 14;
 }
 
 message MessageOfProp // 可拾取道具的信息
@@ -75,8 +75,8 @@ message MessageOfMap
 
 message MessageToClient
 {
-    repeated MessageOfHuman human_message = 1;
-    repeated MessageOfButcher butcher_message = 2; // 是否真正repeated待定
+    repeated MessageOfStudent student_message = 1;
+    repeated MessageOfTricker tricker_message = 2; // 是否真正repeated待定
     repeated MessageOfProp prop_message = 3;
     MessageOfMap map_message = 4;
     GameState game_state = 5;

dependency/proto/Message2Server.proto

@@ -10,8 +10,8 @@ message PlayerMsg
     PlayerType player_type = 2;
     oneof job_type
     {
-        HumanType human_type = 3;
-        ButcherType butcher_type = 4;
+        StudentType student_type = 3;
+        TrickerType tricker_type = 4;
     }
 }
 
@@ -35,7 +35,7 @@ message SendMsg
     string message = 3;
 }
 
-message AttackMsg
+message TrickMsg // 相当于攻击
 {
     int64 player_id = 1;
     double angle = 2;
@@ -53,7 +53,7 @@ message IDMsg
 //     int64 playerID = 2; // 消息发送者的playerID
 //     PlayerType playerType = 3;
 //     HumanType humanType= 4;
-//     ButcherType butcherType = 5;
+//     TrickerType trickerType = 5;
 //     double angle = 6; // messageType为Move, Attack时的角度
 //     PropType propType = 7; // messageType为PickProp时要捡起的道具类型，防止多个道具堆叠时出现问题
 //     int64 timeInMilliseconds = 8;//时间参数

dependency/proto/MessageType.proto

@@ -10,9 +10,10 @@ enum PlaceType // 地图中的所有物件类型
     LAND = 1;
     WALL = 2;
     GRASS = 3;
-    MACHINE = 4;
-    GATE = 5;
-    HIDDEN_GATE = 6;
+    CLASSROOM = 4;
+    BLACKROOM = 5;
+    GATE = 6;
+    HIDDEN_GATE = 7;
     // 待补充有特殊效果的地形
 
 }
@@ -34,59 +35,60 @@ enum PropType // 地图中的可拾取道具类型
 
 }
 
-enum HumanBuffType // 人类可用的增益效果类型
+enum StudentBuffType // 人类可用的增益效果类型
 {
-    NULL_HBUFF_TYPE = 0;
-    HBUFFTYPE1 = 1;
-    HBUFFTYPE2 = 2;
-    HBUFFTYPE3 = 3;
-    HBUFFTYPE4 = 4;
+    NULL_SBUFF_TYPE = 0;
+    SBUFFTYPE1 = 1;
+    SBUFFTYPE2 = 2;
+    SBUFFTYPE3 = 3;
+    SBUFFTYPE4 = 4;
 }
 
-enum HumanState
+enum StudentState
 {
     NULL_STATUS = 0;
     IDLE = 1; // 正常状态
-    FIXING = 2; // 修理状态
-    DYING = 3; // 濒死状态 
-    ON_CHAIR = 4; // 被挂
-    DEAD = 5; // 死亡状态
+    LEARNING = 2; // 学习状态，相当于在修机器
+    FAIL = 3; // 挂科状态，相当于被挂了
+    EMOTIONAL = 4; // EMO状态，相当于倒地了
+    QUIT = 5; // 退学状态，相当于寄了
+    GRADUATED = 6; // 毕业状态，相当于逃脱了
 }
 
-enum ButcherBuffType // 屠夫可用的增益效果类型
+enum TrickerBuffType // 屠夫可用的增益效果类型
 {
-    NULL_BBUFF_TYPE = 0;
-    BBUFFTYPE1 = 1;
-    BBUFFTYPE2 = 2;
-    BBUFFTYPE3 = 3;
-    BBUFFTYPE4 = 4;
+    NULL_TBUFF_TYPE = 0;
+    TBUFFTYPE1 = 1;
+    TBUFFTYPE2 = 2;
+    TBUFFTYPE3 = 3;
+    TBUFFTYPE4 = 4;
 }
 
-// 特别说明：由于Human阵营和Butcher阵营有显著的隔离，且暂定职业、主动技能和被动效果相互绑定，故不按照THUAI5的方式区分ActiveSkillType和CharacterType，而是选择了按照阵营来给不同阵营赋予不同的职业（及技能）。
+// 特别说明：由于Student阵营和Tricker阵营有显著的隔离，且暂定职业、主动技能和被动效果相互绑定，故不按照THUAI5的方式区分ActiveSkillType和CharacterType，而是选择了按照阵营来给不同阵营赋予不同的职业（及技能）。
 
 enum PlayerType
 {
     NULL_PLAYER_TYPE = 0;
-    HUMAN_PLAYER = 1;
-    BUTCHER_PLAYER = 2;
+    STUDENT_PLAYER = 1;
+    TRICKER_PLAYER = 2;
 }
 
-enum HumanType
+enum StudentType
 {
-    NULL_HUMAN_TYPE = 0;
-    HUMANTYPE1 = 1;
-    HUMANTYPE2 = 2;
-    HUMANTYPE3 = 3;
-    HUMANTYPE4 = 4;
+    NULL_STUDENT_TYPE = 0;
+    STUDENTTYPE1 = 1;
+    STUDENTTYPE2 = 2;
+    STUDENTTYPE3 = 3;
+    STUDENTTYPE4 = 4;
 }
 
-enum ButcherType
+enum TrickerType
 {
-    NULL_BUTCHER_TYPE = 0;
-    BUTCHERTYPE1 = 1;
-    BUTCHERTYPE2 = 2;
-    BUTCHERTYPE3 = 3;
-    BUTCHERTYPE4 = 4;
+    NULL_TRICKER_TYPE = 0;
+    TRICKERTYPE1 = 1;
+    TRICKERTYPE2 = 2;
+    TRICKERTYPE3 = 3;
+    TRICKERTYPE4 = 4;
 }
 
 // 游戏进行状态

dependency/proto/Services.proto

@@ -6,26 +6,26 @@ import "Message2Server.proto";
 
 service AvailableService
 {
-    rpc TryConnection(IDMsg) returns(BoolRes);
+    rpc TryConnection (IDMsg) returns(BoolRes);
 
     // 游戏开局调用一次的服务
-    rpc AddPlayer(PlayerMsg) returns(stream MessageToClient); // 连接上后等待游戏开始，server会定时通过该服务向所有client发送消息。
+    rpc AddPlayer (PlayerMsg) returns(stream MessageToClient); // 连接上后等待游戏开始，server会定时通过该服务向所有client发送消息。
 
     // 游戏过程中玩家执行操作的服务
-    rpc Move(MoveMsg) returns (MoveRes);
-    rpc PickProp(PickMsg) returns (BoolRes);
-    rpc UseProp(IDMsg) returns (BoolRes);
-    rpc UseSkill(IDMsg) returns (BoolRes);
-    rpc SendMessage(SendMsg) returns (BoolRes);
-    rpc GetMessage(IDMsg) returns (stream MsgRes);
-    rpc StartFixMachine(IDMsg) returns (BoolRes); // 开始修理机器
-    rpc EndFixMachine(IDMsg) returns (BoolRes); // 主动停止修复
-    rpc StartSaveHuman(IDMsg) returns (BoolRes); // 开始救人
-    rpc EndSaveHuman(IDMsg) returns (BoolRes); // 主动停止救人
-    rpc Attack (AttackMsg) returns (BoolRes);
-    rpc CarryHuman (IDMsg) returns (BoolRes);
-    rpc ReleaseHuman (IDMsg) returns (BoolRes);
-    rpc HangHuman (IDMsg) returns (BoolRes);
-    rpc Escape (IDMsg) returns (BoolRes);
+    rpc Move (MoveMsg) returns (MoveRes);
+    rpc PickProp (PickMsg) returns (BoolRes);
+    rpc UseProp (IDMsg) returns (BoolRes);
+    rpc UseSkill (IDMsg) returns (BoolRes);
+    rpc SendMessage (SendMsg) returns (BoolRes);
+    rpc GetMessage (IDMsg) returns (stream MsgRes);
+    rpc StartLearning (IDMsg) returns (BoolRes); // 开始修理机器
+    rpc EndLearning (IDMsg) returns (BoolRes); // 主动停止修复
+    rpc StartHelpMate (IDMsg) returns (BoolRes); // 开始救人
+    rpc EndHelpMate (IDMsg) returns (BoolRes); // 主动停止救人
+    rpc Trick (TrickMsg) returns (BoolRes); // 攻击
+    rpc StartExam (IDMsg) returns (BoolRes); // 相当于背人
+    rpc EndExam (IDMsg) returns (BoolRes); // 相当于放人
+    rpc MakeFail (IDMsg) returns (BoolRes); // 相当于挂人
+    rpc Graduate (IDMsg) returns (BoolRes); // 相当于逃跑
     
 }