feat(CAPI): ✨ update new service and other funcs

CAPI/cpp/API/include/API.h

@@ -67,8 +67,8 @@ public:
     virtual bool Graduate() = 0;
 
     virtual bool StartLearning() = 0;
-    virtual bool StartTreatMate() = 0;
-    virtual bool StartRescueMate() = 0;
+    virtual bool StartTreatMate(int64_t mateID) = 0;
+    virtual bool StartRescueMate(int64_t mateID) = 0;
 
     virtual bool OpenDoor() = 0;
     virtual bool CloseDoor() = 0;
@@ -171,8 +171,8 @@ public:
     /*****学生阵营的特定函数*****/
 
     virtual std::future<bool> StartLearning() = 0;
-    virtual std::future<bool> StartTreatMate() = 0;
-    virtual std::future<bool> StartRescueMate() = 0;
+    virtual std::future<bool> StartTreatMate(int64_t mateID) = 0;
+    virtual std::future<bool> StartRescueMate(int64_t mateID) = 0;
     virtual std::future<bool> Graduate() = 0;
     [[nodiscard]] virtual std::shared_ptr<const THUAI6::Student> GetSelfInfo() const = 0;
 };
@@ -257,8 +257,8 @@ public:
     [[nodiscard]] std::vector<int64_t> GetPlayerGUIDs() const override;
 
     std::future<bool> StartLearning() override;
-    std::future<bool> StartTreatMate() override;
-    std::future<bool> StartRescueMate() override;
+    std::future<bool> StartTreatMate(int64_t mateID) override;
+    std::future<bool> StartRescueMate(int64_t mateID) override;
     std::future<bool> Graduate() override;
     [[nodiscard]] std::shared_ptr<const THUAI6::Student> GetSelfInfo() const override;
 
@@ -413,8 +413,8 @@ public:
     [[nodiscard]] std::vector<int64_t> GetPlayerGUIDs() const override;
 
     std::future<bool> StartLearning() override;
-    std::future<bool> StartTreatMate() override;
-    std::future<bool> StartRescueMate() override;
+    std::future<bool> StartTreatMate(int64_t mateID) override;
+    std::future<bool> StartRescueMate(int64_t mateID) override;
     std::future<bool> Graduate() override;
     [[nodiscard]] virtual std::shared_ptr<const THUAI6::Student> GetSelfInfo() const override;
 

CAPI/cpp/API/include/Communication.h

@@ -38,8 +38,8 @@ public:
     bool Graduate(int64_t playerID);
 
     bool StartLearning(int64_t playerID);
-    bool StartTreatMate(int64_t playerID);
-    bool StartRescueMate(int64_t playerID);
+    bool StartTreatMate(int64_t playerID, int64_t mateID);
+    bool StartRescueMate(int64_t playerID, int64_t mateID);
 
     bool Attack(double angle, int64_t playerID);
 

CAPI/cpp/API/include/logic.h

@@ -123,8 +123,8 @@ private:
 
     bool StartLearning() override;
 
-    bool StartTreatMate() override;
-    bool StartRescueMate() override;
+    bool StartTreatMate(int64_t mateID) override;
+    bool StartRescueMate(int64_t mateID) override;
 
     bool Attack(double angle) override;
 

CAPI/cpp/API/include/structures.h

@@ -263,9 +263,6 @@ namespace THUAI6
         int32_t studentQuited;
         int32_t studentScore;
         int32_t trickerScore;
-        bool gateOpened;
-        bool hiddenGateRefreshed;
-        bool hiddenGateOpened;
     };
 
     // 仅供DEBUG使用，名称可改动

CAPI/cpp/API/include/utils.hpp

@@ -270,9 +270,6 @@ namespace Proto2THUAI6
         gameInfo->studentQuited = allMsg.student_quited();
         gameInfo->studentScore = allMsg.student_score();
         gameInfo->trickerScore = allMsg.tricker_score();
-        gameInfo->gateOpened = allMsg.gate_opened();
-        gameInfo->hiddenGateOpened = allMsg.hidden_gate_opened();
-        gameInfo->hiddenGateRefreshed = allMsg.hidden_gate_refreshed();
         return gameInfo;
     }
 
@@ -409,6 +406,14 @@ namespace THUAI62Proto
         return idMsg;
     }
 
+    inline protobuf::TreatAndRescueMsg THUAI62ProtobufTreatAndRescue(int64_t playerID, int64_t mateID)
+    {
+        protobuf::TreatAndRescueMsg treatAndRescueMsg;
+        treatAndRescueMsg.set_player_id(playerID);
+        treatAndRescueMsg.set_to_player_id(mateID);
+        return treatAndRescueMsg;
+    }
+
     inline protobuf::MoveMsg THUAI62ProtobufMove(int64_t time, double angle, int64_t id)
     {
         protobuf::MoveMsg moveMsg;

CAPI/cpp/API/src/AI.cpp

@@ -17,8 +17,31 @@ extern const THUAI6::StudentType studentType = THUAI6::StudentType::Athlete;
 
 void AI::play(IStudentAPI& api)
 {
-    api.Move(100, 1);
+    int placei = 0, placej = 0;
+    auto self = api.GetSelfInfo();
+    auto map = api.GetFullMap();
+    for (int i = 0; i < map.size(); i++)
+        for (int j = 0; j < map[i].size(); j++)
+            if (map[i][j] == THUAI6::PlaceType::ClassRoom)
+            {
+                placei = i;
+                placej = j;
+                break;
+            }
+    if (placei < api.GridToCell(self->x))
+        api.MoveLeft(100);
+    else if (placei > api.GridToCell(self->x))
+        api.MoveRight(100);
+    else if (placej < api.GridToCell(self->y))
+        api.MoveUp(100);
+    else if (placej > api.GridToCell(self->y))
+        api.MoveDown(100);
+    else
+        api.Move(100, 1);
+
     api.PrintSelfInfo();
+    api.PrintTricker();
+    api.PrintStudent();
 }
 
 void AI::play(ITrickerAPI& api)

CAPI/cpp/API/src/API.cpp

@@ -15,7 +15,7 @@ int TrickerAPI::GetFrameCount() const
 
 std::future<bool> StudentAPI::Move(int64_t timeInMilliseconds, double angleInRadian)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.Move(timeInMilliseconds, angleInRadian); });
 }
 
@@ -41,7 +41,7 @@ std::future<bool> StudentAPI::MoveLeft(int64_t timeInMilliseconds)
 
 std::future<bool> TrickerAPI::Move(int64_t timeInMilliseconds, double angleInRadian)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.Move(timeInMilliseconds, angleInRadian); });
 }
 
@@ -67,7 +67,7 @@ std::future<bool> TrickerAPI::MoveLeft(int64_t timeInMilliseconds)
 
 std::future<bool> StudentAPI::PickProp(THUAI6::PropType prop)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.PickProp(prop); });
 }
 
@@ -79,7 +79,7 @@ std::future<bool> StudentAPI::UseProp(THUAI6::PropType prop)
 
 std::future<bool> TrickerAPI::PickProp(THUAI6::PropType prop)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.PickProp(prop); });
 }
 
