Merge branch 'new' of github.com:shangfengh/THUAI6 into new

.gitignore

@@ -1,3 +1,4 @@
 # .vs, .vscode must be ignored
 .vs/
 .vscode/
+CAPI/build

CAPI/API/include/AI.h

@@ -0,0 +1,27 @@
+#pragma once
+#ifndef AI_H
+#define AI_H
+
+#include "API.h"
+
+// 暂定版本：Human和Butcher全部继承AI类，
+class IAI
+{
+public:
+    IAI()
+    {
+    }
+    virtual void play(IAPI& api) = 0;
+};
+
+class AI : public IAI
+{
+public:
+    AI() :
+        IAI()
+    {
+    }
+    void play(IAPI& api) override;
+};
+
+#endif

CAPI/API/include/API.h

@@ -0,0 +1,247 @@
+#pragma once
+#ifndef API_H
+#define API_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4996)
+#endif
+
+#include <Message2Server.pb.h>
+#include <Message2Clients.pb.h>
+#include <MessageType.pb.h>
+#include <Message2Server.grpc.pb.h>
+#include <Message2Clients.grpc.pb.h>
+#include <MessageType.grpc.pb.h>
+#include <future>
+#include <iostream>
+#include <vector>
+
+#include "structures.h"
+
+const constexpr int num_of_grid_per_cell = 1000;
+
+class ILogic
+{
+    // API中依赖Logic的部分
+
+public:
+    // 获取服务器发来的所有消息，要注意线程安全问题
+    virtual protobuf::MessageToClient GetFullMessage() = 0;
+
+    // 供IAPI使用的操作相关的部分
+    virtual bool Move(protobuf::MoveMsg) = 0;
+    virtual bool PickProp(protobuf::PickMsg) = 0;
+    virtual bool UseProp(protobuf::IDMsg) = 0;
+    virtual bool UseSkill(protobuf::IDMsg) = 0;
+    virtual void SendMessage(protobuf::SendMsg) = 0;
+    virtual bool HaveMessage(protobuf::IDMsg) = 0;
+    virtual protobuf::MsgRes GetMessage(protobuf::IDMsg) = 0;
+
+    virtual bool Escape(protobuf::IDMsg) = 0;
+
+    // 说明：双向stream由三个函数共同实现，两个记录开始和结束，结果由Logic里的私有的成员变量记录，获得返回值则另调函数
+    virtual bool StartFixMachine(protobuf::IDMsg) = 0;
+    virtual bool EndFixMachine(protobuf::IDMsg) = 0;
+    virtual bool GetFixStatus() = 0;
+
+    virtual bool StartSaveHuman(protobuf::IDMsg) = 0;
+    virtual bool EndSaveHuman(protobuf::IDMsg) = 0;
+    virtual bool GetSaveStatus() = 0;
+
+    virtual bool Attack(protobuf::AttackMsg) = 0;
+    virtual bool CarryHuman(protobuf::IDMsg) = 0;
+    virtual bool ReleaseHuman(protobuf::IDMsg) = 0;
+    virtual bool HangHuman(protobuf::IDMsg) = 0;
+
+    virtual bool WaitThread() = 0;
+
+    virtual int GetCounter() = 0;
+};
+
+class IAPI
+{
+public:
+    // 选手可执行的操作，应当保证所有函数的返回值都应当为std::future，例如下面的移动函数：
+    // 指挥本角色进行移动，`timeInMilliseconds` 为移动时间，单位为毫秒；`angleInRadian` 表示移动的方向，单位是弧度，使用极坐标——竖直向下方向为 x 轴，水平向右方向为 y 轴
+    virtual std::future<bool> Move(uint32_t timeInMilliseconds, double angleInRadian) = 0;
+
+    // 向特定方向移动
+    virtual std::future<bool> MoveRight(uint32_t timeInMilliseconds) = 0;
+    virtual std::future<bool> MoveUp(uint32_t timeInMilliseconds) = 0;
+    virtual std::future<bool> MoveLeft(uint32_t timeInMilliseconds) = 0;
+    virtual std::future<bool> MoveDown(uint32_t timeInMilliseconds) = 0;
+
+    // 捡道具、使用技能
+    virtual std::future<bool> PickProp() = 0;
+    virtual std::future<bool> UseProp() = 0;
+    virtual std::future<bool> UseSkill() = 0;
+
+    // 发送信息、接受信息
+    virtual std::future<bool> SendMessage(int, std::string) = 0;
+    [[nodiscard]] virtual std::future<bool> HaveMessage() = 0;
+    [[nodiscard]] virtual std::future<std::pair<int, std::string>> GetMessage() = 0;
+
+    // 等待下一帧
+    virtual std::future<bool> Wait() = 0;
+
+    // 获取视野内可见的人类/屠夫的信息
+    [[nodiscard]] virtual std::vector<std::shared_ptr<const THUAI6::Human>> GetHuman() const = 0;
+    [[nodiscard]] virtual std::vector<std::shared_ptr<const THUAI6::Buthcer>> GetButcher() const = 0;
+
+    // 获取视野内可见的道具信息
+    [[nodiscard]] virtual std::vector<std::shared_ptr<const THUAI6::Prop>> GetProps() const = 0;
+
+    // 获取地图信息，视野外的地图统一为Land
+    [[nodiscard]] virtual std::array<std::array<THUAI6::PlaceType, 50>, 50> GetFullMap() const = 0;
+    [[nodiscard]] virtual THUAI6::PlaceType GetPlaceType(int32_t CellX, int32_t CellY) const = 0;
+
+    // 获取所有玩家的GUID
+    [[nodiscard]] virtual const std::vector<int64_t> GetPlayerGUIDs() const = 0;
+
+    // 获取游戏目前所进行的帧数
+    [[nodiscard]] virtual int GetFrameCount() const = 0;
+
+    /*****人类阵营的特定函数*****/
+
+    virtual std::future<bool> StartFixMachine() = 0;
+    virtual std::future<bool> EndFixMachine() = 0;
+    virtual std::future<bool> GetFixStatus() = 0;
+    virtual std::future<bool> StartSaveHuman() = 0;
+    virtual std::future<bool> EndSaveHuman() = 0;
+    virtual std::future<bool> GetSaveStatus() = 0;
+    virtual std::future<bool> Escape() = 0;
+    [[nodiscard]] virtual std::shared_ptr<const THUAI6::Human> HumanGetSelfInfo() const = 0;
+
+    /*****屠夫阵营的特定函数*****/
+
+    virtual std::future<bool> Attack(double angleInRadian) = 0;
+    virtual std::future<bool> CarryHuman() = 0;
+    virtual std::future<bool> ReleaseHuman() = 0;
+    virtual std::future<bool> HangHuman() = 0;
+    [[nodiscard]] virtual std::shared_ptr<const THUAI6::Buthcer> ButcherGetSelfInfo() const = 0;
+
+    /*****选手可能用的辅助函数*****/
+
+    // 获取指定格子中心的坐标
+    [[nodiscard]] static inline int CellToGrid(int cell) noexcept
+    {
+        return cell * num_of_grid_per_cell + num_of_grid_per_cell / 2;
+    }
+
+    // 获取指定坐标点所位于的格子的 X 序号
+    [[nodiscard]] static inline int GridToCell(int grid) noexcept
+    {
+        return grid / num_of_grid_per_cell;
+    }
+
+    IAPI(ILogic& logic) :
+        logic(logic)
+    {
+    }
+
+    virtual ~IAPI()
+    {
+    }
+
+protected:
+    ILogic& logic;
+};
+
+// 给Logic使用的IAPI接口，为了保证面向对象的设计模式
+class IAPIForLogic : public IAPI
+{
+public:
+    IAPIForLogic(ILogic& logic) :
+        IAPI(logic)
+    {
+    }
+    virtual void StartTimer() = 0;
+    virtual void EndTimer() = 0;
+};
+
+class HumanAPI : public IAPIForLogic
+{
+public:
+    HumanAPI(ILogic& logic) :
+        IAPIForLogic(logic)
+    {
+    }
+};
+
+class ButcherAPI : public IAPIForLogic
+{
+public:
+    ButcherAPI(ILogic& logic) :
+        IAPIForLogic(logic)
+    {
+    }
+};
+
+// class IHumanAPI : public IAPIForLogic
+// {
+// public:
+//     IHumanAPI(ILogic& logic) :
+//         IAPIForLogic(logic)
+//     {
+//     }
+//     virtual std::future<bool> StartFixMachine() = 0;
+//     virtual std::future<bool> EndFixMachine() = 0;
+//     virtual std::future<bool> GetFixStatus() = 0;
+//     virtual std::future<bool> StartSaveHuman() = 0;
+//     virtual std::future<bool> EndSaveHuman() = 0;
+//     virtual std::future<bool> GetSaveStatus() = 0;
+//     virtual std::future<bool> Escape() = 0;
+//     [[nodiscard]] virtual std::shared_ptr<const THUAI6::Human> GetSelfInfo() const = 0;
+// };
+
+// class IButcherAPI : public IAPIForLogic
+// {
+// public:
+//     IButcherAPI(Logic& logic) :
+//         IAPIForLogic(logic)
+//     {
+//     }
+//     virtual std::future<bool> Attack(double angleInRadian) = 0;
+//     virtual std::future<bool> CarryHuman() = 0;
+//     virtual std::future<bool> ReleaseHuman() = 0;
+//     virtual std::future<bool> HangHuman() = 0;
+//     [[nodiscard]] virtual std::shared_ptr<const THUAI6::Buthcer> GetSelfInfo() const = 0;
+// };
+
+// class HumanAPI : public IHumanAPI
+// {
+// public:
+//     HumanAPI(Logic& logic) :
+//         IHumanAPI(logic)
+//     {
+//     }
+// };
+
+// class DebugHumanAPI : public IHumanAPI
+// {
+// public:
+//     DebugHumanAPI(Logic& logic) :
+//         IHumanAPI(logic)
+//     {
+//     }
+// };
+
+// class ButhcerAPI : public IButcherAPI
+// {
+// public:
+//     ButhcerAPI(Logic& logic) :
+//         IButcherAPI(logic)
+//     {
+//     }
+// };
+
+// class DebugButcherAPI : public IButcherAPI
+// {
+// public:
+//     DebugButcherAPI(Logic& logic) :
+//         IButcherAPI(logic)
+//     {
+//     }
+// };
+
+#endif