@@ -103,129 +103,129 @@ std::future<bool> TrickerAPI::UseSkill(int32_t skillID)
 
 std::future<bool> StudentAPI::OpenDoor()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.OpenDoor(); });
 }
 
 std::future<bool> TrickerAPI::OpenDoor()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.OpenDoor(); });
 }
 
 std::future<bool> StudentAPI::CloseDoor()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.CloseDoor(); });
 }
 
 std::future<bool> TrickerAPI::CloseDoor()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.CloseDoor(); });
 }
 
 std::future<bool> StudentAPI::SkipWindow()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.SkipWindow(); });
 }
 
 std::future<bool> TrickerAPI::SkipWindow()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.SkipWindow(); });
 }
 
 std::future<bool> StudentAPI::StartOpenGate()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.StartOpenGate(); });
 }
 
 std::future<bool> TrickerAPI::StartOpenGate()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.StartOpenGate(); });
 }
 
 std::future<bool> StudentAPI::StartOpenChest()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.StartOpenChest(); });
 }
 
 std::future<bool> TrickerAPI::StartOpenChest()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.StartOpenChest(); });
 }
 
 std::future<bool> StudentAPI::EndAllAction()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.EndAllAction(); });
 }
 
 std::future<bool> TrickerAPI::EndAllAction()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.EndAllAction(); });
 }
 
 std::future<bool> StudentAPI::SendMessage(int64_t toID, std::string message)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.SendMessage(toID, message); });
 }
 
 std::future<bool> TrickerAPI::SendMessage(int64_t toID, std::string message)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.SendMessage(toID, message); });
 }
 
 std::future<bool> StudentAPI::HaveMessage()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.HaveMessage(); });
 }
 
 std::future<bool> TrickerAPI::HaveMessage()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.HaveMessage(); });
 }
 
 std::future<std::optional<std::pair<int64_t, std::string>>> StudentAPI::GetMessage()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.GetMessage(); });
 }
 
 std::future<std::optional<std::pair<int64_t, std::string>>> TrickerAPI::GetMessage()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.GetMessage(); });
 }
 
 std::future<bool> StudentAPI::Wait()
 {
     if (logic.GetCounter() == -1)
-        return std::async(std::launch::async, [&]()
+        return std::async(std::launch::async, [this]()
                           { return false; });
     else
-        return std::async(std::launch::async, [&]()
+        return std::async(std::launch::async, [this]()
                           { return logic.WaitThread(); });
 }
 
 std::future<bool> TrickerAPI::Wait()
 {
     if (logic.GetCounter() == -1)
-        return std::async(std::launch::async, [&]()
+        return std::async(std::launch::async, [this]()
                           { return false; });
     else
-        return std::async(std::launch::async, [&]()
+        return std::async(std::launch::async, [this]()
                           { return logic.WaitThread(); });
 }
 
@@ -361,25 +361,25 @@ std::vector<int64_t> TrickerAPI::GetPlayerGUIDs() const
 
 std::future<bool> StudentAPI::StartLearning()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.StartLearning(); });
 }
 
-std::future<bool> StudentAPI::StartTreatMate()
+std::future<bool> StudentAPI::StartTreatMate(int64_t mateID)
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.StartTreatMate(); });
+    return std::async(std::launch::async, [=]()
+                      { return logic.StartTreatMate(mateID); });
 }
 
-std::future<bool> StudentAPI::StartRescueMate()
+std::future<bool> StudentAPI::StartRescueMate(int64_t mateID)
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.StartRescueMate(); });
+    return std::async(std::launch::async, [=]()
+                      { return logic.StartRescueMate(mateID); });
 }
 
 std::future<bool> StudentAPI::Graduate()
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [this]()
                       { return logic.Graduate(); });
 }
 
@@ -390,13 +390,13 @@ std::shared_ptr<const THUAI6::Student> StudentAPI::GetSelfInfo() const
 
 std::future<bool> TrickerAPI::Attack(double angleInRadian)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.Attack(angleInRadian); });
 }
 
 std::future<bool> StudentAPI::Attack(double angleInRadian)
 {
-    return std::async(std::launch::async, [&]()
+    return std::async(std::launch::async, [=]()
                       { return logic.Attack(angleInRadian); });
 }
 

CAPI/cpp/API/src/Communication.cpp

@@ -171,11 +171,11 @@ bool Communication::StartLearning(int64_t playerID)
         return false;
 }
 
-bool Communication::StartRescueMate(int64_t playerID)
+bool Communication::StartRescueMate(int64_t playerID, int64_t mateID)
 {
     protobuf::BoolRes saveStudentResult;
     ClientContext context;
-    auto request = THUAI62Proto::THUAI62ProtobufID(playerID);
+    auto request = THUAI62Proto::THUAI62ProtobufTreatAndRescue(playerID, mateID);
     auto status = THUAI6Stub->StartRescueMate(&context, request, &saveStudentResult);
     if (status.ok())
         return saveStudentResult.act_success();
@@ -183,11 +183,11 @@ bool Communication::StartRescueMate(int64_t playerID)
         return false;
 }
 
-bool Communication::StartTreatMate(int64_t playerID)
+bool Communication::StartTreatMate(int64_t playerID, int64_t mateID)
 {
     protobuf::BoolRes healStudentResult;
     ClientContext context;
-    auto request = THUAI62Proto::THUAI62ProtobufID(playerID);
+    auto request = THUAI62Proto::THUAI62ProtobufTreatAndRescue(playerID, mateID);
     auto status = THUAI6Stub->StartTreatMate(&context, request, &healStudentResult);
     if (status.ok())
         return healStudentResult.act_success();

CAPI/cpp/API/src/DebugAPI.cpp

@@ -209,74 +209,122 @@ std::future<bool> TrickerDebugAPI::UseSkill(int32_t skillID)
 
 std::future<bool> StudentDebugAPI::OpenDoor()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.OpenDoor(); });
+    logger->info("OpenDoor: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.OpenDoor();
+                        if (!result)
+                            logger->warn("OpenDoor: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> TrickerDebugAPI::OpenDoor()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.OpenDoor(); });
+    logger->info("OpenDoor: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.OpenDoor();
+                        if (!result)
+                            logger->warn("OpenDoor: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> StudentDebugAPI::CloseDoor()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.CloseDoor(); });
+    logger->info("CloseDoor: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.CloseDoor();
+                        if (!result)
+                            logger->warn("CloseDoor: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> TrickerDebugAPI::CloseDoor()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.CloseDoor(); });
+    logger->info("CloseDoor: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.CloseDoor();
+                        if (!result)
+                            logger->warn("CloseDoor: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> StudentDebugAPI::SkipWindow()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.SkipWindow(); });
+    logger->info("SkipWindow: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.SkipWindow();
+                        if (!result)
+                            logger->warn("SkipWindow: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> TrickerDebugAPI::SkipWindow()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.SkipWindow(); });
+    logger->info("SkipWindow: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.SkipWindow();
+                        if (!result)
+                            logger->warn("SkipWindow: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> StudentDebugAPI::StartOpenGate()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.StartOpenGate(); });
+    logger->info("StartOpenGate: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.StartOpenGate();
+                        if (!result)
+                            logger->warn("StartOpenGate: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> TrickerDebugAPI::StartOpenGate()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.StartOpenGate(); });
+    logger->info("StartOpenGate: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.StartOpenGate();
+                        if (!result)
+                            logger->warn("StartOpenGate: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> StudentDebugAPI::StartOpenChest()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.StartOpenChest(); });
+    logger->info("StartOpenChest: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.StartOpenChest();
+                        if (!result)
+                            logger->warn("StartOpenChest: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> TrickerDebugAPI::StartOpenChest()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.StartOpenChest(); });
+    logger->info("StartOpenChest: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.StartOpenChest();
+                        if (!result)
+                            logger->warn("StartOpenChest: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> StudentDebugAPI::EndAllAction()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.EndAllAction(); });
+    logger->info("EndAllAction: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.EndAllAction();
+                        if (!result)
+                            logger->warn("EndAllAction: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> TrickerDebugAPI::EndAllAction()
 {
-    return std::async(std::launch::async, [&]()
-                      { return logic.EndAllAction(); });
+    logger->info("EndAllAction: called at {}ms", Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [this]()
+                      { auto result = logic.EndAllAction();
+                        if (!result)
+                            logger->warn("EndAllAction: failed at {}ms", Time::TimeSinceStart(startPoint));
+                        return result; });
 }
 
 std::future<bool> StudentDebugAPI::SendMessage(int64_t toID, std::string message)
@@ -501,21 +549,21 @@ std::future<bool> StudentDebugAPI::StartLearning()
                         return result; });
 }
 
-std::future<bool> StudentDebugAPI::StartRescueMate()
+std::future<bool> StudentDebugAPI::StartRescueMate(int64_t mateID)
 {
-    logger->info("StartRescueMate: called at {}ms", Time::TimeSinceStart(startPoint));
-    return std::async(std::launch::async, [this]()
-                      { auto result = logic.StartRescueMate();
+    logger->info("StartRescueMate: mate id={}, called at {}ms", mateID, Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [=]()
+                      { auto result = logic.StartRescueMate(mateID);
                         if (!result)
                             logger->warn("StartRescueMate: failed at {}ms", Time::TimeSinceStart(startPoint));
                         return result; });
 }
 
-std::future<bool> StudentDebugAPI::StartTreatMate()
+std::future<bool> StudentDebugAPI::StartTreatMate(int64_t mateID)
 {
-    logger->info("StartTreatMate: called at {}ms", Time::TimeSinceStart(startPoint));
-    return std::async(std::launch::async, [this]()
-                      { auto result = logic.StartTreatMate();
+    logger->info("StartTreatMate: mate id={}, called at {}ms", mateID, Time::TimeSinceStart(startPoint));
+    return std::async(std::launch::async, [=]()
+                      { auto result = logic.StartTreatMate(mateID);
                         if (!result)
                             logger->warn("StartTreatMate: failed at {}ms", Time::TimeSinceStart(startPoint));
                         return result; });

CAPI/cpp/API/src/logic.cpp

@@ -220,16 +220,16 @@ bool Logic::StartLearning()
     return pComm->StartLearning(playerID);
 }
 
-bool Logic::StartTreatMate()
+bool Logic::StartTreatMate(int64_t mateID)
 {
     logger->debug("Called StartTreatMate");
-    return pComm->StartTreatMate(playerID);
+    return pComm->StartTreatMate(playerID, mateID);
 }
 
-bool Logic::StartRescueMate()
+bool Logic::StartRescueMate(int64_t mateID)
 {
     logger->debug("Called StartRescueMate");
-    return pComm->StartRescueMate(playerID);
+    return pComm->StartRescueMate(playerID, mateID);
 }
 
 bool Logic::Attack(double angle)
@@ -282,7 +282,7 @@ bool Logic::WaitThread()
 
 void Logic::ProcessMessage()
 {
-    auto messageThread = [&]()
+    auto messageThread = [this]()
     {
         logger->info("Message thread start!");
         pComm->AddPlayer(playerID, playerType, studentType, trickerType);
@@ -682,7 +682,7 @@ void Logic::Update() noexcept
         std::unique_lock<std::mutex> lock(mtxBuffer);
 
         // 缓冲区被更新之后才可以使用
-        cvBuffer.wait(lock, [&]()
+        cvBuffer.wait(lock, [this]()
                       { return bufferUpdated; });
 
         std::swap(currentState, bufferState);
@@ -697,7 +697,7 @@ void Logic::Wait() noexcept
     freshed = false;
     {
         std::unique_lock<std::mutex> lock(mtxBuffer);
-        cvBuffer.wait(lock, [&]()
+        cvBuffer.wait(lock, [this]()
                       { return freshed.load(); });
     }
 }

CAPI/cpp/API/src/main.cpp

@@ -10,7 +10,7 @@
 int THUAI6Main(int argc, char** argv, CreateAIFunc AIBuilder)
 {
     int pID = 0;
-    std::string sIP = "183.172.213.88";
+    std::string sIP = "183.172.169.99";
     std::string sPort = "8888";
     bool file = false;
     bool print = false;
@@ -18,9 +18,8 @@ int THUAI6Main(int argc, char** argv, CreateAIFunc AIBuilder)
     extern const THUAI6::PlayerType playerType;
     extern const THUAI6::TrickerType trickerType;
     extern const THUAI6::StudentType studentType;
-    // 仅供早期调试使用
     // {
-    //     file = false;
+    //     file = true;
     //     print = true;
     //     Logic logic(playerType, pID, trickerType, studentType);
     //     logic.Main(AIBuilder, sIP, sPort, file, print, warnOnly);
@@ -38,7 +37,7 @@ int THUAI6Main(int argc, char** argv, CreateAIFunc AIBuilder)
         TCLAP::ValueArg<std::string> serverPort("P", "serverPort", "Port the server listens to 7777 in default", false, "7777", "USORT");
         cmd.add(serverPort);
 
-        std::vector<int> validPlayerIDs{0, 1, 2, 3};
+        std::vector<int> validPlayerIDs{0, 1, 2, 3, 4};
         TCLAP::ValuesConstraint<int> playerIdConstraint(validPlayerIDs);
         TCLAP::ValueArg<int> playerID("p", "playerID", "Player ID 0,1,2,3 valid only", true, -1, &playerIdConstraint);
         cmd.add(playerID);
@@ -71,8 +70,15 @@ int THUAI6Main(int argc, char** argv, CreateAIFunc AIBuilder)
         return 1;
     }
     std::cout << file << std::endl;
-    Logic logic(playerType, pID, trickerType, studentType);
-    logic.Main(AIBuilder, sIP, sPort, file, print, warnOnly);
+    try
+    {
+        Logic logic(playerType, pID, trickerType, studentType);
+        logic.Main(AIBuilder, sIP, sPort, file, print, warnOnly);
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << e.what() << '\n';
+    }
     return 0;
 }
 

CAPI/cpp/proto/Message2Server.pb.cc

@@ -154,6 +154,28 @@ namespace protobuf
         };
     };
     PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IDMsgDefaultTypeInternal _IDMsg_default_instance_;
+    PROTOBUF_CONSTEXPR TreatAndRescueMsg::TreatAndRescueMsg(
+        ::_pbi::ConstantInitialized
+    ) :
+        _impl_{
+            /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.to_player_id_)*/ int64_t{0}, /*decltype(_impl_._cached_size_)*/ {}}
+    {
+    }
+    struct TreatAndRescueMsgDefaultTypeInternal
+    {
+        PROTOBUF_CONSTEXPR TreatAndRescueMsgDefaultTypeInternal() :
+            _instance(::_pbi::ConstantInitialized{})
+        {
+        }
+        ~TreatAndRescueMsgDefaultTypeInternal()
+        {
+        }
+        union
+        {
+            TreatAndRescueMsg _instance;
+        };
+    };
+    PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TreatAndRescueMsgDefaultTypeInternal _TreatAndRescueMsg_default_instance_;
     PROTOBUF_CONSTEXPR SkillMsg::SkillMsg(
         ::_pbi::ConstantInitialized
     ) :
@@ -177,7 +199,7 @@ namespace protobuf
     };
     PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkillMsgDefaultTypeInternal _SkillMsg_default_instance_;
 }  // namespace protobuf
-static ::_pb::Metadata file_level_metadata_Message2Server_2eproto[7];
+static ::_pb::Metadata file_level_metadata_Message2Server_2eproto[8];
 static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_Message2Server_2eproto = nullptr;
 static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_Message2Server_2eproto = nullptr;
 
@@ -235,6 +257,14 @@ const uint32_t TableStruct_Message2Server_2eproto::offsets[] PROTOBUF_SECTION_VA
     ~0u,  // no _inlined_string_donated_
     PROTOBUF_FIELD_OFFSET(::protobuf::IDMsg, _impl_.player_id_),
     ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::protobuf::TreatAndRescueMsg, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    PROTOBUF_FIELD_OFFSET(::protobuf::TreatAndRescueMsg, _impl_.player_id_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::TreatAndRescueMsg, _impl_.to_player_id_),
+    ~0u,  // no _has_bits_
     PROTOBUF_FIELD_OFFSET(::protobuf::SkillMsg, _internal_metadata_),
     ~0u,  // no _extensions_
     ~0u,  // no _oneof_case_
@@ -250,7 +280,8 @@ static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protode
     {28, -1, -1, sizeof(::protobuf::SendMsg)},
     {37, -1, -1, sizeof(::protobuf::AttackMsg)},
     {45, -1, -1, sizeof(::protobuf::IDMsg)},
-    {52, -1, -1, sizeof(::protobuf::SkillMsg)},
+    {52, -1, -1, sizeof(::protobuf::TreatAndRescueMsg)},
+    {60, -1, -1, sizeof(::protobuf::SkillMsg)},
 };
 
 static const ::_pb::Message* const file_default_instances[] = {
@@ -260,6 +291,7 @@ static const ::_pb::Message* const file_default_instances[] = {
     &::protobuf::_SendMsg_default_instance_._instance,
     &::protobuf::_AttackMsg_default_instance_._instance,
     &::protobuf::_IDMsg_default_instance_._instance,
+    &::protobuf::_TreatAndRescueMsg_default_instance_._instance,
     &::protobuf::_SkillMsg_default_instance_._instance,
 };
 
@@ -277,8 +309,9 @@ const char descriptor_table_protodef_Message2Server_2eproto[] PROTOBUF_SECTION_V
     "d\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\005angle\030\002 \001(\001\"\032\n\005IDMsg\022\021\n\tplayer_id\030\001 \001("
-    "\003\"/\n\010SkillMsg\022\021\n\tplayer_id\030\001 \001(\003\022\020\n\010skil"
-    "l_id\030\002 \001(\005b\006proto3";
+    "\003\"<\n\021TreatAndRescueMsg\022\021\n\tplayer_id\030\001 \001("
+    "\003\022\024\n\014to_player_id\030\002 \001(\003\"/\n\010SkillMsg\022\021\n\tp"
+    "layer_id\030\001 \001(\003\022\020\n\010skill_id\030\002 \001(\005b\006proto3";
 static const ::_pbi::DescriptorTable* const descriptor_table_Message2Server_2eproto_deps[1] = {
     &::descriptor_table_MessageType_2eproto,
 };
@@ -286,13 +319,13 @@ static ::_pbi::once_flag descriptor_table_Message2Server_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_Message2Server_2eproto = {
     false,
     false,
-    578,
+    640,
     descriptor_table_protodef_Message2Server_2eproto,
     "Message2Server.proto",
     &descriptor_table_Message2Server_2eproto_once,
     descriptor_table_Message2Server_2eproto_deps,
     1,
-    7,
+    8,
     schemas,
     file_default_instances,
     TableStruct_Message2Server_2eproto::offsets,
@@ -1968,6 +2001,247 @@ namespace protobuf
 
     // ===================================================================
 
+    class TreatAndRescueMsg::_Internal
+    {
+    public:
+    };
+
+    TreatAndRescueMsg::TreatAndRescueMsg(::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.TreatAndRescueMsg)
+    }
+    TreatAndRescueMsg::TreatAndRescueMsg(const TreatAndRescueMsg& from) :
+        ::PROTOBUF_NAMESPACE_ID::Message()
+    {
+        TreatAndRescueMsg* const _this = this;
+        (void)_this;
+        new (&_impl_) Impl_{
+            decltype(_impl_.player_id_){}, decltype(_impl_.to_player_id_){}, /*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_.to_player_id_) - reinterpret_cast<char*>(&_impl_.player_id_)) + sizeof(_impl_.to_player_id_));
+        // @@protoc_insertion_point(copy_constructor:protobuf.TreatAndRescueMsg)
+    }
+
+    inline void TreatAndRescueMsg::SharedCtor(
+        ::_pb::Arena* arena, bool is_message_owned
+    )
+    {
+        (void)arena;
+        (void)is_message_owned;
+        new (&_impl_) Impl_{
+            decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.to_player_id_){int64_t{0}}, /*decltype(_impl_._cached_size_)*/ {}};
+    }
+
+    TreatAndRescueMsg::~TreatAndRescueMsg()
+    {
+        // @@protoc_insertion_point(destructor:protobuf.TreatAndRescueMsg)
+        if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>())
+        {
+            (void)arena;
+            return;
+        }
+        SharedDtor();
+    }
+
+    inline void TreatAndRescueMsg::SharedDtor()
+    {
+        GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+    }
+
+    void TreatAndRescueMsg::SetCachedSize(int size) const
+    {
+        _impl_._cached_size_.Set(size);
+    }
+
+    void TreatAndRescueMsg::Clear()
+    {
+        // @@protoc_insertion_point(message_clear_start:protobuf.TreatAndRescueMsg)
+        uint32_t cached_has_bits = 0;
+        // Prevent compiler warnings about cached_has_bits being unused
+        (void)cached_has_bits;
+
+        ::memset(&_impl_.player_id_, 0, static_cast<size_t>(reinterpret_cast<char*>(&_impl_.to_player_id_) - reinterpret_cast<char*>(&_impl_.player_id_)) + sizeof(_impl_.to_player_id_));
+        _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    const char* TreatAndRescueMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx)
+    {
+#define CHK_(x)                       \
+    if (PROTOBUF_PREDICT_FALSE(!(x))) \
+    goto failure
+        while (!ctx->Done(&ptr))
+        {
+            uint32_t tag;
+            ptr = ::_pbi::ReadTag(ptr, &tag);
+            switch (tag >> 3)
+            {
+                // int64 player_id = 1;
+                case 1:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8))
+                    {
+                        _impl_.player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+                        CHK_(ptr);
+                    }
+                    else
+                        goto handle_unusual;
+                    continue;
+                // int64 to_player_id = 2;
+                case 2:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16))
+                    {
+                        _impl_.to_player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+                        CHK_(ptr);
+                    }
+                    else
+                        goto handle_unusual;
+                    continue;
+                default:
+                    goto handle_unusual;
+            }  // switch
+        handle_unusual:
+            if ((tag == 0) || ((tag & 7) == 4))
+            {
+                CHK_(ptr);
+                ctx->SetLastTag(tag);
+                goto message_done;
+            }
+            ptr = UnknownFieldParse(
+                tag,
+                _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+                ptr,
+                ctx
+            );
+            CHK_(ptr != nullptr);
+        }  // while
+    message_done:
+        return ptr;
+    failure:
+        ptr = nullptr;
+        goto message_done;
+#undef CHK_
+    }
+
+    uint8_t* TreatAndRescueMsg::_InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const
+    {
+        // @@protoc_insertion_point(serialize_to_array_start:protobuf.TreatAndRescueMsg)
+        uint32_t cached_has_bits = 0;
+        (void)cached_has_bits;
+
+        // int64 player_id = 1;
+        if (this->_internal_player_id() != 0)
+        {
+            target = stream->EnsureSpace(target);
+            target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_player_id(), target);
+        }
+
+        // int64 to_player_id = 2;
+        if (this->_internal_to_player_id() != 0)
+        {
+            target = stream->EnsureSpace(target);
+            target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_to_player_id(), target);
+        }
+
+        if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields()))
+        {
+            target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+                _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream
+            );
+        }
+        // @@protoc_insertion_point(serialize_to_array_end:protobuf.TreatAndRescueMsg)
+        return target;
+    }
+
+    size_t TreatAndRescueMsg::ByteSizeLong() const
+    {
+        // @@protoc_insertion_point(message_byte_size_start:protobuf.TreatAndRescueMsg)
+        size_t total_size = 0;
+
+        uint32_t cached_has_bits = 0;
+        // Prevent compiler warnings about cached_has_bits being unused
+        (void)cached_has_bits;
+
+        // int64 player_id = 1;
+        if (this->_internal_player_id() != 0)
+        {
+            total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id());
+        }
+
+        // int64 to_player_id = 2;
+        if (this->_internal_to_player_id() != 0)
+        {
+            total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_to_player_id());
+        }
+
+        return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
+    }
+
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TreatAndRescueMsg::_class_data_ = {
+        ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
+        TreatAndRescueMsg::MergeImpl};
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* TreatAndRescueMsg::GetClassData() const
+    {
+        return &_class_data_;
+    }
+
+    void TreatAndRescueMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg)
+    {
+        auto* const _this = static_cast<TreatAndRescueMsg*>(&to_msg);
+        auto& from = static_cast<const TreatAndRescueMsg&>(from_msg);
+        // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.TreatAndRescueMsg)
+        GOOGLE_DCHECK_NE(&from, _this);
+        uint32_t cached_has_bits = 0;
+        (void)cached_has_bits;
+
+        if (from._internal_player_id() != 0)
+        {
+            _this->_internal_set_player_id(from._internal_player_id());
+        }
+        if (from._internal_to_player_id() != 0)
+        {
+            _this->_internal_set_to_player_id(from._internal_to_player_id());
+        }
+        _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+    }
+
+    void TreatAndRescueMsg::CopyFrom(const TreatAndRescueMsg& from)
+    {
+        // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.TreatAndRescueMsg)
+        if (&from == this)
+            return;
+        Clear();
+        MergeFrom(from);
+    }
+
+    bool TreatAndRescueMsg::IsInitialized() const
+    {
+        return true;
+    }
+
+    void TreatAndRescueMsg::InternalSwap(TreatAndRescueMsg* other)
+    {
+        using std::swap;
+        _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+        ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+            PROTOBUF_FIELD_OFFSET(TreatAndRescueMsg, _impl_.to_player_id_) + sizeof(TreatAndRescueMsg::_impl_.to_player_id_) - PROTOBUF_FIELD_OFFSET(TreatAndRescueMsg, _impl_.player_id_)>(
+            reinterpret_cast<char*>(&_impl_.player_id_),
+            reinterpret_cast<char*>(&other->_impl_.player_id_)
+        );
+    }
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata TreatAndRescueMsg::GetMetadata() const
+    {
+        return ::_pbi::AssignDescriptors(
+            &descriptor_table_Message2Server_2eproto_getter, &descriptor_table_Message2Server_2eproto_once, file_level_metadata_Message2Server_2eproto[6]
+        );
+    }
+
+    // ===================================================================
+
     class SkillMsg::_Internal
     {
     public:
@@ -2203,7 +2477,7 @@ namespace protobuf
     ::PROTOBUF_NAMESPACE_ID::Metadata SkillMsg::GetMetadata() const
     {
         return ::_pbi::AssignDescriptors(
-            &descriptor_table_Message2Server_2eproto_getter, &descriptor_table_Message2Server_2eproto_once, file_level_metadata_Message2Server_2eproto[6]
+            &descriptor_table_Message2Server_2eproto_getter, &descriptor_table_Message2Server_2eproto_once, file_level_metadata_Message2Server_2eproto[7]
         );
     }
 
@@ -2247,6 +2521,12 @@ PROTOBUF_NOINLINE ::protobuf::IDMsg*
     return Arena::CreateMessageInternal<::protobuf::IDMsg>(arena);
 }
 template<>
+PROTOBUF_NOINLINE ::protobuf::TreatAndRescueMsg*
+    Arena::CreateMaybeMessage<::protobuf::TreatAndRescueMsg>(Arena* arena)
+{
+    return Arena::CreateMessageInternal<::protobuf::TreatAndRescueMsg>(arena);
+}
+template<>
 PROTOBUF_NOINLINE ::protobuf::SkillMsg*
     Arena::CreateMaybeMessage<::protobuf::SkillMsg>(Arena* arena)
 {

CAPI/cpp/proto/Message2Server.pb.h

@@ -70,6 +70,9 @@ namespace protobuf
     class SkillMsg;
     struct SkillMsgDefaultTypeInternal;
     extern SkillMsgDefaultTypeInternal _SkillMsg_default_instance_;
+    class TreatAndRescueMsg;
+    struct TreatAndRescueMsgDefaultTypeInternal;
+    extern TreatAndRescueMsgDefaultTypeInternal _TreatAndRescueMsg_default_instance_;
 }  // namespace protobuf
 PROTOBUF_NAMESPACE_OPEN
 template<>
@@ -86,6 +89,8 @@ template<>
 ::protobuf::SendMsg* Arena::CreateMaybeMessage<::protobuf::SendMsg>(Arena*);
 template<>
 ::protobuf::SkillMsg* Arena::CreateMaybeMessage<::protobuf::SkillMsg>(Arena*);
+template<>
+::protobuf::TreatAndRescueMsg* Arena::CreateMaybeMessage<::protobuf::TreatAndRescueMsg>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace protobuf
 {
@@ -1392,6 +1397,210 @@ namespace protobuf
     };
     // -------------------------------------------------------------------
 
+    class TreatAndRescueMsg final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.TreatAndRescueMsg) */
+    {
+    public:
+        inline TreatAndRescueMsg() :
+            TreatAndRescueMsg(nullptr)
+        {
+        }
+        ~TreatAndRescueMsg() override;
+        explicit PROTOBUF_CONSTEXPR TreatAndRescueMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+        TreatAndRescueMsg(const TreatAndRescueMsg& from);
+        TreatAndRescueMsg(TreatAndRescueMsg&& from) noexcept
+            :
+            TreatAndRescueMsg()
+        {
+            *this = ::std::move(from);
+        }
+
+        inline TreatAndRescueMsg& operator=(const TreatAndRescueMsg& from)
+        {
+            CopyFrom(from);
+            return *this;
+        }
+        inline TreatAndRescueMsg& operator=(TreatAndRescueMsg&& from) noexcept
+        {
+            if (this == &from)
+                return *this;
+            if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+                && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+            )
+            {
+                InternalSwap(&from);
+            }
+            else
+            {
+                CopyFrom(from);
+            }
+            return *this;
+        }
+
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+        {
+            return GetDescriptor();
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+        {
+            return default_instance().GetMetadata().descriptor;
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+        {
+            return default_instance().GetMetadata().reflection;
+        }
+        static const TreatAndRescueMsg& default_instance()
+        {
+            return *internal_default_instance();
+        }
+        static inline const TreatAndRescueMsg* internal_default_instance()
+        {
+            return reinterpret_cast<const TreatAndRescueMsg*>(
+                &_TreatAndRescueMsg_default_instance_
+            );
+        }
+        static constexpr int kIndexInFileMessages =
+            6;
+
+        friend void swap(TreatAndRescueMsg& a, TreatAndRescueMsg& b)
+        {
+            a.Swap(&b);
+        }
+        inline void Swap(TreatAndRescueMsg* other)
+        {
+            if (other == this)
+                return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() != nullptr &&
+                GetOwningArena() == other->GetOwningArena())
+            {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() == other->GetOwningArena())
+            {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+                InternalSwap(other);
+            }
+            else
+            {
+                ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+            }
+        }
+        void UnsafeArenaSwap(TreatAndRescueMsg* other)
+        {
+            if (other == this)
+                return;
+            GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+            InternalSwap(other);
+        }
+
+        // implements Message ----------------------------------------------
+
+        TreatAndRescueMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        {
+            return CreateMaybeMessage<TreatAndRescueMsg>(arena);
+        }
+        using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+        void CopyFrom(const TreatAndRescueMsg& from);
+        using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+        void MergeFrom(const TreatAndRescueMsg& from)
+        {
+            TreatAndRescueMsg::MergeImpl(*this, from);
+        }
+
+    private:
+        static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+    public:
+        PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+        bool IsInitialized() const final;
+
+        size_t ByteSizeLong() const final;
+        const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+        uint8_t* _InternalSerialize(
+            uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+        ) const final;
+        int GetCachedSize() const final
+        {
+            return _impl_._cached_size_.Get();
+        }
+
+    private:
+        void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+        void SharedDtor();
+        void SetCachedSize(int size) const final;
+        void InternalSwap(TreatAndRescueMsg* other);
+
+    private:
+        friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+        static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+        {
+            return "protobuf.TreatAndRescueMsg";
+        }
+
+    protected:
+        explicit TreatAndRescueMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+    public:
+        static const ClassData _class_data_;
+        const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+        ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+        // nested types ----------------------------------------------------
+
+        // accessors -------------------------------------------------------
+
+        enum : int
+        {
+            kPlayerIdFieldNumber = 1,
+            kToPlayerIdFieldNumber = 2,
+        };
+        // int64 player_id = 1;
+        void clear_player_id();
+        int64_t player_id() const;
+        void set_player_id(int64_t value);
+
+    private:
+        int64_t _internal_player_id() const;
+        void _internal_set_player_id(int64_t value);
+
+    public:
+        // int64 to_player_id = 2;
+        void clear_to_player_id();
+        int64_t to_player_id() const;
+        void set_to_player_id(int64_t value);
+
+    private:
+        int64_t _internal_to_player_id() const;
+        void _internal_set_to_player_id(int64_t value);
+
+    public:
+        // @@protoc_insertion_point(class_scope:protobuf.TreatAndRescueMsg)
+
+    private:
+        class _Internal;
+
+        template<typename T>
+        friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+        typedef void InternalArenaConstructable_;
+        typedef void DestructorSkippable_;
+        struct Impl_
+        {
+            int64_t player_id_;
+            int64_t to_player_id_;
+            mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        };
+        union
+        {
+            Impl_ _impl_;
+        };
+        friend struct ::TableStruct_Message2Server_2eproto;
+    };
+    // -------------------------------------------------------------------
+
     class SkillMsg final :
         public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.SkillMsg) */
     {
@@ -1458,7 +1667,7 @@ namespace protobuf
             );
         }
         static constexpr int kIndexInFileMessages =
-            6;
+            7;
 
         friend void swap(SkillMsg& a, SkillMsg& b)
         {
@@ -2081,6 +2290,58 @@ namespace protobuf
 
     // -------------------------------------------------------------------
 
+    // TreatAndRescueMsg
+
+    // int64 player_id = 1;
+    inline void TreatAndRescueMsg::clear_player_id()
+    {
+        _impl_.player_id_ = int64_t{0};
+    }
+    inline int64_t TreatAndRescueMsg::_internal_player_id() const
+    {
+        return _impl_.player_id_;
+    }
+    inline int64_t TreatAndRescueMsg::player_id() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.TreatAndRescueMsg.player_id)
+        return _internal_player_id();
+    }
+    inline void TreatAndRescueMsg::_internal_set_player_id(int64_t value)
+    {
+        _impl_.player_id_ = value;
+    }
+    inline void TreatAndRescueMsg::set_player_id(int64_t value)
+    {
+        _internal_set_player_id(value);
+        // @@protoc_insertion_point(field_set:protobuf.TreatAndRescueMsg.player_id)
+    }
+
+    // int64 to_player_id = 2;
+    inline void TreatAndRescueMsg::clear_to_player_id()
+    {
+        _impl_.to_player_id_ = int64_t{0};
+    }
+    inline int64_t TreatAndRescueMsg::_internal_to_player_id() const
+    {
+        return _impl_.to_player_id_;
+    }
+    inline int64_t TreatAndRescueMsg::to_player_id() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.TreatAndRescueMsg.to_player_id)
+        return _internal_to_player_id();
+    }
+    inline void TreatAndRescueMsg::_internal_set_to_player_id(int64_t value)
+    {
+        _impl_.to_player_id_ = value;
+    }
+    inline void TreatAndRescueMsg::set_to_player_id(int64_t value)
+    {
+        _internal_set_to_player_id(value);
+        // @@protoc_insertion_point(field_set:protobuf.TreatAndRescueMsg.to_player_id)
+    }
+
+    // -------------------------------------------------------------------
+
     // SkillMsg
 
     // int64 player_id = 1;
@@ -2146,6 +2407,8 @@ namespace protobuf
 
     // -------------------------------------------------------------------
 
+    // -------------------------------------------------------------------
+
     // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace protobuf

CAPI/cpp/proto/Services.grpc.pb.cc

@@ -319,27 +319,27 @@ namespace protobuf
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartRescueMate_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartRescueMate_, context, request, response);
     }
 