CAPI/API/include/constants.h

@@ -0,0 +1,8 @@
+#pragma once
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+
+namespace Constants
+{
+}
+#endif

CAPI/API/include/logic.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#ifndef LOGIC_H
+#define LOGIC_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4996)
+#endif
+
+#include <iostream>
+#include <vector>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <atomic>
+
+#include <Message2Server.pb.h>
+#include <Message2Clients.pb.h>
+#include <MessageType.pb.h>
+#include <Message2Server.grpc.pb.h>
+#include <Message2Clients.grpc.pb.h>
+#include <MessageType.grpc.pb.h>
+#include "API.h"
+#include "AI.h"
+
+// 封装了通信组件和对AI对象进行操作
+class Logic : public ILogic
+{
+private:
+    // gRPC客户端的stub，所有与服务端之间的通信操作都需要基于stub完成。
+    std::unique_ptr<Protobuf::AvailableService::Stub> THUAI6Stub;
+    // ID、阵营记录
+    int playerID;
+    THUAI6::PlayerType playerType;
+
+    // 类型记录
+    THUAI6::HumanType humanType;
+    THUAI6::ButcherType butcherType;
+
+    // GUID信息
+    std::vector<int64_t> playerGUIDs;
+
+    // THUAI5中的通信组件可以完全被我们的stub取代，故无须再写
+
+    std::unique_ptr<IAI> pAI;
+
+    std::shared_ptr<IAPIForLogic> pAPI;
+
+    std::thread tAI;
+
+    mutable std::mutex mtxAI;
+    mutable std::mutex mtxState;
+    mutable std::mutex mtxBuffer;
+
+    std::condition_variable cvBuffer;
+    std::condition_variable cvAI;
+
+    // 信息队列目前可能会不用？具体待定
+
+    // 存储状态，分别是现在的状态和缓冲区的状态。
+    State state[2];
+    State* currentState;
+    State* bufferState;
+
+    // 是否应该执行player()
+    std::atomic_bool AILoop = true;
+
+    // buffer是否更新完毕
+    bool bufferUpdated = true;
+
+    // 是否可以启用当前状态
+    bool currentStateAccessed = false;
+
+    // 是否应当启动AI
+    bool AIStart = false;
+
+    // 控制内容更新的变量
+    std::atomic_bool freshed = false;
+
+    // 所有API中声明的函数都需要在此处重写，先暂时略过，等到之后具体实现时再考虑
+
+    // 执行AI线程
+    void PlayerWrapper(std::function<void()> player);
+
+    // THUAI5中的一系列用于处理信息的函数可能也不会再用
+
+    // 将信息加载到buffer
+    void LoadBuffer(std::shared_ptr<Protobuf::MessageToClient>);
+
+    // 解锁状态更新线程
+    void UnBlockBuffer();
+
+    // 解锁AI线程
+    void UnBlockAI();
+
+    // 更新状态
+    void Update() noexcept;
+
+    // 等待
+    void Wait() noexcept;
+
+public:
+    // 构造函数还需要传更多参数，有待补充
+    Logic(std::shared_ptr<grpc::Channel> channel);
+
+    ~Logic() = default;
+
+    // Main函数同上
+    void Main();
+};
+
+#endif

CAPI/API/include/state.h

@@ -0,0 +1,27 @@
+#pragma once
+#ifndef STATE_H
+#define STATE_H
+
+#include <vector>
+
+#include "structures.h"
+
+// 存储场上的状态
+struct State
+{
+    uint32_t teamScore;
+
+    // 自身信息，根据playerType的不同，可以调用的值也不同。
+    std::shared_ptr<THUAI6::Human> humanSelf;
+    std::shared_ptr<THUAI6::Butcher> butcherSelf;
+
+    std::vector<std::shared_ptr<THUAI6::Human>> humans;
+    std::vector<std::shared_ptr<THUAI6::Butcher>> butchers;
+    std::vector<std::shared_ptr<THUAI6::Prop>> props;
+
+    THUAI6::PlaceType gamemap[51][51];
+
+    std::vector<int64_t> guids;
+};
+
+#endif

CAPI/API/include/structures.h