-    void AvailableService::Stub::async::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* 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_StartRescueMate_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartRescueMate_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
         ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartRescueMate_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartRescueMate_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::TreatAndRescueMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartRescueMate_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
             this->PrepareAsyncStartRescueMateRaw(context, request, cq);
@@ -347,27 +347,27 @@ namespace protobuf
         return result;
     }
 
-    ::grpc::Status AvailableService::Stub::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Stub::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::protobuf::BoolRes* response)
     {
-        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartTreatMate_, context, request, response);
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartTreatMate_, context, request, response);
     }
 
-    void AvailableService::Stub::async::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    void AvailableService::Stub::async::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* 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_StartTreatMate_, context, request, response, std::move(f));
+        ::grpc::internal::CallbackUnaryCall<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartTreatMate_, context, request, response, std::move(f));
     }
 
-    void AvailableService::Stub::async::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    void AvailableService::Stub::async::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
     {
         ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartTreatMate_, context, request, response, reactor);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
     {
-        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartTreatMate_, context, request);
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::TreatAndRescueMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartTreatMate_, context, request);
     }
 
-    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
     {
         auto* result =
             this->PrepareAsyncStartTreatMateRaw(context, request, cq);
@@ -730,10 +730,10 @@ namespace protobuf
         AddMethod(new ::grpc::internal::RpcServiceMethod(
             AvailableService_method_names[9],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
-            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
                    ::grpc::ServerContext* ctx,
-                   const ::protobuf::IDMsg* req,
+                   const ::protobuf::TreatAndRescueMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
                     return service->StartRescueMate(ctx, req, resp);
@@ -744,10 +744,10 @@ namespace protobuf
         AddMethod(new ::grpc::internal::RpcServiceMethod(
             AvailableService_method_names[10],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
-            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
                    ::grpc::ServerContext* ctx,
-                   const ::protobuf::IDMsg* req,
+                   const ::protobuf::TreatAndRescueMsg* req,
                    ::protobuf::BoolRes* resp)
                 {
                     return service->StartTreatMate(ctx, req, resp);
@@ -945,7 +945,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::StartRescueMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::StartRescueMate(::grpc::ServerContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;
@@ -953,7 +953,7 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
-    ::grpc::Status AvailableService::Service::StartTreatMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    ::grpc::Status AvailableService::Service::StartTreatMate(::grpc::ServerContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response)
     {
         (void)context;
         (void)request;

CAPI/cpp/proto/Services.grpc.pb.h

@@ -130,25 +130,26 @@ namespace protobuf
                 return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartLearningRaw(context, request, cq));
             }
             // 开始修理机器
-            virtual ::grpc::Status StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
-            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            virtual ::grpc::Status StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::protobuf::BoolRes* response) = 0;
+            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartRescueMateRaw(context, request, cq));
             }
-            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartRescueMateRaw(context, request, cq));
             }
             // 开始救人