@@ -0,0 +1,151 @@
+#pragma once
+#ifndef STRUCTURES_H
+#define STRUCTURES_H
+
+#include <cstdint>
+#include <array>
+#include <map>
+
+namespace THUAI6
+{
+    // 所有NullXXXType均为错误类型，其余为可能出现的正常类型
+
+    // 位置标志
+    enum class PlaceType : unsigned char
+    {
+        NullPlaceType = 0,
+        Land = 1,
+        Wall = 2,
+        Grass = 3,
+        Machine = 4,
+        Gate = 5,
+        HiddenGate = 6,
+    };
+
+    // 形状标志
+    enum class ShapeType : unsigned char
+    {
+        NullShapeType = 0,
+        Circle = 1,
+        Square = 2,
+    };
+
+    // 道具类型
+    enum class PropType : unsigned char
+    {
+        NullPropType = 0,
+        PropType1 = 1,
+        PropType2 = 2,
+        PropType3 = 3,
+        PropType4 = 4,
+    };
+
+    // 玩家类型
+    enum class PlayerType : unsigned char
+    {
+        NullPlayerType = 0,
+        HumanPlayer = 1,
+        ButcherType = 2,
+    };
+
+    // 人类类型
+    enum class HumanType : unsigned char
+    {
+        NullHumanType = 0,
+        HumanType1 = 1,
+        HumanType2 = 2,
+        HumanType3 = 3,
+        HumanType4 = 4,
+    };
+
+    // 屠夫类型
+    enum class ButcherType : unsigned char
+    {
+        NullButcherType = 0,
+        ButcherType1 = 1,
+        ButcherType2 = 2,
+        ButcherType3 = 3,
+        ButcherType4 = 4,
+    };
+
+    // 人类Buff类型
+    enum class HumanBuffType : unsigned char
+    {
+        NullHumanBuffType = 0,
+        HumanBuffType1 = 1,
+        HumanBuffType2 = 2,
+        HumanBuffType3 = 3,
+        HumanBuffType4 = 4,
+    };
+
+    // 玩家类
+    struct Player
+    {
+        int32_t x;           // x坐标
+        int32_t y;           // y坐标
+        uint32_t speed;      // 移动速度
+        uint32_t viewRange;  // 视野范围
+        uint64_t playerID;   // 玩家ID
+        uint64_t guid;       // 全局唯一ID
+        uint16_t radius;     // 圆形物体的半径或正方形物体的内切圆半径
+
+        double timeUntilSkillAvailable;  // 技能冷却时间
+
+        PlayerType playerType;  // 玩家类型
+        PropType prop;          // 手上的道具类型
+        PlaceType place;        // 所处格子的类型
+    };
+
+    struct Human : public Player
+    {
+        bool onChair;         // 是否被挂
+        bool onGround;        // 是否倒地
+        uint32_t life;        // 剩余生命（本次倒地之前还能承受的伤害）
+        uint32_t hangedTime;  // 被挂的次数
+
+        HumanType humanType;              // 人类类型
+        std::vector<HumanBuffType> buff;  // buff
+    };
+
+    struct Butcher : public Player
+    {
+        uint32_t damage;  // 攻击伤害
+        bool movable;     // 是否处在攻击后摇中
+
+        ButcherType butcherType;            // 屠夫类型
+        std::vector<ButcherBuffType> buff;  // buff
+    };
+
+    struct Prop
+    {
+        int32_t x;
+        int32_t y;
+        uint32_t size;
+        uint64_t guid;
+        PropType type;
+        PlaceType place;
+        double facingDirection;  // 朝向
+        bool isMoving;
+    };
+
+    // 仅供DEBUG使用，名称可改动
+    // 还没写完，后面待续
+
+    inline std::map<PlaceType, std::string> placeDict{
+        {PlaceType::NullPlaceType, "NullPlaceType"},
+        {PlaceType::Land, "Land"},
+        {PlaceType::Wall, "Wall"},
+        {PlaceType::Grass, "Grass"},
+        {PlaceType::Machine, "Machine"},
+        {PlaceType::Gate, "Gate"},
+        {PlaceType::HiddenGate, "HiddenGate"},
+    };
+
+    inline std::map<PropType, std::string> propDict{
+        {PropType::NullPropType, "NullPropType"},
+
+    };
+
+}  // namespace THUAI6
+
+#endif

CAPI/API/src/AI.cpp

@@ -0,0 +1,15 @@
+#include <vector>
+#include <thread>
+#include "AI.h"
+
+// 选手必须定义该变量来选择自己的阵营
+const THUAI6::PlayerType playerType = THUAI6::PlayerType::HumanPlayer;
+
+// 选手只需要定义两者中自己选中的那个即可，定义两个也不会有影响。
+const THUAI6::ButcherType butcherType = THUAI6::ButcherType::ButcherType1;
+
+const THUAI6::HumanType humanType = THUAI6::HumanType::HumanType1;
+
+void AI::play(IAPI& api)
+{
+}

CAPI/API/src/logic.cpp

@@ -0,0 +1,7 @@
+#pragma once
+#include "logic.h"
+
+Logic::Logic(std::shared_ptr<grpc::Channel> channel) :
+    THUAI6Stub(Protobuf::AvailableService::NewStub(channel))
+{
+}

CAPI/CMakeLists.txt

@@ -0,0 +1,28 @@
+# 临时CMakeLists，仅供本地调试用
+cmake_minimum_required(VERSION 3.5)
+
+project(THUAI6_CAPI VERSION 1.0)
+
+set(CMAKE_CXX_STANDARD 17)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -pthread")
+
+aux_source_directory(./API/src CPP_LIST)
+aux_source_directory(./proto PROTO_CPP_LIST)
+
+find_package(Protobuf CONFIG REQUIRED)
+find_package(gRPC CONFIG REQUIRED)
+
+message(STATUS "Using protobuf ${Protobuf_VERSION}")
+message(STATUS "Using gRPC ${gRPC_VERSION}")
+
+add_executable(capi ${CPP_LIST} ${PROTO_CPP_LIST})
+
+target_include_directories(capi PUBLIC ${PROJECT_SOURCE_DIR}/proto ${PROJECT_SOURCE_DIR}/API/include)
+
+target_link_libraries(capi
+protobuf::libprotobuf
+gRPC::grpc
+gRPC::grpc++_reflection
+gRPC::grpc++
+)

CAPI/proto/Message2Clients.grpc.pb.cc

@@ -29,6 +29,8 @@ namespace protobuf
         "/protobuf.AvailableService/UseProp",
         "/protobuf.AvailableService/UseSkill",
         "/protobuf.AvailableService/SendMessage",
+        "/protobuf.AvailableService/HaveMessage",
+        "/protobuf.AvailableService/GetMessage",
         "/protobuf.AvailableService/FixMachine",
         "/protobuf.AvailableService/SaveHuman",
         "/protobuf.AvailableService/Attack",
@@ -53,13 +55,15 @@ namespace protobuf
         rpcmethod_UseProp_(AvailableService_method_names[3], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
         rpcmethod_UseSkill_(AvailableService_method_names[4], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
         rpcmethod_SendMessage_(AvailableService_method_names[5], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_FixMachine_(AvailableService_method_names[6], options.suffix_for_stats(), ::grpc::internal::RpcMethod::BIDI_STREAMING, channel),
-        rpcmethod_SaveHuman_(AvailableService_method_names[7], options.suffix_for_stats(), ::grpc::internal::RpcMethod::BIDI_STREAMING, channel),
-        rpcmethod_Attack_(AvailableService_method_names[8], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_CarryHuman_(AvailableService_method_names[9], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_ReleaseHuman_(AvailableService_method_names[10], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_HangHuman_(AvailableService_method_names[11], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
-        rpcmethod_Escape_(AvailableService_method_names[12], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+        rpcmethod_HaveMessage_(AvailableService_method_names[6], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_GetMessage_(AvailableService_method_names[7], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_FixMachine_(AvailableService_method_names[8], options.suffix_for_stats(), ::grpc::internal::RpcMethod::BIDI_STREAMING, channel),
+        rpcmethod_SaveHuman_(AvailableService_method_names[9], options.suffix_for_stats(), ::grpc::internal::RpcMethod::BIDI_STREAMING, channel),
+        rpcmethod_Attack_(AvailableService_method_names[10], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_CarryHuman_(AvailableService_method_names[11], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_ReleaseHuman_(AvailableService_method_names[12], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_HangHuman_(AvailableService_method_names[13], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel),
+        rpcmethod_Escape_(AvailableService_method_names[14], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
     {
     }
 
@@ -223,6 +227,62 @@ namespace protobuf
         return result;
     }
 
+    ::grpc::Status AvailableService::Stub::HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response)
+    {
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_HaveMessage_, context, request, response);
+    }
+
+    void AvailableService::Stub::async::HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function<void(::grpc::Status)> f)
+    {
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HaveMessage_, context, request, response, std::move(f));
+    }
+
+    void AvailableService::Stub::async::HaveMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor)
+    {
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_HaveMessage_, context, request, response, reactor);
+    }
+
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncHaveMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    {
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_HaveMessage_, context, request);
+    }
+
+    ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncHaveMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    {
+        auto* result =
+            this->PrepareAsyncHaveMessageRaw(context, request, cq);
+        result->StartCall();
+        return result;
+    }
+
+    ::grpc::Status AvailableService::Stub::GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::MsgRes* response)
+    {
+        return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::MsgRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetMessage_, context, request, response);
+    }
+
+    void AvailableService::Stub::async::GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response, std::function<void(::grpc::Status)> f)
+    {
+        ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::MsgRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetMessage_, context, request, response, std::move(f));
+    }
+
+    void AvailableService::Stub::async::GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response, ::grpc::ClientUnaryReactor* reactor)
+    {
+        ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetMessage_, context, request, response, reactor);
+    }
+
+    ::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>* AvailableService::Stub::PrepareAsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    {
+        return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::MsgRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetMessage_, context, request);
+    }
+
+    ::grpc::ClientAsyncResponseReader<::protobuf::MsgRes>* AvailableService::Stub::AsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq)
+    {
+        auto* result =
+            this->PrepareAsyncGetMessageRaw(context, request, cq);
+        result->StartCall();
+        return result;
+    }
+
     ::grpc::ClientReaderWriter<::protobuf::IDMsg, ::protobuf::BoolRes>* AvailableService::Stub::FixMachineRaw(::grpc::ClientContext* context)
     {
         return ::grpc::internal::ClientReaderWriterFactory<::protobuf::IDMsg, ::protobuf::BoolRes>::Create(channel_.get(), rpcmethod_FixMachine_, context);
@@ -491,6 +551,34 @@ namespace protobuf
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
             AvailableService_method_names[6],
+            ::grpc::internal::RpcMethod::NORMAL_RPC,
+            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+                [](AvailableService::Service* service,
+                   ::grpc::ServerContext* ctx,
+                   const ::protobuf::IDMsg* req,
+                   ::protobuf::BoolRes* resp)
+                {
+                    return service->HaveMessage(ctx, req, resp);
+                },
+                this
+            )
+        ));
+        AddMethod(new ::grpc::internal::RpcServiceMethod(
+            AvailableService_method_names[7],
+            ::grpc::internal::RpcMethod::NORMAL_RPC,
+            new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::MsgRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+                [](AvailableService::Service* service,
+                   ::grpc::ServerContext* ctx,
+                   const ::protobuf::IDMsg* req,
+                   ::protobuf::MsgRes* resp)
+                {
+                    return service->GetMessage(ctx, req, resp);
+                },
+                this
+            )
+        ));
+        AddMethod(new ::grpc::internal::RpcServiceMethod(
+            AvailableService_method_names[8],
             ::grpc::internal::RpcMethod::BIDI_STREAMING,
             new ::grpc::internal::BidiStreamingHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes>(
                 [](AvailableService::Service* service,
@@ -503,7 +591,7 @@ namespace protobuf
             )
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
-            AvailableService_method_names[7],
+            AvailableService_method_names[9],
             ::grpc::internal::RpcMethod::BIDI_STREAMING,
             new ::grpc::internal::BidiStreamingHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes>(
                 [](AvailableService::Service* service,
@@ -516,7 +604,7 @@ namespace protobuf
             )
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
-            AvailableService_method_names[8],
+            AvailableService_method_names[10],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
             new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
@@ -530,7 +618,7 @@ namespace protobuf
             )
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
-            AvailableService_method_names[9],
+            AvailableService_method_names[11],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
             new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
@@ -544,7 +632,7 @@ namespace protobuf
             )
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
-            AvailableService_method_names[10],
+            AvailableService_method_names[12],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
             new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
@@ -558,7 +646,7 @@ namespace protobuf
             )
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
-            AvailableService_method_names[11],
+            AvailableService_method_names[13],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
             new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
@@ -572,7 +660,7 @@ namespace protobuf
             )
         ));
         AddMethod(new ::grpc::internal::RpcServiceMethod(
-            AvailableService_method_names[12],
+            AvailableService_method_names[14],
             ::grpc::internal::RpcMethod::NORMAL_RPC,
             new ::grpc::internal::RpcMethodHandler<AvailableService::Service, ::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
                 [](AvailableService::Service* service,
@@ -639,6 +727,22 @@ namespace protobuf
         return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
     }
 
+    ::grpc::Status AvailableService::Service::HaveMessage(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response)
+    {
+        (void)context;
+        (void)request;
+        (void)response;
+        return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+
+    ::grpc::Status AvailableService::Service::GetMessage(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::MsgRes* response)
+    {
+        (void)context;
+        (void)request;
+        (void)response;
+        return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+
     ::grpc::Status AvailableService::Service::FixMachine(::grpc::ServerContext* context, ::grpc::ServerReaderWriter<::protobuf::BoolRes, ::protobuf::IDMsg>* stream)
     {
         (void)context;

CAPI/proto/Message2Clients.pb.cc

@@ -114,7 +114,9 @@ namespace protobuf
         place_(0)
 
         ,
-        guid_(int64_t{0})
+        guid_(int64_t{0}),
+        size_(0),
+        is_moving_(false)
     {
     }
     struct MessageOfPropDefaultTypeInternal
@@ -269,8 +271,31 @@ namespace protobuf
         };
     };
     PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BoolResDefaultTypeInternal _BoolRes_default_instance_;
+    constexpr MsgRes::MsgRes(
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized
+    ) :
+        message_received_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string),
+        from_player_id_(int64_t{0}),
+        have_message_(false)
+    {
+    }
+    struct MsgResDefaultTypeInternal
+    {
+        constexpr MsgResDefaultTypeInternal() :
+            _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{})
+        {
+        }
+        ~MsgResDefaultTypeInternal()
+        {
+        }
+        union
+        {
+            MsgRes _instance;
+        };
+    };
+    PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgResDefaultTypeInternal _MsgRes_default_instance_;
 }  // namespace protobuf
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_Message2Clients_2eproto[9];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_Message2Clients_2eproto[10];
 static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_Message2Clients_2eproto = nullptr;
 static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_Message2Clients_2eproto = nullptr;
 
@@ -329,6 +354,8 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V
     PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfProp, facing_direction_),
     PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfProp, guid_),
     PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfProp, place_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfProp, size_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfProp, is_moving_),
     ~0u,  // no _has_bits_
     PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfPickedProp, _internal_metadata_),
     ~0u,  // no _extensions_
@@ -379,17 +406,27 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V
     ~0u,  // no _weak_field_map_
     ~0u,  // no _inlined_string_donated_
     PROTOBUF_FIELD_OFFSET(::protobuf::BoolRes, act_success_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::protobuf::MsgRes, _internal_metadata_),
+    ~0u,  // no _extensions_
+    ~0u,  // no _oneof_case_
+    ~0u,  // no _weak_field_map_
+    ~0u,  // no _inlined_string_donated_
+    PROTOBUF_FIELD_OFFSET(::protobuf::MsgRes, have_message_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::MsgRes, from_player_id_),
+    PROTOBUF_FIELD_OFFSET(::protobuf::MsgRes, message_received_),
 };
 static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
     {0, -1, -1, sizeof(::protobuf::MessageOfHuman)},
     {23, -1, -1, sizeof(::protobuf::MessageOfButcher)},
     {42, -1, -1, sizeof(::protobuf::MessageOfProp)},
-    {54, -1, -1, sizeof(::protobuf::MessageOfPickedProp)},
-    {65, -1, -1, sizeof(::protobuf::MessageOfMap_Row)},
-    {72, -1, -1, sizeof(::protobuf::MessageOfMap)},
-    {79, -1, -1, sizeof(::protobuf::MessageToClient)},
-    {89, -1, -1, sizeof(::protobuf::MoveRes)},
-    {97, -1, -1, sizeof(::protobuf::BoolRes)},
+    {56, -1, -1, sizeof(::protobuf::MessageOfPickedProp)},
+    {67, -1, -1, sizeof(::protobuf::MessageOfMap_Row)},
+    {74, -1, -1, sizeof(::protobuf::MessageOfMap)},
+    {81, -1, -1, sizeof(::protobuf::MessageToClient)},
+    {91, -1, -1, sizeof(::protobuf::MoveRes)},
+    {99, -1, -1, sizeof(::protobuf::BoolRes)},
+    {106, -1, -1, sizeof(::protobuf::MsgRes)},
 };
 
 static ::PROTOBUF_NAMESPACE_ID::Message const* const file_default_instances[] = {
@@ -402,6 +439,7 @@ static ::PROTOBUF_NAMESPACE_ID::Message const* const file_default_instances[] =
     reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::protobuf::_MessageToClient_default_instance_),
     reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::protobuf::_MoveRes_default_instance_),
     reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::protobuf::_BoolRes_default_instance_),
+    reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::protobuf::_MsgRes_default_instance_),
 };
 
 const char descriptor_table_protodef_Message2Clients_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
@@ -425,41 +463,46 @@ const char descriptor_table_protodef_Message2Clients_2eproto[] PROTOBUF_SECTION_
     " \001(\0162\025.protobuf.ButcherType\022\014\n\004guid\030\t \001("
     "\003\022\017\n\007movable\030\n \001(\010\022\020\n\010playerID\030\013 \001(\003\022\022\n\n"
     "view_range\030\014 \001(\005\022\'\n\004buff\030\r \003(\0162\031.protobu"