-            virtual ::grpc::Status StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0;
-            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            virtual ::grpc::Status StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::protobuf::BoolRes* response) = 0;
+            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartTreatMateRaw(context, request, cq));
             }
-            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartTreatMateRaw(context, request, cq));
             }
+            // 开始治疗
             virtual ::grpc::Status Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) = 0;
             std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq)
             {
@@ -256,11 +257,12 @@ namespace protobuf
                 virtual void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                 virtual void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                 // 开始修理机器
-                virtual void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
-                virtual void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+                virtual void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
+                virtual void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                 // 开始救人
-                virtual void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
-                virtual void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+                virtual void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
+                virtual void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+                // 开始治疗
                 virtual void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) = 0;
                 virtual void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0;
                 // 攻击
@@ -315,10 +317,10 @@ namespace protobuf
             virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) = 0;
             virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
             virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
-            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
-            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
-            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
-            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
+            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) = 0;
+            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) = 0;
+            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) = 0;
+            virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) = 0;
             virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) = 0;
             virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) = 0;
             virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncGraduateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0;
@@ -424,21 +426,21 @@ namespace protobuf
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartLearningRaw(context, request, cq));
             }
-            ::grpc::Status StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
-            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            ::grpc::Status StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::protobuf::BoolRes* response) override;
+            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartRescueMateRaw(context, request, cq));
             }