-    "f.ButcherBuffType\"\223\001\n\rMessageOfProp\022 \n\004t"
+    "f.ButcherBuffType\"\264\001\n\rMessageOfProp\022 \n\004t"
     "ype\030\001 \001(\0162\022.protobuf.PropType\022\t\n\001x\030\002 \001(\005"
     "\022\t\n\001y\030\003 \001(\005\022\030\n\020facing_direction\030\004 \001(\001\022\014\n"
     "\004guid\030\005 \001(\003\022\"\n\005place\030\006 \001(\0162\023.protobuf.Pl"
-    "aceType\"{\n\023MessageOfPickedProp\022 \n\004type\030\001"
-    " \001(\0162\022.protobuf.PropType\022\t\n\001x\030\002 \001(\005\022\t\n\001y"
-    "\030\003 \001(\005\022\030\n\020facing_direction\030\004 \001(\001\022\022\n\nmapp"
-    "ing_id\030\005 \001(\003\"`\n\014MessageOfMap\022\'\n\003row\030\002 \003("
-    "\0132\032.protobuf.MessageOfMap.Row\032\'\n\003Row\022 \n\003"
-    "col\030\001 \003(\0162\023.protobuf.PlaceType\"\323\001\n\017Messa"
-    "geToClient\022/\n\rhuman_message\030\001 \003(\0132\030.prot"
-    "obuf.MessageOfHuman\0223\n\017butcher_message\030\002"
-    " \003(\0132\032.protobuf.MessageOfButcher\022-\n\014prop"
-    "_message\030\003 \003(\0132\027.protobuf.MessageOfProp\022"
-    "+\n\013map_massage\030\004 \001(\0132\026.protobuf.MessageO"
-    "fMap\"5\n\007MoveRes\022\024\n\014actual_speed\030\001 \001(\003\022\024\n"
-    "\014actual_angle\030\002 \001(\001\"\036\n\007BoolRes\022\023\n\013act_su"
-    "ccess\030\001 \001(\0102\247\005\n\020AvailableService\022=\n\tAddP"
-    "layer\022\023.protobuf.PlayerMsg\032\031.protobuf.Me"
-    "ssageToClient0\001\022,\n\004Move\022\021.protobuf.MoveM"
-    "sg\032\021.protobuf.MoveRes\0220\n\010PickProp\022\021.prot"
-    "obuf.PickMsg\032\021.protobuf.BoolRes\022-\n\007UsePr"
-    "op\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\022."
-    "\n\010UseSkill\022\017.protobuf.IDMsg\032\021.protobuf.B"
-    "oolRes\0223\n\013SendMessage\022\021.protobuf.SendMsg"
-    "\032\021.protobuf.BoolRes\0224\n\nFixMachine\022\017.prot"
-    "obuf.IDMsg\032\021.protobuf.BoolRes(\0010\001\0223\n\tSav"
-    "eHuman\022\017.protobuf.IDMsg\032\021.protobuf.BoolR"
-    "es(\0010\001\0220\n\006Attack\022\023.protobuf.AttackMsg\032\021."
-    "protobuf.BoolRes\0220\n\nCarryHuman\022\017.protobu"
-    "f.IDMsg\032\021.protobuf.BoolRes\0222\n\014ReleaseHum"
-    "an\022\017.protobuf.IDMsg\032\021.protobuf.BoolRes\022/"
-    "\n\tHangHuman\022\017.protobuf.IDMsg\032\021.protobuf."
-    "BoolRes\022,\n\006Escape\022\017.protobuf.IDMsg\032\021.pro"
-    "tobuf.BoolResb\006proto3";
+    "aceType\022\014\n\004size\030\007 \001(\005\022\021\n\tis_moving\030\010 \001(\010"
+    "\"{\n\023MessageOfPickedProp\022 \n\004type\030\001 \001(\0162\022."
+    "protobuf.PropType\022\t\n\001x\030\002 \001(\005\022\t\n\001y\030\003 \001(\005\022"
+    "\030\n\020facing_direction\030\004 \001(\001\022\022\n\nmapping_id\030"
+    "\005 \001(\003\"`\n\014MessageOfMap\022\'\n\003row\030\002 \003(\0132\032.pro"
+    "tobuf.MessageOfMap.Row\032\'\n\003Row\022 \n\003col\030\001 \003"
+    "(\0162\023.protobuf.PlaceType\"\323\001\n\017MessageToCli"
+    "ent\022/\n\rhuman_message\030\001 \003(\0132\030.protobuf.Me"
+    "ssageOfHuman\0223\n\017butcher_message\030\002 \003(\0132\032."
+    "protobuf.MessageOfButcher\022-\n\014prop_messag"
+    "e\030\003 \003(\0132\027.protobuf.MessageOfProp\022+\n\013map_"
+    "massage\030\004 \001(\0132\026.protobuf.MessageOfMap\"5\n"
+    "\007MoveRes\022\024\n\014actual_speed\030\001 \001(\003\022\024\n\014actual"
+    "_angle\030\002 \001(\001\"\036\n\007BoolRes\022\023\n\013act_success\030\001"
+    " \001(\010\"P\n\006MsgRes\022\024\n\014have_message\030\001 \001(\010\022\026\n\016"
+    "from_player_id\030\002 \001(\003\022\030\n\020message_received"
+    "\030\003 \001(\t2\213\006\n\020AvailableService\022=\n\tAddPlayer"
+    "\022\023.protobuf.PlayerMsg\032\031.protobuf.Message"
+    "ToClient0\001\022,\n\004Move\022\021.protobuf.MoveMsg\032\021."
+    "protobuf.MoveRes\0220\n\010PickProp\022\021.protobuf."
+    "PickMsg\032\021.protobuf.BoolRes\022-\n\007UseProp\022\017."
+    "protobuf.IDMsg\032\021.protobuf.BoolRes\022.\n\010Use"
+    "Skill\022\017.protobuf.IDMsg\032\021.protobuf.BoolRe"
+    "s\0223\n\013SendMessage\022\021.protobuf.SendMsg\032\021.pr"
+    "otobuf.BoolRes\0221\n\013HaveMessage\022\017.protobuf"
+    ".IDMsg\032\021.protobuf.BoolRes\022/\n\nGetMessage\022"
+    "\017.protobuf.IDMsg\032\020.protobuf.MsgRes\0224\n\nFi"
+    "xMachine\022\017.protobuf.IDMsg\032\021.protobuf.Boo"
+    "lRes(\0010\001\0223\n\tSaveHuman\022\017.protobuf.IDMsg\032\021"
+    ".protobuf.BoolRes(\0010\001\0220\n\006Attack\022\023.protob"
+    "uf.AttackMsg\032\021.protobuf.BoolRes\0220\n\nCarry"
+    "Human\022\017.protobuf.IDMsg\032\021.protobuf.BoolRe"
+    "s\0222\n\014ReleaseHuman\022\017.protobuf.IDMsg\032\021.pro"
+    "tobuf.BoolRes\022/\n\tHangHuman\022\017.protobuf.ID"
+    "Msg\032\021.protobuf.BoolRes\022,\n\006Escape\022\017.proto"
+    "buf.IDMsg\032\021.protobuf.BoolResb\006proto3";
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* const descriptor_table_Message2Clients_2eproto_deps[2] = {
     &::descriptor_table_Message2Server_2eproto,
     &::descriptor_table_MessageType_2eproto,
@@ -468,13 +511,13 @@ static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_Message2Cli
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Message2Clients_2eproto = {
     false,
     false,
-    2181,
+    2396,
     descriptor_table_protodef_Message2Clients_2eproto,
     "Message2Clients.proto",
     &descriptor_table_Message2Clients_2eproto_once,
     descriptor_table_Message2Clients_2eproto_deps,
     2,
-    9,
+    10,
     schemas,
     file_default_instances,
     TableStruct_Message2Clients_2eproto::offsets,
@@ -1836,13 +1879,13 @@ namespace protobuf
         ::PROTOBUF_NAMESPACE_ID::Message()
     {
         _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
-        ::memcpy(&type_, &from.type_, static_cast<size_t>(reinterpret_cast<char*>(&guid_) - reinterpret_cast<char*>(&type_)) + sizeof(guid_));
+        ::memcpy(&type_, &from.type_, static_cast<size_t>(reinterpret_cast<char*>(&is_moving_) - reinterpret_cast<char*>(&type_)) + sizeof(is_moving_));
         // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfProp)
     }
 
     inline void MessageOfProp::SharedCtor()
     {
-        ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)), 0, static_cast<size_t>(reinterpret_cast<char*>(&guid_) - reinterpret_cast<char*>(&type_)) + sizeof(guid_));
+        ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)), 0, static_cast<size_t>(reinterpret_cast<char*>(&is_moving_) - reinterpret_cast<char*>(&type_)) + sizeof(is_moving_));
     }
 
     MessageOfProp::~MessageOfProp()