-            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartRescueMateRaw(context, request, cq));
             }
-            ::grpc::Status StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override;
-            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            ::grpc::Status StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::protobuf::BoolRes* response) override;
+            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartTreatMateRaw(context, request, cq));
             }
-            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+            std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq)
             {
                 return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartTreatMateRaw(context, request, cq));
             }
@@ -535,10 +537,10 @@ namespace protobuf
                 void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                 void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                 void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
-                void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
-                void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
-                void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
-                void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
+                void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
+                void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
+                void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
+                void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                 void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
                 void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override;
                 void Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)>) override;
@@ -598,10 +600,10 @@ namespace protobuf
             ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) override;
             ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
             ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartLearningRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
-            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
-            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
-            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
-            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
+            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) override;
+            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) override;
+            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) override;
+            ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::TreatAndRescueMsg& request, ::grpc::CompletionQueue* cq) override;
             ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) override;
             ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) override;
             ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncGraduateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override;
@@ -659,9 +661,10 @@ namespace protobuf
             // rpc GetMessage (IDMsg) returns (stream MsgRes);
             virtual ::grpc::Status StartLearning(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
             // 开始修理机器
-            virtual ::grpc::Status StartRescueMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
+            virtual ::grpc::Status StartRescueMate(::grpc::ServerContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response);
             // 开始救人
-            virtual ::grpc::Status StartTreatMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
+            virtual ::grpc::Status StartTreatMate(::grpc::ServerContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response);
+            // 开始治疗
             virtual ::grpc::Status Attack(::grpc::ServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response);
             // 攻击
             virtual ::grpc::Status Graduate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response);