@@ -1879,7 +1922,7 @@ namespace protobuf
         // Prevent compiler warnings about cached_has_bits being unused
         (void)cached_has_bits;
 
-        ::memset(&type_, 0, static_cast<size_t>(reinterpret_cast<char*>(&guid_) - reinterpret_cast<char*>(&type_)) + sizeof(guid_));
+        ::memset(&type_, 0, static_cast<size_t>(reinterpret_cast<char*>(&is_moving_) - reinterpret_cast<char*>(&type_)) + sizeof(is_moving_));
         _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
     }
 
@@ -1956,6 +1999,26 @@ namespace protobuf
                     else
                         goto handle_unusual;
                     continue;
+                // int32 size = 7;
+                case 7:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56))
+                    {
+                        size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+                        CHK_(ptr);
+                    }
+                    else
+                        goto handle_unusual;
+                    continue;
+                // bool is_moving = 8;
+                case 8:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64))
+                    {
+                        is_moving_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+                        CHK_(ptr);
+                    }
+                    else
+                        goto handle_unusual;
+                    continue;
                 default:
                     goto handle_unusual;
             }  // switch
@@ -2040,6 +2103,20 @@ namespace protobuf
             );
         }
 
+        // int32 size = 7;
+        if (this->_internal_size() != 0)
+        {
+            target = stream->EnsureSpace(target);
+            target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_size(), target);
+        }
+
+        // bool is_moving = 8;
+        if (this->_internal_is_moving() != 0)
+        {
+            target = stream->EnsureSpace(target);
+            target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_is_moving(), target);
+        }
+
         if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields()))
         {
             target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
@@ -2101,6 +2178,18 @@ namespace protobuf
             total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_guid());
         }
 
+        // int32 size = 7;
+        if (this->_internal_size() != 0)
+        {
+            total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_size());
+        }
+
+        // bool is_moving = 8;
+        if (this->_internal_is_moving() != 0)
+        {
+            total_size += 1 + 1;
+        }
+
         return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
     }
 
@@ -2154,6 +2243,14 @@ namespace protobuf
         {
             _internal_set_guid(from._internal_guid());
         }
+        if (from._internal_size() != 0)
+        {
+            _internal_set_size(from._internal_size());
+        }
+        if (from._internal_is_moving() != 0)
+        {
+            _internal_set_is_moving(from._internal_is_moving());
+        }
         _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
     }
 
@@ -2176,7 +2273,7 @@ namespace protobuf
         using std::swap;
         _internal_metadata_.InternalSwap(&other->_internal_metadata_);
         ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-            PROTOBUF_FIELD_OFFSET(MessageOfProp, guid_) + sizeof(MessageOfProp::guid_) - PROTOBUF_FIELD_OFFSET(MessageOfProp, type_)>(
+            PROTOBUF_FIELD_OFFSET(MessageOfProp, is_moving_) + sizeof(MessageOfProp::is_moving_) - PROTOBUF_FIELD_OFFSET(MessageOfProp, type_)>(
             reinterpret_cast<char*>(&type_),
             reinterpret_cast<char*>(&other->type_)
         );
@@ -3831,6 +3928,311 @@ namespace protobuf
         );
     }
 
+    // ===================================================================
+
+    class MsgRes::_Internal
+    {
+    public:
+    };
+
+    MsgRes::MsgRes(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) :
+        ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned)
+    {
+        SharedCtor();
+        if (!is_message_owned)
+        {
+            RegisterArenaDtor(arena);
+        }
+        // @@protoc_insertion_point(arena_constructor:protobuf.MsgRes)
+    }
+    MsgRes::MsgRes(const MsgRes& from) :
+        ::PROTOBUF_NAMESPACE_ID::Message()
+    {
+        _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+        message_received_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        message_received_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (!from._internal_message_received().empty())
+        {
+            message_received_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message_received(), GetArenaForAllocation());
+        }
+        ::memcpy(&from_player_id_, &from.from_player_id_, static_cast<size_t>(reinterpret_cast<char*>(&have_message_) - reinterpret_cast<char*>(&from_player_id_)) + sizeof(have_message_));
+        // @@protoc_insertion_point(copy_constructor:protobuf.MsgRes)
+    }
+
+    inline void MsgRes::SharedCtor()
+    {
+        message_received_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        message_received_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(reinterpret_cast<char*>(&from_player_id_) - reinterpret_cast<char*>(this)), 0, static_cast<size_t>(reinterpret_cast<char*>(&have_message_) - reinterpret_cast<char*>(&from_player_id_)) + sizeof(have_message_));
+    }
+
+    MsgRes::~MsgRes()
+    {
+        // @@protoc_insertion_point(destructor:protobuf.MsgRes)
+        if (GetArenaForAllocation() != nullptr)
+            return;
+        SharedDtor();
+        _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    inline void MsgRes::SharedDtor()
+    {
+        GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+        message_received_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+    }
+
+    void MsgRes::ArenaDtor(void* object)
+    {
+        MsgRes* _this = reinterpret_cast<MsgRes*>(object);
+        (void)_this;
+    }
+    void MsgRes::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*)
+    {
+    }
+    void MsgRes::SetCachedSize(int size) const
+    {
+        _cached_size_.Set(size);
+    }
+
+    void MsgRes::Clear()
+    {
+        // @@protoc_insertion_point(message_clear_start:protobuf.MsgRes)
+        uint32_t cached_has_bits = 0;
+        // Prevent compiler warnings about cached_has_bits being unused
+        (void)cached_has_bits;
+
+        message_received_.ClearToEmpty();
+        ::memset(&from_player_id_, 0, static_cast<size_t>(reinterpret_cast<char*>(&have_message_) - reinterpret_cast<char*>(&from_player_id_)) + sizeof(have_message_));
+        _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    const char* MsgRes::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx)
+    {
+#define CHK_(x)                       \
+    if (PROTOBUF_PREDICT_FALSE(!(x))) \
+    goto failure
+        while (!ctx->Done(&ptr))
+        {
+            uint32_t tag;
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+            switch (tag >> 3)
+            {
+                // bool have_message = 1;
+                case 1:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8))
+                    {
+                        have_message_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+                        CHK_(ptr);
+                    }
+                    else
+                        goto handle_unusual;
+                    continue;
+                // int64 from_player_id = 2;
+                case 2:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16))
+                    {
+                        from_player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+                        CHK_(ptr);
+                    }
+                    else
+                        goto handle_unusual;
+                    continue;
+                // string message_received = 3;
+                case 3:
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26))
+                    {
+                        auto str = _internal_mutable_message_received();
+                        ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+                        CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "protobuf.MsgRes.message_received"));
+                        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* MsgRes::_InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const
+    {
+        // @@protoc_insertion_point(serialize_to_array_start:protobuf.MsgRes)
+        uint32_t cached_has_bits = 0;
+        (void)cached_has_bits;
+
+        // bool have_message = 1;
+        if (this->_internal_have_message() != 0)
+        {
+            target = stream->EnsureSpace(target);
+            target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_have_message(), target);
+        }
+
+        // int64 from_player_id = 2;
+        if (this->_internal_from_player_id() != 0)
+        {
+            target = stream->EnsureSpace(target);
+            target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_from_player_id(), target);
+        }
+
+        // string message_received = 3;
+        if (!this->_internal_message_received().empty())
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+                this->_internal_message_received().data(), static_cast<int>(this->_internal_message_received().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "protobuf.MsgRes.message_received"
+            );
+            target = stream->WriteStringMaybeAliased(
+                3, this->_internal_message_received(), target
+            );
+        }
+
+        if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields()))
+        {
+            target = ::PROTOBUF_NAMESPACE_ID::internal::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.MsgRes)
+        return target;
+    }
+
+    size_t MsgRes::ByteSizeLong() const
+    {
+        // @@protoc_insertion_point(message_byte_size_start:protobuf.MsgRes)
+        size_t total_size = 0;
+
+        uint32_t cached_has_bits = 0;
+        // Prevent compiler warnings about cached_has_bits being unused
+        (void)cached_has_bits;
+
+        // string message_received = 3;
+        if (!this->_internal_message_received().empty())
+        {
+            total_size += 1 +
+                          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+                              this->_internal_message_received()
+                          );
+        }
+
+        // int64 from_player_id = 2;
+        if (this->_internal_from_player_id() != 0)
+        {
+            total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_from_player_id());
+        }
+
+        // bool have_message = 1;
+        if (this->_internal_have_message() != 0)
+        {
+            total_size += 1 + 1;
+        }
+
+        return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+    }
+
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgRes::_class_data_ = {
+        ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+        MsgRes::MergeImpl};
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MsgRes::GetClassData() const
+    {
+        return &_class_data_;
+    }
+
+    void MsgRes::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from)
+    {
+        static_cast<MsgRes*>(to)->MergeFrom(
+            static_cast<const MsgRes&>(from)
+        );
+    }
+
+    void MsgRes::MergeFrom(const MsgRes& from)
+    {
+        // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MsgRes)
+        GOOGLE_DCHECK_NE(&from, this);
+        uint32_t cached_has_bits = 0;
+        (void)cached_has_bits;
+
+        if (!from._internal_message_received().empty())
+        {
+            _internal_set_message_received(from._internal_message_received());
+        }
+        if (from._internal_from_player_id() != 0)
+        {
+            _internal_set_from_player_id(from._internal_from_player_id());
+        }
+        if (from._internal_have_message() != 0)
+        {
+            _internal_set_have_message(from._internal_have_message());
+        }
+        _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+    }
+
+    void MsgRes::CopyFrom(const MsgRes& from)
+    {
+        // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MsgRes)
+        if (&from == this)
+            return;
+        Clear();
+        MergeFrom(from);
+    }
+
+    bool MsgRes::IsInitialized() const
+    {
+        return true;
+    }
+
+    void MsgRes::InternalSwap(MsgRes* other)
+    {
+        using std::swap;
+        auto* lhs_arena = GetArenaForAllocation();
+        auto* rhs_arena = other->GetArenaForAllocation();
+        _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+            &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+            &message_received_,
+            lhs_arena,
+            &other->message_received_,
+            rhs_arena
+        );
+        ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+            PROTOBUF_FIELD_OFFSET(MsgRes, have_message_) + sizeof(MsgRes::have_message_) - PROTOBUF_FIELD_OFFSET(MsgRes, from_player_id_)>(
+            reinterpret_cast<char*>(&from_player_id_),
+            reinterpret_cast<char*>(&other->from_player_id_)
+        );
+    }
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata MsgRes::GetMetadata() const
+    {
+        return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+            &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[9]
+        );
+    }
+
     // @@protoc_insertion_point(namespace_scope)
 }  // namespace protobuf
 PROTOBUF_NAMESPACE_OPEN
@@ -3879,6 +4281,11 @@ PROTOBUF_NOINLINE ::protobuf::BoolRes* Arena::CreateMaybeMessage<::protobuf::Boo
 {
     return Arena::CreateMessageInternal<::protobuf::BoolRes>(arena);
 }
+template<>
+PROTOBUF_NOINLINE ::protobuf::MsgRes* Arena::CreateMaybeMessage<::protobuf::MsgRes>(Arena* arena)
+{
+    return Arena::CreateMessageInternal<::protobuf::MsgRes>(arena);
+}
 PROTOBUF_NAMESPACE_CLOSE
 
 // @@protoc_insertion_point(global_scope)

CAPI/proto/Message2Clients.pb.h

@@ -48,7 +48,7 @@ struct TableStruct_Message2Clients_2eproto
 {
     static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold);
     static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold);
-    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[9] PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[10] PROTOBUF_SECTION_VARIABLE(protodesc_cold);
     static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
     static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
     static const uint32_t offsets[];
@@ -83,6 +83,9 @@ namespace protobuf
     class MoveRes;
     struct MoveResDefaultTypeInternal;
     extern MoveResDefaultTypeInternal _MoveRes_default_instance_;
+    class MsgRes;
+    struct MsgResDefaultTypeInternal;
+    extern MsgResDefaultTypeInternal _MsgRes_default_instance_;
 }  // namespace protobuf
 PROTOBUF_NAMESPACE_OPEN
 template<>
@@ -103,6 +106,8 @@ template<>
 ::protobuf::MessageToClient* Arena::CreateMaybeMessage<::protobuf::MessageToClient>(Arena*);
 template<>
 ::protobuf::MoveRes* Arena::CreateMaybeMessage<::protobuf::MoveRes>(Arena*);
+template<>
+::protobuf::MsgRes* Arena::CreateMaybeMessage<::protobuf::MsgRes>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 namespace protobuf
 {
@@ -1006,6 +1011,8 @@ namespace protobuf
             kYFieldNumber = 3,
             kPlaceFieldNumber = 6,
             kGuidFieldNumber = 5,
+            kSizeFieldNumber = 7,
+            kIsMovingFieldNumber = 8,
         };
         // .protobuf.PropType type = 1;
         void clear_type();
@@ -1066,6 +1073,26 @@ namespace protobuf
         int64_t _internal_guid() const;
         void _internal_set_guid(int64_t value);
 
+    public:
+        // int32 size = 7;
+        void clear_size();
+        int32_t size() const;
+        void set_size(int32_t value);
+
+    private:
+        int32_t _internal_size() const;
+        void _internal_set_size(int32_t value);
+
+    public:
+        // bool is_moving = 8;
+        void clear_is_moving();
+        bool is_moving() const;
+        void set_is_moving(bool value);
+
+    private:
+        bool _internal_is_moving() const;
+        void _internal_set_is_moving(bool value);
+
     public:
         // @@protoc_insertion_point(class_scope:protobuf.MessageOfProp)
 
@@ -1082,6 +1109,8 @@ namespace protobuf
         int32_t y_;
         int place_;
         int64_t guid_;
+        int32_t size_;
+        bool is_moving_;
         mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
         friend struct ::TableStruct_Message2Clients_2eproto;
     };
@@ -2372,6 +2401,221 @@ namespace protobuf
         mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
         friend struct ::TableStruct_Message2Clients_2eproto;
     };