@@ -948,12 +951,12 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
             }
-            void RequestStartRescueMate(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
+            void RequestStartRescueMate(::grpc::ServerContext* context, ::protobuf::TreatAndRescueMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
             {
                 ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag);
             }
@@ -976,12 +979,12 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
             }
-            void RequestStartTreatMate(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
+            void RequestStartTreatMate(::grpc::ServerContext* context, ::protobuf::TreatAndRescueMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag)
             {
                 ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag);
             }
@@ -1565,15 +1568,15 @@ namespace protobuf
         public:
             WithCallbackMethod_StartRescueMate()
             {
-                ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
-                                                                                                                                          { return this->StartRescueMate(context, request, response); }));
+                ::grpc::Service::MarkMethodCallback(9, new ::grpc::internal::CallbackUnaryHandler<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response)
+                                                                                                                                                      { return this->StartRescueMate(context, request, response); }));
             }
             void SetMessageAllocatorFor_StartRescueMate(
-                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
+                ::grpc::MessageAllocator<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>* allocator
             )
             {
                 ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(9);
-                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
+                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>*>(handler)
                     ->SetMessageAllocator(allocator);
             }
             ~WithCallbackMethod_StartRescueMate() override
@@ -1581,13 +1584,13 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
             }
             virtual ::grpc::ServerUnaryReactor* StartRescueMate(
-                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
+                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/
             )
             {
                 return nullptr;
@@ -1604,15 +1607,15 @@ namespace protobuf
         public:
             WithCallbackMethod_StartTreatMate()
             {
-                ::grpc::Service::MarkMethodCallback(10, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
-                                                                                                                                           { return this->StartTreatMate(context, request, response); }));
+                ::grpc::Service::MarkMethodCallback(10, new ::grpc::internal::CallbackUnaryHandler<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::TreatAndRescueMsg* request, ::protobuf::BoolRes* response)
+                                                                                                                                                       { return this->StartTreatMate(context, request, response); }));
             }
             void SetMessageAllocatorFor_StartTreatMate(
-                ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator
+                ::grpc::MessageAllocator<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>* allocator
             )
             {
                 ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(10);
-                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler)
+                static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>*>(handler)
                     ->SetMessageAllocator(allocator);
             }
             ~WithCallbackMethod_StartTreatMate() override