+    // -------------------------------------------------------------------
+
+    class MsgRes final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MsgRes) */
+    {
+    public:
+        inline MsgRes() :
+            MsgRes(nullptr)
+        {
+        }
+        ~MsgRes() override;
+        explicit constexpr MsgRes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+        MsgRes(const MsgRes& from);
+        MsgRes(MsgRes&& from) noexcept
+            :
+            MsgRes()
+        {
+            *this = ::std::move(from);
+        }
+
+        inline MsgRes& operator=(const MsgRes& from)
+        {
+            CopyFrom(from);
+            return *this;
+        }
+        inline MsgRes& operator=(MsgRes&& 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 MsgRes& default_instance()
+        {
+            return *internal_default_instance();
+        }
+        static inline const MsgRes* internal_default_instance()
+        {
+            return reinterpret_cast<const MsgRes*>(
+                &_MsgRes_default_instance_
+            );
+        }
+        static constexpr int kIndexInFileMessages =
+            9;
+
+        friend void swap(MsgRes& a, MsgRes& b)
+        {
+            a.Swap(&b);
+        }
+        inline void Swap(MsgRes* 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(MsgRes* other)
+        {
+            if (other == this)
+                return;
+            GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+            InternalSwap(other);
+        }
+
+        // implements Message ----------------------------------------------
+
+        MsgRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        {
+            return CreateMaybeMessage<MsgRes>(arena);
+        }
+        using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+        void CopyFrom(const MsgRes& from);
+        using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+        void MergeFrom(const MsgRes& from);
+
+    private:
+        static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+
+    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 _cached_size_.Get();
+        }
+
+    private:
+        void SharedCtor();
+        void SharedDtor();
+        void SetCachedSize(int size) const final;
+        void InternalSwap(MsgRes* other);
+
+    private:
+        friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+        static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+        {
+            return "protobuf.MsgRes";
+        }
+
+    protected:
+        explicit MsgRes(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+    private:
+        static void ArenaDtor(void* object);
+        inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+
+    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
+        {
+            kMessageReceivedFieldNumber = 3,
+            kFromPlayerIdFieldNumber = 2,
+            kHaveMessageFieldNumber = 1,
+        };
+        // string message_received = 3;
+        void clear_message_received();
+        const std::string& message_received() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_message_received(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_message_received();
+        PROTOBUF_NODISCARD std::string* release_message_received();
+        void set_allocated_message_received(std::string* message_received);
+
+    private:
+        const std::string& _internal_message_received() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_message_received(const std::string& value);
+        std::string* _internal_mutable_message_received();
+
+    public:
+        // int64 from_player_id = 2;
+        void clear_from_player_id();
+        int64_t from_player_id() const;
+        void set_from_player_id(int64_t value);
+
+    private:
+        int64_t _internal_from_player_id() const;
+        void _internal_set_from_player_id(int64_t value);
+
+    public:
+        // bool have_message = 1;
+        void clear_have_message();
+        bool have_message() const;
+        void set_have_message(bool value);
+
+    private:
+        bool _internal_have_message() const;
+        void _internal_set_have_message(bool value);
+
+    public:
+        // @@protoc_insertion_point(class_scope:protobuf.MsgRes)
+
+    private:
+        class _Internal;
+
+        template<typename T>
+        friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+        typedef void InternalArenaConstructable_;
+        typedef void DestructorSkippable_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_received_;
+        int64_t from_player_id_;
+        bool have_message_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        friend struct ::TableStruct_Message2Clients_2eproto;
+    };
     // ===================================================================
 
     // ===================================================================
@@ -3314,6 +3558,54 @@ namespace protobuf
         // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.place)
     }
 
+    // int32 size = 7;
+    inline void MessageOfProp::clear_size()
+    {
+        size_ = 0;
+    }
+    inline int32_t MessageOfProp::_internal_size() const
+    {
+        return size_;
+    }
+    inline int32_t MessageOfProp::size() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.size)
+        return _internal_size();
+    }
+    inline void MessageOfProp::_internal_set_size(int32_t value)
+    {
+        size_ = value;
+    }
+    inline void MessageOfProp::set_size(int32_t value)
+    {
+        _internal_set_size(value);
+        // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.size)
+    }
+
+    // bool is_moving = 8;
+    inline void MessageOfProp::clear_is_moving()
+    {
+        is_moving_ = false;
+    }
+    inline bool MessageOfProp::_internal_is_moving() const
+    {
+        return is_moving_;
+    }
+    inline bool MessageOfProp::is_moving() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.is_moving)
+        return _internal_is_moving();
+    }
+    inline void MessageOfProp::_internal_set_is_moving(bool value)
+    {
+        is_moving_ = value;
+    }
+    inline void MessageOfProp::set_is_moving(bool value)
+    {
+        _internal_set_is_moving(value);
+        // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.is_moving)
+    }
+
     // -------------------------------------------------------------------
 
     // MessageOfPickedProp
@@ -3895,6 +4187,115 @@ namespace protobuf
         // @@protoc_insertion_point(field_set:protobuf.BoolRes.act_success)
     }
 
+    // -------------------------------------------------------------------
+
+    // MsgRes
+
+    // bool have_message = 1;
+    inline void MsgRes::clear_have_message()
+    {
+        have_message_ = false;
+    }
+    inline bool MsgRes::_internal_have_message() const
+    {
+        return have_message_;
+    }
+    inline bool MsgRes::have_message() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.MsgRes.have_message)
+        return _internal_have_message();
+    }
+    inline void MsgRes::_internal_set_have_message(bool value)
+    {
+        have_message_ = value;
+    }
+    inline void MsgRes::set_have_message(bool value)
+    {
+        _internal_set_have_message(value);
+        // @@protoc_insertion_point(field_set:protobuf.MsgRes.have_message)
+    }
+
+    // int64 from_player_id = 2;
+    inline void MsgRes::clear_from_player_id()
+    {
+        from_player_id_ = int64_t{0};
+    }
+    inline int64_t MsgRes::_internal_from_player_id() const
+    {
+        return from_player_id_;
+    }
+    inline int64_t MsgRes::from_player_id() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.MsgRes.from_player_id)
+        return _internal_from_player_id();
+    }
+    inline void MsgRes::_internal_set_from_player_id(int64_t value)
+    {
+        from_player_id_ = value;
+    }
+    inline void MsgRes::set_from_player_id(int64_t value)
+    {
+        _internal_set_from_player_id(value);
+        // @@protoc_insertion_point(field_set:protobuf.MsgRes.from_player_id)
+    }
+
+    // string message_received = 3;
+    inline void MsgRes::clear_message_received()
+    {
+        message_received_.ClearToEmpty();
+    }
+    inline const std::string& MsgRes::message_received() const
+    {
+        // @@protoc_insertion_point(field_get:protobuf.MsgRes.message_received)
+        return _internal_message_received();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void MsgRes::set_message_received(ArgT0&& arg0, ArgT... args)
+    {
+        message_received_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:protobuf.MsgRes.message_received)
+    }
+    inline std::string* MsgRes::mutable_message_received()
+    {
+        std::string* _s = _internal_mutable_message_received();
+        // @@protoc_insertion_point(field_mutable:protobuf.MsgRes.message_received)
+        return _s;
+    }
+    inline const std::string& MsgRes::_internal_message_received() const
+    {
+        return message_received_.Get();
+    }
+    inline void MsgRes::_internal_set_message_received(const std::string& value)
+    {
+        message_received_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+    }
+    inline std::string* MsgRes::_internal_mutable_message_received()
+    {
+        return message_received_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    }
+    inline std::string* MsgRes::release_message_received()
+    {
+        // @@protoc_insertion_point(field_release:protobuf.MsgRes.message_received)
+        return message_received_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+    }
+    inline void MsgRes::set_allocated_message_received(std::string* message_received)
+    {
+        if (message_received != nullptr)
+        {
+        }
+        else
+        {
+        }
+        message_received_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message_received, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (message_received_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()))
+        {
+            message_received_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:protobuf.MsgRes.message_received)
+    }
+
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif  // __GNUC__
@@ -3914,6 +4315,8 @@ namespace protobuf
 
     // -------------------------------------------------------------------
 
+    // -------------------------------------------------------------------
+
     // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace protobuf

dependency/proto/Message2Clients.proto

@@ -51,6 +51,8 @@ message MessageOfProp // 可拾取道具的信息
     double facing_direction = 4;
     int64 guid = 5;
     PlaceType place = 6;
+    int32 size = 7;
+    bool is_moving = 8;
 }
 
 message MessageOfPickedProp  //for Unity，直接继承自THUAI5
@@ -90,6 +92,13 @@ message BoolRes // 用于只需要判断执行操作是否成功的行为，如
     bool act_success = 1;
 }
 
+message MsgRes // 用于获取队友发来的消息
+{
+    bool have_message = 1; // 是否有待接收的消息
+    int64 from_player_id = 2;
+    string message_received = 3;
+}
+
 service AvailableService
 {
     // 游戏开局调用一次的服务
@@ -101,6 +110,8 @@ service AvailableService
     rpc UseProp(IDMsg) returns (BoolRes);
     rpc UseSkill(IDMsg) returns (BoolRes);
     rpc SendMessage(SendMsg) returns (BoolRes);
+    rpc HaveMessage(IDMsg) returns (BoolRes);
+    rpc GetMessage(IDMsg) returns (MsgRes);
     rpc FixMachine(stream IDMsg) returns (stream BoolRes); // 若正常修复且未被打断则返回修复成功，位置错误/被打断则返回修复失败，下同
     rpc SaveHuman(stream IDMsg) returns (stream BoolRes);
     rpc Attack (AttackMsg) returns (BoolRes);
@@ -108,5 +119,5 @@ service AvailableService
     rpc ReleaseHuman (IDMsg) returns (BoolRes);
     rpc HangHuman (IDMsg) returns (BoolRes);
     rpc Escape (IDMsg) returns (BoolRes);
-
+    
 }