@@ -1620,13 +1623,13 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
             }
             virtual ::grpc::ServerUnaryReactor* StartTreatMate(
-                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/
+                ::grpc::CallbackServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/
             )
             {
                 return nullptr;
@@ -2180,7 +2183,7 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
@@ -2204,7 +2207,7 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
@@ -2672,7 +2675,7 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
@@ -2700,7 +2703,7 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
@@ -3232,7 +3235,7 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
@@ -3263,7 +3266,7 @@ namespace protobuf
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable synchronous version of this method
-            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
@@ -3750,21 +3753,21 @@ namespace protobuf
         public:
             WithStreamedUnaryMethod_StartRescueMate()
             {
-                ::grpc::Service::MarkMethodStreamed(9, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
-                                                                                                                                          { return this->StreamedStartRescueMate(context, streamer); }));
+                ::grpc::Service::MarkMethodStreamed(9, new ::grpc::internal::StreamedUnaryHandler<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>* streamer)
+                                                                                                                                                      { return this->StreamedStartRescueMate(context, streamer); }));
             }
             ~WithStreamedUnaryMethod_StartRescueMate() override
             {
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable regular version of this method
-            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
             }
             // replace default version of method with streamed unary
-            virtual ::grpc::Status StreamedStartRescueMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
+            virtual ::grpc::Status StreamedStartRescueMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
         };
         template<class BaseClass>
         class WithStreamedUnaryMethod_StartTreatMate : public BaseClass
@@ -3777,21 +3780,21 @@ namespace protobuf
         public:
             WithStreamedUnaryMethod_StartTreatMate()
             {
-                ::grpc::Service::MarkMethodStreamed(10, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer)
-                                                                                                                                           { return this->StreamedStartTreatMate(context, streamer); }));
+                ::grpc::Service::MarkMethodStreamed(10, new ::grpc::internal::StreamedUnaryHandler<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>* streamer)
+                                                                                                                                                       { return this->StreamedStartTreatMate(context, streamer); }));
             }
             ~WithStreamedUnaryMethod_StartTreatMate() override
             {
                 BaseClassMustBeDerivedFromService(this);
             }
             // disable regular version of this method
-            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
+            ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::TreatAndRescueMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override
             {
                 abort();
                 return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
             }
             // replace default version of method with streamed unary
-            virtual ::grpc::Status StreamedStartTreatMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
+            virtual ::grpc::Status StreamedStartTreatMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::TreatAndRescueMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0;
         };
         template<class BaseClass>
         class WithStreamedUnaryMethod_Attack : public BaseClass

CAPI/cpp/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\350\007\n\020Avai"
+    "nts.proto\032\024Message2Server.proto2\200\010\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"
@@ -44,20 +44,20 @@ const char descriptor_table_protodef_Services_2eproto[] PROTOBUF_SECTION_VARIABL
     "rotobuf.BoolRes\0223\n\013SendMessage\022\021.protobu"
     "f.SendMsg\032\021.protobuf.BoolRes\0223\n\rStartLea"
     "rning\022\017.protobuf.IDMsg\032\021.protobuf.BoolRe"
-    "s\0225\n\017StartRescueMate\022\017.protobuf.IDMsg\032\021."
-    "protobuf.BoolRes\0224\n\016StartTreatMate\022\017.pro"
-    "tobuf.IDMsg\032\021.protobuf.BoolRes\0220\n\006Attack"
-    "\022\023.protobuf.AttackMsg\032\021.protobuf.BoolRes"
-    "\022.\n\010Graduate\022\017.protobuf.IDMsg\032\021.protobuf"
-    ".BoolRes\022.\n\010OpenDoor\022\017.protobuf.IDMsg\032\021."
-    "protobuf.BoolRes\022/\n\tCloseDoor\022\017.protobuf"
-    ".IDMsg\032\021.protobuf.BoolRes\0220\n\nSkipWindow\022"
-    "\017.protobuf.IDMsg\032\021.protobuf.BoolRes\0223\n\rS"
-    "tartOpenGate\022\017.protobuf.IDMsg\032\021.protobuf"
-    ".BoolRes\0224\n\016StartOpenChest\022\017.protobuf.ID"
-    "Msg\032\021.protobuf.BoolRes\0222\n\014EndAllAction\022\017"
-    ".protobuf.IDMsg\032\021.protobuf.BoolResb\006prot"
-    "o3";
+    "s\022A\n\017StartRescueMate\022\033.protobuf.TreatAnd"
+    "RescueMsg\032\021.protobuf.BoolRes\022@\n\016StartTre"
+    "atMate\022\033.protobuf.TreatAndRescueMsg\032\021.pr"
+    "otobuf.BoolRes\0220\n\006Attack\022\023.protobuf.Atta"
+    "ckMsg\032\021.protobuf.BoolRes\022.\n\010Graduate\022\017.p"
+    "rotobuf.IDMsg\032\021.protobuf.BoolRes\022.\n\010Open"
+    "Door\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes"
+    "\022/\n\tCloseDoor\022\017.protobuf.IDMsg\032\021.protobu"
+    "f.BoolRes\0220\n\nSkipWindow\022\017.protobuf.IDMsg"
+    "\032\021.protobuf.BoolRes\0223\n\rStartOpenGate\022\017.p"
+    "rotobuf.IDMsg\032\021.protobuf.BoolRes\0224\n\016Star"
+    "tOpenChest\022\017.protobuf.IDMsg\032\021.protobuf.B"
+    "oolRes\0222\n\014EndAllAction\022\017.protobuf.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,
@@ -66,7 +66,7 @@ static ::_pbi::once_flag descriptor_table_Services_2eproto_once;
 const ::_pbi::DescriptorTable descriptor_table_Services_2eproto = {
     false,
     false,
-    1082,
+    1106,
     descriptor_table_protodef_Services_2eproto,
     "Services.proto",
     &descriptor_table_Services_2eproto_once,