diff --git a/CAPI/.gitattributes b/CAPI/cpp/.gitattributes similarity index 100% rename from CAPI/.gitattributes rename to CAPI/cpp/.gitattributes diff --git a/CAPI/.gitignore b/CAPI/cpp/.gitignore similarity index 100% rename from CAPI/.gitignore rename to CAPI/cpp/.gitignore diff --git a/CAPI/API/API.vcxproj b/CAPI/cpp/API/API.vcxproj similarity index 100% rename from CAPI/API/API.vcxproj rename to CAPI/cpp/API/API.vcxproj diff --git a/CAPI/API/API.vcxproj.filters b/CAPI/cpp/API/API.vcxproj.filters similarity index 100% rename from CAPI/API/API.vcxproj.filters rename to CAPI/cpp/API/API.vcxproj.filters diff --git a/CAPI/API/include/AI.h b/CAPI/cpp/API/include/AI.h similarity index 100% rename from CAPI/API/include/AI.h rename to CAPI/cpp/API/include/AI.h diff --git a/CAPI/API/include/API.h b/CAPI/cpp/API/include/API.h similarity index 90% rename from CAPI/API/include/API.h rename to CAPI/cpp/API/include/API.h index e3fb77d..0e99b41 100644 --- a/CAPI/API/include/API.h +++ b/CAPI/cpp/API/include/API.h @@ -44,8 +44,8 @@ public: // 供IAPI使用的操作相关的部分 virtual bool Move(int64_t time, double angle) = 0; virtual bool PickProp(THUAI6::PropType prop) = 0; - virtual bool UseProp() = 0; - virtual bool UseSkill() = 0; + virtual bool UseProp(THUAI6::PropType prop) = 0; + virtual bool UseSkill(int32_t skillID) = 0; virtual bool SendMessage(int64_t toID, std::string message) = 0; virtual bool HaveMessage() = 0; virtual std::optional> GetMessage() = 0; @@ -58,11 +58,11 @@ public: virtual bool Graduate() = 0; virtual bool StartLearning() = 0; - virtual bool StartHelpMate() = 0; - virtual bool StartHealMate() = 0; + virtual bool StartTreatMate() = 0; + virtual bool StartRescueMate() = 0; // ITrickerAPI使用的部分 - virtual bool Trick(double angle) = 0; + virtual bool Attack(double angle) = 0; virtual const std::vector GetPlayerGUIDs() const = 0; }; @@ -82,8 +82,8 @@ public: // 捡道具、使用技能 virtual std::future PickProp(THUAI6::PropType prop) = 0; - virtual std::future UseProp() = 0; - virtual std::future UseSkill() = 0; + virtual std::future UseProp(THUAI6::PropType prop) = 0; + virtual std::future UseSkill(int32_t skillID) = 0; // 发送信息、接受信息，注意收消息时无消息则返回nullopt virtual std::future SendMessage(int64_t, std::string) = 0; @@ -138,8 +138,8 @@ public: /*****学生阵营的特定函数*****/ virtual std::future StartLearning() = 0; - virtual std::future StartHelpMate() = 0; - virtual std::future StartHealMate() = 0; + virtual std::future StartTreatMate() = 0; + virtual std::future StartRescueMate() = 0; virtual std::future Graduate() = 0; [[nodiscard]] virtual std::shared_ptr GetSelfInfo() const = 0; }; @@ -149,7 +149,7 @@ class ITrickerAPI : public IAPI public: /*****捣蛋鬼阵营的特定函数*****/ - virtual std::future Trick(double angleInRadian) = 0; + virtual std::future Attack(double angleInRadian) = 0; [[nodiscard]] virtual std::shared_ptr GetSelfInfo() const = 0; }; @@ -187,8 +187,8 @@ public: std::future MoveDown(int64_t timeInMilliseconds) override; std::future PickProp(THUAI6::PropType prop) override; - std::future UseProp() override; - std::future UseSkill() override; + std::future UseProp(THUAI6::PropType prop) override; + std::future UseSkill(int32_t skillID) override; std::future SendMessage(int64_t, std::string) override; [[nodiscard]] std::future HaveMessage() override; @@ -207,8 +207,8 @@ public: [[nodiscard]] const std::vector GetPlayerGUIDs() const override; std::future StartLearning() override; - std::future StartHelpMate() override; - std::future StartHealMate() override; + std::future StartTreatMate() override; + std::future StartRescueMate() override; std::future Graduate() override; [[nodiscard]] std::shared_ptr GetSelfInfo() const override; @@ -253,8 +253,8 @@ public: std::future MoveDown(int64_t timeInMilliseconds) override; std::future PickProp(THUAI6::PropType prop) override; - std::future UseProp() override; - std::future UseSkill() override; + std::future UseProp(THUAI6::PropType prop) override; + std::future UseSkill(int32_t skillID) override; std::future SendMessage(int64_t, std::string) override; [[nodiscard]] std::future HaveMessage() override; @@ -272,7 +272,7 @@ public: [[nodiscard]] const std::vector GetPlayerGUIDs() const override; - std::future Trick(double angleInRadian) override; + std::future Attack(double angleInRadian) override; [[nodiscard]] std::shared_ptr GetSelfInfo() const override; void PrintStudent() const override @@ -309,8 +309,8 @@ public: std::future MoveDown(int64_t timeInMilliseconds) override; std::future PickProp(THUAI6::PropType prop) override; - std::future UseProp() override; - std::future UseSkill() override; + std::future UseProp(THUAI6::PropType prop) override; + std::future UseSkill(int32_t skillID) override; std::future SendMessage(int64_t, std::string) override; [[nodiscard]] std::future HaveMessage() override; @@ -329,8 +329,8 @@ public: [[nodiscard]] const std::vector GetPlayerGUIDs() const override; std::future StartLearning() override; - std::future StartHelpMate() override; - std::future StartHealMate() override; + std::future StartTreatMate() override; + std::future StartRescueMate() override; std::future Graduate() override; [[nodiscard]] virtual std::shared_ptr GetSelfInfo() const override; @@ -362,8 +362,8 @@ public: std::future MoveDown(int64_t timeInMilliseconds) override; std::future PickProp(THUAI6::PropType prop) override; - std::future UseProp() override; - std::future UseSkill() override; + std::future UseProp(THUAI6::PropType prop) override; + std::future UseSkill(int32_t skillID) override; std::future SendMessage(int64_t, std::string) override; [[nodiscard]] std::future HaveMessage() override; @@ -381,7 +381,7 @@ public: [[nodiscard]] const std::vector GetPlayerGUIDs() const override; - std::future Trick(double angleInRadian) override; + std::future Attack(double angleInRadian) override; [[nodiscard]] std::shared_ptr GetSelfInfo() const override; void PrintStudent() const override; diff --git a/CAPI/API/include/Communication.h b/CAPI/cpp/API/include/Communication.h similarity index 73% rename from CAPI/API/include/Communication.h rename to CAPI/cpp/API/include/Communication.h index 98b1234..ef69a4d 100644 --- a/CAPI/API/include/Communication.h +++ b/CAPI/cpp/API/include/Communication.h @@ -26,18 +26,25 @@ public: } bool Move(int64_t time, double angle, int64_t playerID); bool PickProp(THUAI6::PropType prop, int64_t playerID); - bool UseProp(int64_t playerID); - bool UseSkill(int64_t playerID); + bool UseProp(THUAI6::PropType prop, int64_t playerID); + bool UseSkill(int32_t skillID, int64_t playerID); std::optional> GetMessage(); bool HaveMessage(); bool SendMessage(int64_t toID, std::string message, int64_t playerID); + bool OpenDoor(int64_t playerID); + bool CloseDoor(int64_t playerID); + bool SkipWindow(int64_t playerID); + bool StartOpenGate(int64_t playerID); + bool StartOpenChest(int64_t playerID); + bool EndAllAction(int64_t playerID); + bool Graduate(int64_t playerID); bool StartLearning(int64_t playerID); - bool StartHelpMate(int64_t playerID); - bool StartHealMate(int64_t playerID); + bool StartTreatMate(int64_t playerID); + bool StartRescueMate(int64_t playerID); - bool Trick(double angle, int64_t playerID); + bool Attack(double angle, int64_t playerID); bool TryConnection(int64_t playerID); protobuf::MessageToClient GetMessage2Client(); @@ -47,6 +54,7 @@ public: private: std::unique_ptr THUAI6Stub; + THUAI6::PlayerType playerType; bool haveNewMessage = false; protobuf::MessageToClient message2Client; ConcurrentQueue> messageQueue; diff --git a/CAPI/API/include/ConcurrentQueue.hpp b/CAPI/cpp/API/include/ConcurrentQueue.hpp similarity index 100% rename from CAPI/API/include/ConcurrentQueue.hpp rename to CAPI/cpp/API/include/ConcurrentQueue.hpp diff --git a/CAPI/API/include/constants.h b/CAPI/cpp/API/include/constants.h similarity index 100% rename from CAPI/API/include/constants.h rename to CAPI/cpp/API/include/constants.h diff --git a/CAPI/API/include/logic.h b/CAPI/cpp/API/include/logic.h similarity index 94% rename from CAPI/API/include/logic.h rename to CAPI/cpp/API/include/logic.h index 8e74fb9..eefa8d4 100644 --- a/CAPI/API/include/logic.h +++ b/CAPI/cpp/API/include/logic.h @@ -102,8 +102,8 @@ private: // 供IAPI使用的操作相关的部分 bool Move(int64_t time, double angle) override; bool PickProp(THUAI6::PropType prop) override; - bool UseProp() override; - bool UseSkill() override; + bool UseProp(THUAI6::PropType prop) override; + bool UseSkill(int32_t skillID) override; bool SendMessage(int64_t toID, std::string message) override; bool HaveMessage() override; @@ -113,10 +113,10 @@ private: bool StartLearning() override; - bool StartHelpMate() override; - bool StartHealMate() override; + bool StartTreatMate() override; + bool StartRescueMate() override; - bool Trick(double angle) override; + bool Attack(double angle) override; bool WaitThread() override; diff --git a/CAPI/API/include/state.h b/CAPI/cpp/API/include/state.h similarity index 86% rename from CAPI/API/include/state.h rename to CAPI/cpp/API/include/state.h index f83585c..d8e7863 100644 --- a/CAPI/API/include/state.h +++ b/CAPI/cpp/API/include/state.h @@ -4,6 +4,7 @@ #include #include +#include #include "structures.h" @@ -24,7 +25,9 @@ struct State std::vector> bombedBullets; - std::vector> gamemap; + std::shared_ptr gameMap; + + std::shared_ptr gameInfo; std::vector guids; }; diff --git a/CAPI/API/include/structures.h b/CAPI/cpp/API/include/structures.h similarity index 63% rename from CAPI/API/include/structures.h rename to CAPI/cpp/API/include/structures.h index d650770..2736138 100644 --- a/CAPI/API/include/structures.h +++ b/CAPI/cpp/API/include/structures.h @@ -27,9 +27,11 @@ namespace THUAI6 Wall = 2, Grass = 3, ClassRoom = 4, - BlackRoom = 5, - Gate = 6, - HiddenGate = 7, + Gate = 5, + HiddenGate = 6, + Window = 7, + Door = 8, + Chest = 9, }; // 形状标志 @@ -108,9 +110,9 @@ namespace THUAI6 }; // 学生状态枚举 - enum class StudentState : unsigned char + enum class PlayerState : unsigned char { - NullStudentState = 0, + NullState = 0, Idle = 1, Learning = 2, Addicted = 3, @@ -121,6 +123,30 @@ namespace THUAI6 Stunned = 8, Treating = 9, Rescuing = 10, + Swinging = 11, + Attacking = 12, + Locking = 13, + Rummaging = 14, + Climbing = 15, + }; + + enum class MessageOfObj : unsigned char + { + NullMessageOfObj = 0, + StudentMessage = 1, + TrickerMessage = 2, + PropMessage = 3, + BulletMessage = 4, + BombedBulletMessage = 5, + }; + + enum class MessageOfMapObj : unsigned char + { + NullMessageOfMapObj = 0, + ClassroomMessage = 1, + DoorMessage = 2, + GateMessage = 3, + ChestMessage = 4, }; // 玩家类 @@ -138,26 +164,25 @@ namespace THUAI6 double timeUntilSkillAvailable; // 技能冷却时间 PlayerType playerType; // 玩家类型 - PropType prop; // 手上的道具类型 - PlaceType place; // 所处格子的类型 + std::vector props; + PlaceType place; // 所处格子的类型 + + PlayerState playerState; }; struct Student : public Player { - StudentState state; // 学生状态 + StudentType studentType; int32_t determination; // 剩余毅力（本次Emo之前还能承受的伤害） int32_t failNum; // 挂科数量 double failTime; // 挂科时间 double emoTime; // EMO时间 - StudentType studentType; // 学生类型 std::vector buff; // buff }; struct Tricker : public Player { - bool movable; // 是否处在攻击后摇中 - TrickerType trickerType; // 捣蛋鬼类型 std::vector buff; // buff }; @@ -196,6 +221,31 @@ namespace THUAI6 bool isMoving; }; + struct GameMap + { + std::vector> gameMap; + std::map, int32_t> classRoomState; + + std::map, int32_t> gateState; + + std::map, bool> doorState; + + std::map, int32_t> chestState; + }; + + struct GameInfo + { + int32_t gameTime; + int32_t subjectLeft; + int32_t studentGraduated; + int32_t studentQuited; + int32_t studentScore; + int32_t trickerScore; + bool gateOpened; + bool hiddenGateRefreshed; + bool hiddenGateOpened; + }; + // 仅供DEBUG使用，名称可改动 // 还没写完，后面待续 @@ -206,18 +256,23 @@ namespace THUAI6 {GameState::GameEnd, "GameEnd"}, }; - inline std::map studentStateDict{ - {StudentState::NullStudentState, "NullStudentState"}, - {StudentState::Idle, "Idle"}, - {StudentState::Learning, "Learning"}, - {StudentState::Addicted, "Addicted"}, - {StudentState::Quit, "Quit"}, - {StudentState::Graduated, "Graduated"}, - {StudentState::Treated, "Treated"}, - {StudentState::Rescued, "Rescued"}, - {StudentState::Stunned, "Stunned"}, - {StudentState::Treating, "Treating"}, - {StudentState::Rescuing, "Rescuing"}, + inline std::map playerStateDict{ + {PlayerState::NullState, "NullState"}, + {PlayerState::Idle, "Idle"}, + {PlayerState::Learning, "Learning"}, + {PlayerState::Addicted, "Addicted"}, + {PlayerState::Quit, "Quit"}, + {PlayerState::Graduated, "Graduated"}, + {PlayerState::Treated, "Treated"}, + {PlayerState::Rescued, "Rescued"}, + {PlayerState::Stunned, "Stunned"}, + {PlayerState::Treating, "Treating"}, + {PlayerState::Rescuing, "Rescuing"}, + {PlayerState::Swinging, "Swinging"}, + {PlayerState::Attacking, "Attacking"}, + {PlayerState::Locking, "Locking"}, + {PlayerState::Rummaging, "Rummaging"}, + {PlayerState::Climbing, "Climbing"}, }; inline std::map playerTypeDict{ @@ -234,6 +289,9 @@ namespace THUAI6 {PlaceType::ClassRoom, "ClassRoom"}, {PlaceType::Gate, "Gate"}, {PlaceType::HiddenGate, "HiddenGate"}, + {PlaceType::Door, "Door"}, + {PlaceType::Window, "Window"}, + {PlaceType::Chest, "Chest"}, }; inline std::map propTypeDict{ @@ -251,6 +309,23 @@ namespace THUAI6 }; + inline std::map messageOfObjDict{ + {MessageOfObj::NullMessageOfObj, "NullMessageOfObj"}, + {MessageOfObj::StudentMessage, "StudentMessage"}, + {MessageOfObj::TrickerMessage, "TrickerMessage"}, + {MessageOfObj::PropMessage, "PropMessage"}, + {MessageOfObj::BulletMessage, "BulletMessage"}, + {MessageOfObj::BombedBulletMessage, "BombedBulletMessage"}, + }; + + inline std::map messageOfMapObjDict{ + {MessageOfMapObj::NullMessageOfMapObj, "NullMessageOfMapObj"}, + {MessageOfMapObj::ClassroomMessage, "ClassroomMessage"}, + {MessageOfMapObj::DoorMessage, "DoorMessage"}, + {MessageOfMapObj::GateMessage, "GateMessage"}, + {MessageOfMapObj::ChestMessage, "ChestMessage"}, + }; + } // namespace THUAI6 #endif diff --git a/CAPI/API/include/utils.hpp b/CAPI/cpp/API/include/utils.hpp similarity index 73% rename from CAPI/API/include/utils.hpp rename to CAPI/cpp/API/include/utils.hpp index 49f0d6f..4dbaf9c 100644 --- a/CAPI/API/include/utils.hpp +++ b/CAPI/cpp/API/include/utils.hpp @@ -69,6 +69,8 @@ namespace Proto2THUAI6 {protobuf::PlaceType::CLASSROOM, THUAI6::PlaceType::ClassRoom}, {protobuf::PlaceType::GATE, THUAI6::PlaceType::Gate}, {protobuf::PlaceType::HIDDEN_GATE, THUAI6::PlaceType::HiddenGate}, + {protobuf::PlaceType::WINDOW, THUAI6::PlaceType::Window}, + {protobuf::PlaceType::DOOR, THUAI6::PlaceType::Door}, }; inline std::map shapeTypeDict{ @@ -123,18 +125,18 @@ namespace Proto2THUAI6 {protobuf::TrickerBuffType::TBUFFTYPE4, THUAI6::TrickerBuffType::TrickerBuffType4}, }; - inline std::map studentStateDict{ - {protobuf::StudentState::NULL_STATUS, THUAI6::StudentState::NullStudentState}, - {protobuf::StudentState::IDLE, THUAI6::StudentState::Idle}, - {protobuf::StudentState::LEARNING, THUAI6::StudentState::Learning}, - {protobuf::StudentState::ADDICTED, THUAI6::StudentState::Addicted}, - {protobuf::StudentState::QUIT, THUAI6::StudentState::Quit}, - {protobuf::StudentState::GRADUATED, THUAI6::StudentState::Graduated}, - {protobuf::StudentState::RESCUED, THUAI6::StudentState::Rescued}, - {protobuf::StudentState::TREATED, THUAI6::StudentState::Treated}, - {protobuf::StudentState::STUNNED, THUAI6::StudentState::Stunned}, - {protobuf::StudentState::RESCUING, THUAI6::StudentState::Rescuing}, - {protobuf::StudentState::TREATING, THUAI6::StudentState::Treating}, + inline std::map playerStateDict{ + {protobuf::PlayerState::NULL_STATUS, THUAI6::PlayerState::NullState}, + {protobuf::PlayerState::IDLE, THUAI6::PlayerState::Idle}, + {protobuf::PlayerState::LEARNING, THUAI6::PlayerState::Learning}, + {protobuf::PlayerState::ADDICTED, THUAI6::PlayerState::Addicted}, + {protobuf::PlayerState::QUIT, THUAI6::PlayerState::Quit}, + {protobuf::PlayerState::GRADUATED, THUAI6::PlayerState::Graduated}, + {protobuf::PlayerState::RESCUED, THUAI6::PlayerState::Rescued}, + {protobuf::PlayerState::TREATED, THUAI6::PlayerState::Treated}, + {protobuf::PlayerState::STUNNED, THUAI6::PlayerState::Stunned}, + {protobuf::PlayerState::RESCUING, THUAI6::PlayerState::Rescuing}, + {protobuf::PlayerState::TREATING, THUAI6::PlayerState::Treating}, }; inline std::map gameStateDict{ @@ -153,6 +155,23 @@ namespace Proto2THUAI6 {protobuf::BulletType::ATOM_BOMB, THUAI6::BulletType::AtomBomb}, }; + inline std::map messageOfObjDict{ + {protobuf::MessageOfObj::kStudentMessage, THUAI6::MessageOfObj::StudentMessage}, + {protobuf::MessageOfObj::kTrickerMessage, THUAI6::MessageOfObj::TrickerMessage}, + {protobuf::MessageOfObj::kPropMessage, THUAI6::MessageOfObj::PropMessage}, + {protobuf::MessageOfObj::kBulletMessage, THUAI6::MessageOfObj::BulletMessage}, + {protobuf::MessageOfObj::kBombedBulletMessage, THUAI6::MessageOfObj::BombedBulletMessage}, + {protobuf::MessageOfObj::MESSAGE_OF_OBJ_NOT_SET, THUAI6::MessageOfObj::NullMessageOfObj}, + }; + + inline std::map messageOfMapObjDict{ + {protobuf::MessageOfMapObj::MessageOfMapObjCase::kClassroomMessage, THUAI6::MessageOfMapObj::ClassroomMessage}, + {protobuf::MessageOfMapObj::MessageOfMapObjCase::kDoorMessage, THUAI6::MessageOfMapObj::DoorMessage}, + {protobuf::MessageOfMapObj::MessageOfMapObjCase::kGateMessage, THUAI6::MessageOfMapObj::GateMessage}, + {protobuf::MessageOfMapObj::MessageOfMapObjCase::kChestMessage, THUAI6::MessageOfMapObj::ChestMessage}, + + }; + // 用于将Protobuf中的类转换为THUAI6的类 inline std::shared_ptr Protobuf2THUAI6Tricker(const protobuf::MessageOfTricker& trickerMsg) { @@ -163,10 +182,13 @@ namespace Proto2THUAI6 tricker->damage = trickerMsg.damage(); tricker->timeUntilSkillAvailable = trickerMsg.time_until_skill_available(); tricker->place = placeTypeDict[trickerMsg.place()]; - tricker->prop = propTypeDict[trickerMsg.prop()]; + tricker->playerState = playerStateDict[trickerMsg.player_state()]; + for (int i = 0; i < trickerMsg.prop().size(); i++) + { + tricker->props.push_back(propTypeDict[trickerMsg.prop(i)]); + } tricker->trickerType = trickerTypeDict[trickerMsg.tricker_type()]; tricker->guid = trickerMsg.guid(); - tricker->movable = trickerMsg.movable(); tricker->playerID = trickerMsg.player_id(); tricker->viewRange = trickerMsg.view_range(); tricker->radius = trickerMsg.radius(); @@ -191,9 +213,12 @@ namespace Proto2THUAI6 student->timeUntilSkillAvailable = studentMsg.time_until_skill_available(); student->damage = studentMsg.damage(); student->playerType = THUAI6::PlayerType::StudentPlayer; - student->prop = propTypeDict[studentMsg.prop()]; + for (int i = 0; i < studentMsg.prop().size(); i++) + { + student->props.push_back(propTypeDict[studentMsg.prop(i)]); + } student->place = placeTypeDict[studentMsg.place()]; - student->state = studentStateDict[studentMsg.state()]; + student->playerState = playerStateDict[studentMsg.state()]; student->determination = studentMsg.determination(); student->failNum = studentMsg.fail_num(); student->failTime = studentMsg.fail_time(); @@ -221,9 +246,9 @@ namespace Proto2THUAI6 return prop; } - inline std::vector> Protobuf2THUAI6Map(const protobuf::MessageOfMap& mapMsg) + inline std::shared_ptr Protobuf2THUAI6Map(const protobuf::MessageOfMap& mapMsg) { - std::vector> map; + auto map = std::make_shared(); for (int i = 0; i < mapMsg.row_size(); i++) { std::vector row; @@ -231,11 +256,41 @@ namespace Proto2THUAI6 { row.push_back(placeTypeDict[mapMsg.row(i).col(j)]); } - map.push_back(row); + map->gameMap.push_back(row); } + for (const auto& item : mapMsg.map_obj_message()) + switch (messageOfMapObjDict[item.message_of_map_obj_case()]) + { + case THUAI6::MessageOfMapObj::ClassroomMessage: + map->classRoomState.emplace(std::make_pair(item.classroom_message().x(), item.classroom_message().y()), item.classroom_message().progress()); + break; + case THUAI6::MessageOfMapObj::DoorMessage: + map->doorState.emplace(std::make_pair(item.door_message().x(), item.door_message().y()), item.door_message().is_open()); + break; + case THUAI6::MessageOfMapObj::GateMessage: + map->gateState.emplace(std::make_pair(item.gate_message().x(), item.gate_message().y()), item.gate_message().progress()); + break; + default: + break; + } return map; } + inline std::shared_ptr Protobuf2THUAI6GameInfo(const protobuf::MessageOfAll& allMsg) + { + auto gameInfo = std::make_shared(); + gameInfo->gameTime = allMsg.game_time(); + gameInfo->subjectLeft = allMsg.subject_left(); + gameInfo->studentGraduated = allMsg.student_graduated(); + 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; + } + inline std::shared_ptr Protobuf2THUAI6Bullet(const protobuf::MessageOfBullet& bulletMsg) { auto bullet = std::make_shared(); @@ -275,6 +330,8 @@ namespace THUAI62Proto {THUAI6::PlaceType::ClassRoom, protobuf::PlaceType::CLASSROOM}, {THUAI6::PlaceType::Gate, protobuf::PlaceType::GATE}, {THUAI6::PlaceType::HiddenGate, protobuf::PlaceType::HIDDEN_GATE}, + {THUAI6::PlaceType::Door, protobuf::PlaceType::DOOR}, + {THUAI6::PlaceType::Window, protobuf::PlaceType::WINDOW}, }; inline std::map shapeTypeDict{ @@ -346,45 +403,60 @@ namespace THUAI62Proto return playerMsg; } - inline protobuf::IDMsg THUAI62ProtobufID(int playerID) + inline protobuf::IDMsg THUAI62ProtobufID(int playerID, THUAI6::PlayerType playerType) { protobuf::IDMsg idMsg; idMsg.set_player_id(playerID); + idMsg.set_player_type(playerTypeDict[playerType]); return idMsg; } - inline protobuf::MoveMsg THUAI62ProtobufMove(int64_t time, double angle, int64_t id) + inline protobuf::MoveMsg THUAI62ProtobufMove(int64_t time, double angle, int64_t id, THUAI6::PlayerType playerType) { protobuf::MoveMsg moveMsg; moveMsg.set_time_in_milliseconds(time); moveMsg.set_angle(angle); moveMsg.set_player_id(id); + moveMsg.set_player_type(playerTypeDict[playerType]); return moveMsg; } - inline protobuf::PickMsg THUAI62ProtobufPick(THUAI6::PropType prop, int64_t id) + inline protobuf::PropMsg THUAI62ProtobufProp(THUAI6::PropType prop, int64_t id, THUAI6::PlayerType playerType) { - protobuf::PickMsg pickMsg; + protobuf::PropMsg pickMsg; pickMsg.set_prop_type(propTypeDict[prop]); pickMsg.set_player_id(id); + pickMsg.set_player_type(playerTypeDict[playerType]); return pickMsg; } - inline protobuf::SendMsg THUAI62ProtobufSend(std::string msg, int64_t toID, int64_t id) + inline protobuf::SendMsg THUAI62ProtobufSend(std::string msg, int64_t toID, int64_t id, THUAI6::PlayerType playerType, THUAI6::PlayerType toType) { protobuf::SendMsg sendMsg; sendMsg.set_message(msg); sendMsg.set_to_player_id(toID); sendMsg.set_player_id(id); + sendMsg.set_player_type(playerTypeDict[playerType]); + sendMsg.set_to_player_type(playerTypeDict[toType]); return sendMsg; } - inline protobuf::TrickMsg THUAI62ProtobufTrick(double angle, int64_t id) + inline protobuf::AttackMsg THUAI62ProtobufAttack(double angle, int64_t id, THUAI6::PlayerType playerType) + { + protobuf::AttackMsg attackMsg; + attackMsg.set_angle(angle); + attackMsg.set_player_id(id); + attackMsg.set_player_type(playerTypeDict[playerType]); + return attackMsg; + } + + inline protobuf::SkillMsg THUAI62ProtobufSkill(int32_t skillID, int64_t id, THUAI6::PlayerType playerType) { - protobuf::TrickMsg trickMsg; - trickMsg.set_angle(angle); - trickMsg.set_player_id(id); - return trickMsg; + protobuf::SkillMsg skillMsg; + skillMsg.set_skill_id(skillID); + skillMsg.set_player_id(id); + skillMsg.set_player_type(playerTypeDict[playerType]); + return skillMsg; } } // namespace THUAI62Proto diff --git a/CAPI/API/src/AI.cpp b/CAPI/cpp/API/src/AI.cpp similarity index 100% rename from CAPI/API/src/AI.cpp rename to CAPI/cpp/API/src/AI.cpp diff --git a/CAPI/API/src/API.cpp b/CAPI/cpp/API/src/API.cpp similarity index 85% rename from CAPI/API/src/API.cpp rename to CAPI/cpp/API/src/API.cpp index 75e6a02..3be14f2 100644 --- a/CAPI/API/src/API.cpp +++ b/CAPI/cpp/API/src/API.cpp @@ -71,10 +71,10 @@ std::future StudentAPI::PickProp(THUAI6::PropType prop) { return logic.PickProp(prop); }); } -std::future StudentAPI::UseProp() +std::future StudentAPI::UseProp(THUAI6::PropType prop) { - return std::async(std::launch::async, [&]() - { return logic.UseProp(); }); + return std::async(std::launch::async, [=]() + { return logic.UseProp(prop); }); } std::future TrickerAPI::PickProp(THUAI6::PropType prop) @@ -83,22 +83,22 @@ std::future TrickerAPI::PickProp(THUAI6::PropType prop) { return logic.PickProp(prop); }); } -std::future TrickerAPI::UseProp() +std::future TrickerAPI::UseProp(THUAI6::PropType prop) { - return std::async(std::launch::async, [&]() - { return logic.UseProp(); }); + return std::async(std::launch::async, [=]() + { return logic.UseProp(prop); }); } -std::future StudentAPI::UseSkill() +std::future StudentAPI::UseSkill(int32_t skillID) { - return std::async(std::launch::async, [&]() - { return logic.UseSkill(); }); + return std::async(std::launch::async, [=]() + { return logic.UseSkill(skillID); }); } -std::future TrickerAPI::UseSkill() +std::future TrickerAPI::UseSkill(int32_t skillID) { - return std::async(std::launch::async, [&]() - { return logic.UseSkill(); }); + return std::async(std::launch::async, [=]() + { return logic.UseSkill(skillID); }); } std::future StudentAPI::SendMessage(int64_t toID, std::string message) @@ -223,16 +223,16 @@ std::future StudentAPI::StartLearning() { return logic.StartLearning(); }); } -std::future StudentAPI::StartHelpMate() +std::future StudentAPI::StartTreatMate() { return std::async(std::launch::async, [&]() - { return logic.StartHelpMate(); }); + { return logic.StartTreatMate(); }); } -std::future StudentAPI::StartHealMate() +std::future StudentAPI::StartRescueMate() { return std::async(std::launch::async, [&]() - { return logic.StartHealMate(); }); + { return logic.StartRescueMate(); }); } std::future StudentAPI::Graduate() @@ -246,10 +246,10 @@ std::shared_ptr StudentAPI::GetSelfInfo() const return logic.StudentGetSelfInfo(); } -std::future TrickerAPI::Trick(double angleInRadian) +std::future TrickerAPI::Attack(double angleInRadian) { return std::async(std::launch::async, [&]() - { return logic.Trick(angleInRadian); }); + { return logic.Attack(angleInRadian); }); } std::shared_ptr TrickerAPI::GetSelfInfo() const diff --git a/CAPI/API/src/Communication.cpp b/CAPI/cpp/API/src/Communication.cpp similarity index 55% rename from CAPI/API/src/Communication.cpp rename to CAPI/cpp/API/src/Communication.cpp index b1ad452..c6e40cf 100644 --- a/CAPI/API/src/Communication.cpp +++ b/CAPI/cpp/API/src/Communication.cpp @@ -18,7 +18,7 @@ bool Communication::Move(int64_t time, double angle, int64_t playerID) { protobuf::MoveRes moveResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufMove(time, angle, playerID); + auto request = THUAI62Proto::THUAI62ProtobufMove(time, angle, playerID, playerType); std::cout << "Move request sent" << std::endl; auto status = THUAI6Stub->Move(&context, request, &moveResult); if (status.ok()) @@ -31,7 +31,7 @@ bool Communication::PickProp(THUAI6::PropType prop, int64_t playerID) { protobuf::BoolRes pickPropResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufPick(prop, playerID); + auto request = THUAI62Proto::THUAI62ProtobufProp(prop, playerID, playerType); auto status = THUAI6Stub->PickProp(&context, request, &pickPropResult); if (status.ok()) return pickPropResult.act_success(); @@ -39,11 +39,11 @@ bool Communication::PickProp(THUAI6::PropType prop, int64_t playerID) return false; } -bool Communication::UseProp(int64_t playerID) +bool Communication::UseProp(THUAI6::PropType prop, int64_t playerID) { protobuf::BoolRes usePropResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); + auto request = THUAI62Proto::THUAI62ProtobufProp(prop, playerID, playerType); auto status = THUAI6Stub->UseProp(&context, request, &usePropResult); if (status.ok()) return usePropResult.act_success(); @@ -51,11 +51,11 @@ bool Communication::UseProp(int64_t playerID) return false; } -bool Communication::UseSkill(int64_t playerID) +bool Communication::UseSkill(int32_t skillID, int64_t playerID) { protobuf::BoolRes useSkillResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); + auto request = THUAI62Proto::THUAI62ProtobufSkill(skillID, playerID, playerType); auto status = THUAI6Stub->UseSkill(&context, request, &useSkillResult); if (status.ok()) return useSkillResult.act_success(); @@ -67,7 +67,7 @@ bool Communication::SendMessage(int64_t toID, std::string message, int64_t playe { protobuf::BoolRes sendMessageResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufSend(message, toID, playerID); + auto request = THUAI62Proto::THUAI62ProtobufSend(message, toID, playerID, playerType, playerType); auto status = THUAI6Stub->SendMessage(&context, request, &sendMessageResult); if (status.ok()) return sendMessageResult.act_success(); @@ -75,11 +75,83 @@ bool Communication::SendMessage(int64_t toID, std::string message, int64_t playe return false; } +bool Communication::OpenDoor(int64_t playerID) +{ + protobuf::BoolRes openDoorResult; + ClientContext context; + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->OpenDoor(&context, request, &openDoorResult); + if (status.ok()) + return openDoorResult.act_success(); + else + return false; +} + +bool Communication::CloseDoor(int64_t playerID) +{ + protobuf::BoolRes closeDoorResult; + ClientContext context; + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->CloseDoor(&context, request, &closeDoorResult); + if (status.ok()) + return closeDoorResult.act_success(); + else + return false; +} + +bool Communication::SkipWindow(int64_t playerID) +{ + protobuf::BoolRes skipWindowResult; + ClientContext context; + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->SkipWindow(&context, request, &skipWindowResult); + if (status.ok()) + return skipWindowResult.act_success(); + else + return false; +} + +bool Communication::StartOpenGate(int64_t playerID) +{ + protobuf::BoolRes startOpenGateResult; + ClientContext context; + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->StartOpenGate(&context, request, &startOpenGateResult); + if (status.ok()) + return startOpenGateResult.act_success(); + else + return false; +} + +bool Communication::StartOpenChest(int64_t playerID) +{ + protobuf::BoolRes startOpenChestResult; + ClientContext context; + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->StartOpenChest(&context, request, &startOpenChestResult); + if (status.ok()) + return startOpenChestResult.act_success(); + else + return false; +} + +bool Communication::EndAllAction(int64_t playerID) +{ + protobuf::BoolRes endAllActionResult; + ClientContext context; + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->EndAllAction(&context, request, &endAllActionResult); + if (status.ok()) + return endAllActionResult.act_success(); + else + return false; +} + bool Communication::Graduate(int64_t playerID) { protobuf::BoolRes graduateResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); auto status = THUAI6Stub->Graduate(&context, request, &graduateResult); if (status.ok()) return graduateResult.act_success(); @@ -91,7 +163,7 @@ bool Communication::StartLearning(int64_t playerID) { protobuf::BoolRes startLearningResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); auto status = THUAI6Stub->StartLearning(&context, request, &startLearningResult); if (status.ok()) return startLearningResult.act_success(); @@ -99,38 +171,38 @@ bool Communication::StartLearning(int64_t playerID) return false; } -bool Communication::StartHelpMate(int64_t playerID) +bool Communication::StartRescueMate(int64_t playerID) { protobuf::BoolRes saveStudentResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); - auto status = THUAI6Stub->StartHelpMate(&context, request, &saveStudentResult); + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->StartRescueMate(&context, request, &saveStudentResult); if (status.ok()) return saveStudentResult.act_success(); else return false; } -bool Communication::StartHealMate(int64_t playerID) +bool Communication::StartTreatMate(int64_t playerID) { protobuf::BoolRes healStudentResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); - auto status = THUAI6Stub->StartHealMate(&context, request, &healStudentResult); + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); + auto status = THUAI6Stub->StartTreatMate(&context, request, &healStudentResult); if (status.ok()) return healStudentResult.act_success(); else return false; } -bool Communication::Trick(double angle, int64_t playerID) +bool Communication::Attack(double angle, int64_t playerID) { - protobuf::BoolRes trickResult; + protobuf::BoolRes attackResult; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufTrick(angle, playerID); - auto status = THUAI6Stub->Trick(&context, request, &trickResult); + auto request = THUAI62Proto::THUAI62ProtobufAttack(angle, playerID, playerType); + auto status = THUAI6Stub->Attack(&context, request, &attackResult); if (status.ok()) - return trickResult.act_success(); + return attackResult.act_success(); else return false; } @@ -139,7 +211,7 @@ bool Communication::TryConnection(int64_t playerID) { protobuf::BoolRes reply; ClientContext context; - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); auto status = THUAI6Stub->TryConnection(&context, request, &reply); if (status.ok()) { @@ -173,7 +245,7 @@ void Communication::ReadMessage(int64_t playerID) { auto tRead = [=]() { - auto request = THUAI62Proto::THUAI62ProtobufID(playerID); + auto request = THUAI62Proto::THUAI62ProtobufID(playerID, playerType); ClientContext context; protobuf::MsgRes messageReceived; auto reader = THUAI6Stub->GetMessage(&context, request); @@ -185,11 +257,12 @@ void Communication::ReadMessage(int64_t playerID) std::thread(tRead).detach(); } -void Communication::AddPlayer(int64_t playerID, THUAI6::PlayerType playerType, THUAI6::StudentType studentType, THUAI6::TrickerType trickerType) +void Communication::AddPlayer(int64_t playerID, THUAI6::PlayerType playerType_, THUAI6::StudentType studentType, THUAI6::TrickerType trickerType) { + playerType = playerType_; auto tMessage = [=]() { - protobuf::PlayerMsg playerMsg = THUAI62Proto::THUAI62ProtobufPlayer(playerID, playerType, studentType, trickerType); + protobuf::PlayerMsg playerMsg = THUAI62Proto::THUAI62ProtobufPlayer(playerID, playerType_, studentType, trickerType); grpc::ClientContext context; auto MessageReader = THUAI6Stub->AddPlayer(&context, playerMsg); diff --git a/CAPI/API/src/DebugAPI.cpp b/CAPI/cpp/API/src/DebugAPI.cpp similarity index 77% rename from CAPI/API/src/DebugAPI.cpp rename to CAPI/cpp/API/src/DebugAPI.cpp index 973df03..6995a17 100644 --- a/CAPI/API/src/DebugAPI.cpp +++ b/CAPI/cpp/API/src/DebugAPI.cpp @@ -156,11 +156,11 @@ std::future StudentDebugAPI::PickProp(THUAI6::PropType prop) return result; }); } -std::future StudentDebugAPI::UseProp() +std::future StudentDebugAPI::UseProp(THUAI6::PropType prop) { - logger->info("UseProp: called at {}ms", Time::TimeSinceStart(startPoint)); + logger->info("UseProp: prop={}, called at {}ms", THUAI6::propTypeDict[prop], Time::TimeSinceStart(startPoint)); return std::async(std::launch::async, [=]() - { auto result = logic.UseProp(); + { auto result = logic.UseProp(prop); if (!result) logger->warn("UseProp: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); @@ -176,31 +176,31 @@ std::future TrickerDebugAPI::PickProp(THUAI6::PropType prop) return result; }); } -std::future TrickerDebugAPI::UseProp() +std::future TrickerDebugAPI::UseProp(THUAI6::PropType prop) { - logger->info("UseProp: called at {}ms", Time::TimeSinceStart(startPoint)); - return std::async(std::launch::async, [this]() - { auto result = logic.UseProp(); + logger->info("UseProp: prop={}, called at {}ms", THUAI6::propTypeDict[prop], Time::TimeSinceStart(startPoint)); + return std::async(std::launch::async, [=]() + { auto result = logic.UseProp(prop); if (!result) logger->warn("UseProp: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); } -std::future StudentDebugAPI::UseSkill() +std::future StudentDebugAPI::UseSkill(int32_t skillID) { - logger->info("UseSkill: called at {}ms", Time::TimeSinceStart(startPoint)); - return std::async(std::launch::async, [this]() - { auto result = logic.UseSkill(); + logger->info("UseSkill: skillID={}, called at {}ms", skillID, Time::TimeSinceStart(startPoint)); + return std::async(std::launch::async, [=]() + { auto result = logic.UseSkill(skillID); if (!result) logger->warn("UseSkill: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); } -std::future TrickerDebugAPI::UseSkill() +std::future TrickerDebugAPI::UseSkill(int32_t skillID) { - logger->info("UseSkill: called at {}ms", Time::TimeSinceStart(startPoint)); - return std::async(std::launch::async, [this]() - { auto result = logic.UseSkill(); + logger->info("UseSkill: skillID={}, called at {}ms", skillID, Time::TimeSinceStart(startPoint)); + return std::async(std::launch::async, [=]() + { auto result = logic.UseSkill(skillID); if (!result) logger->warn("UseSkill: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); @@ -358,23 +358,23 @@ std::future StudentDebugAPI::StartLearning() return result; }); } -std::future StudentDebugAPI::StartHelpMate() +std::future StudentDebugAPI::StartRescueMate() { - logger->info("StartHelpMate: called at {}ms", Time::TimeSinceStart(startPoint)); + logger->info("StartRescueMate: called at {}ms", Time::TimeSinceStart(startPoint)); return std::async(std::launch::async, [this]() - { auto result = logic.StartHelpMate(); + { auto result = logic.StartRescueMate(); if (!result) - logger->warn("StartHelpMate: failed at {}ms", Time::TimeSinceStart(startPoint)); + logger->warn("StartRescueMate: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); } -std::future StudentDebugAPI::StartHealMate() +std::future StudentDebugAPI::StartTreatMate() { - logger->info("StartHealMate: called at {}ms", Time::TimeSinceStart(startPoint)); + logger->info("StartTreatMate: called at {}ms", Time::TimeSinceStart(startPoint)); return std::async(std::launch::async, [this]() - { auto result = logic.StartHealMate(); + { auto result = logic.StartTreatMate(); if (!result) - logger->warn("StartHealMate: failed at {}ms", Time::TimeSinceStart(startPoint)); + logger->warn("StartTreatMate: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); } @@ -393,13 +393,13 @@ std::shared_ptr StudentDebugAPI::GetSelfInfo() const return logic.StudentGetSelfInfo(); } -std::future TrickerDebugAPI::Trick(double angleInRadian) +std::future TrickerDebugAPI::Attack(double angleInRadian) { - logger->info("Trick: angleInRadian = {}, called at {}ms", angleInRadian, Time::TimeSinceStart(startPoint)); + logger->info("Attack: angleInRadian = {}, called at {}ms", angleInRadian, Time::TimeSinceStart(startPoint)); return std::async(std::launch::async, [=]() - { auto result = logic.Trick(angleInRadian); + { auto result = logic.Attack(angleInRadian); if (!result) - logger->warn("Trick: failed at {}ms", Time::TimeSinceStart(startPoint)); + logger->warn("Attack: failed at {}ms", Time::TimeSinceStart(startPoint)); return result; }); } @@ -414,12 +414,16 @@ void StudentDebugAPI::PrintStudent() const { logger->info("******Student Info******"); logger->info("playerID={}, GUID={}, x={}, y={}", student->playerID, student->guid, student->x, student->y); - logger->info("speed={}, view range={}, skill time={}, prop={}, place={}", student->speed, student->viewRange, student->timeUntilSkillAvailable, THUAI6::propTypeDict[student->prop], THUAI6::placeTypeDict[student->place]); - logger->info("state={}, determination={}, fail num={}, fail time={}, emo time={}", THUAI6::studentStateDict[student->state], student->determination, student->failNum, student->failTime, student->emoTime); + logger->info("speed={}, view range={}, damage={}, skill time={}, place={}", student->speed, student->viewRange, student->damage, student->timeUntilSkillAvailable, THUAI6::placeTypeDict[student->place]); + logger->info("state={}, determination={}, fail num={}, fail time={}, emo time={}", THUAI6::playerStateDict[student->playerState], student->determination, student->failNum, student->failTime, student->emoTime); std::string studentBuff = "buff="; + std::string studentProp = "prop="; for (auto buff : student->buff) studentBuff += THUAI6::studentBuffDict[buff] + ", "; + for (auto prop : student->props) + studentProp += THUAI6::propTypeDict[prop] + ", "; logger->info(studentBuff); + logger->info(studentProp); logger->info("**********************"); } } @@ -430,12 +434,16 @@ void TrickerDebugAPI::PrintStudent() const { logger->info("******Student Info******"); logger->info("playerID={}, GUID={}, x={}, y={}", student->playerID, student->guid, student->x, student->y); - logger->info("speed={}, view range={}, skill time={}, prop={}, place={}", student->speed, student->viewRange, student->timeUntilSkillAvailable, THUAI6::propTypeDict[student->prop], THUAI6::placeTypeDict[student->place]); - logger->info("state={}, determination={}, fail num={}, fail time={}, emo time={}", THUAI6::studentStateDict[student->state], student->determination, student->failNum, student->failTime, student->emoTime); + logger->info("speed={}, view range={}, damage={}, skill time={}, place={}", student->speed, student->viewRange, student->damage, student->timeUntilSkillAvailable, THUAI6::placeTypeDict[student->place]); + logger->info("state={}, determination={}, fail num={}, fail time={}, emo time={}", THUAI6::playerStateDict[student->playerState], student->determination, student->failNum, student->failTime, student->emoTime); std::string studentBuff = "buff="; + std::string studentProp = "prop="; for (auto buff : student->buff) studentBuff += THUAI6::studentBuffDict[buff] + ", "; + for (auto prop : student->props) + studentProp += THUAI6::propTypeDict[prop] + ", "; logger->info(studentBuff); + logger->info(studentProp); logger->info("**********************"); } } @@ -446,12 +454,16 @@ void StudentDebugAPI::PrintTricker() const { logger->info("******Tricker Info******"); logger->info("playerID={}, GUID={}, x={}, y={}", tricker->playerID, tricker->guid, tricker->x, tricker->y); - logger->info("speed={}, view range={}, skill time={}, prop={}, place={}", tricker->speed, tricker->viewRange, tricker->timeUntilSkillAvailable, THUAI6::propTypeDict[tricker->prop], THUAI6::placeTypeDict[tricker->place]); - logger->info("damage={}, movable={}", tricker->damage, tricker->movable); + logger->info("speed={}, view range={}, skill time={}, place={}", tricker->speed, tricker->viewRange, tricker->timeUntilSkillAvailable, THUAI6::placeTypeDict[tricker->place]); + logger->info("damage={}, state={}", tricker->damage, THUAI6::playerStateDict[tricker->playerState]); std::string trickerBuff = "buff="; for (auto buff : tricker->buff) trickerBuff += THUAI6::trickerBuffDict[buff] + ", "; logger->info(trickerBuff); + std::string trickerProp = "prop="; + for (auto prop : tricker->props) + trickerProp += THUAI6::propTypeDict[prop] + ", "; + logger->info(trickerProp); logger->info("************************"); } } @@ -462,12 +474,16 @@ void TrickerDebugAPI::PrintTricker() const { logger->info("******Tricker Info******"); logger->info("playerID={}, GUID={}, x={}, y={}", tricker->playerID, tricker->guid, tricker->x, tricker->y); - logger->info("speed={}, view range={}, skill time={}, prop={}, place={}", tricker->speed, tricker->viewRange, tricker->timeUntilSkillAvailable, THUAI6::propTypeDict[tricker->prop], THUAI6::placeTypeDict[tricker->place]); - logger->info("damage={}, movable={}", tricker->damage, tricker->movable); + logger->info("speed={}, view range={}, skill time={}, place={}", tricker->speed, tricker->viewRange, tricker->timeUntilSkillAvailable, THUAI6::placeTypeDict[tricker->place]); + logger->info("damage={}, state={}", tricker->damage, THUAI6::playerStateDict[tricker->playerState]); std::string trickerBuff = "buff="; for (auto buff : tricker->buff) trickerBuff += THUAI6::trickerBuffDict[buff] + ", "; logger->info(trickerBuff); + std::string trickerProp = "prop="; + for (auto prop : tricker->props) + trickerProp += THUAI6::propTypeDict[prop] + ", "; + logger->info(trickerProp); logger->info("************************"); } } @@ -497,12 +513,16 @@ void StudentDebugAPI::PrintSelfInfo() const auto self = logic.StudentGetSelfInfo(); logger->info("******Self Info******"); logger->info("playerID={}, GUID={}, x={}, y={}", self->playerID, self->guid, self->x, self->y); - logger->info("speed={}, view range={}, skill time={}, prop={}, place={}", self->speed, self->viewRange, self->timeUntilSkillAvailable, THUAI6::propTypeDict[self->prop], THUAI6::placeTypeDict[self->place]); - logger->info("state={}, determination={}, fail num={}, fail time={}, emo time={}", THUAI6::studentStateDict[self->state], self->determination, self->failNum, self->failTime, self->emoTime); + logger->info("speed={}, view range={}, damage={}, skill time={}, place={}", self->speed, self->viewRange, self->damage, self->timeUntilSkillAvailable, THUAI6::placeTypeDict[self->place]); + logger->info("state={}, determination={}, fail num={}, fail time={}, emo time={}", THUAI6::playerStateDict[self->playerState], self->determination, self->failNum, self->failTime, self->emoTime); std::string studentBuff = "buff="; for (auto buff : self->buff) studentBuff += THUAI6::studentBuffDict[buff] + ", "; logger->info(studentBuff); + std::string studentProp = "prop="; + for (auto prop : self->props) + studentProp += THUAI6::propTypeDict[prop] + ", "; + logger->info(studentProp); logger->info("*********************"); } @@ -511,12 +531,16 @@ void TrickerDebugAPI::PrintSelfInfo() const auto self = logic.TrickerGetSelfInfo(); logger->info("******Self Info******"); logger->info("playerID={}, GUID={}, x={}, y={}", self->playerID, self->guid, self->x, self->y); - logger->info("speed={}, view range={}, skill time={}, prop={}, place={}", self->speed, self->viewRange, self->timeUntilSkillAvailable, THUAI6::propTypeDict[self->prop], THUAI6::placeTypeDict[self->place]); - logger->info("damage={}, movable={}", self->damage, self->movable); + logger->info("speed={}, view range={}, skill time={}, place={}", self->speed, self->viewRange, self->timeUntilSkillAvailable, THUAI6::placeTypeDict[self->place]); + logger->info("damage={}, state={}", self->damage, THUAI6::playerStateDict[self->playerState]); std::string trickerBuff = "buff="; for (auto buff : self->buff) trickerBuff += THUAI6::trickerBuffDict[buff] + ", "; logger->info(trickerBuff); + std::string trickerProp = "prop="; + for (auto prop : self->props) + trickerProp += THUAI6::propTypeDict[prop] + ", "; + logger->info(trickerProp); logger->info("*********************"); } diff --git a/CAPI/API/src/logic.cpp b/CAPI/cpp/API/src/logic.cpp similarity index 67% rename from CAPI/API/src/logic.cpp rename to CAPI/cpp/API/src/logic.cpp index b4b0742..8715d1e 100644 --- a/CAPI/API/src/logic.cpp +++ b/CAPI/cpp/API/src/logic.cpp @@ -65,14 +65,14 @@ std::vector> Logic::GetFullMap() const { std::unique_lock lock(mtxState); logger->debug("Called GetFullMap"); - return currentState->gamemap; + return currentState->gameMap->gameMap; } THUAI6::PlaceType Logic::GetPlaceType(int32_t CellX, int32_t CellY) const { std::unique_lock lock(mtxState); logger->debug("Called GetPlaceType"); - return currentState->gamemap[CellX][CellY]; + return currentState->gameMap->gameMap[CellX][CellY]; } bool Logic::Move(int64_t time, double angle) @@ -87,16 +87,16 @@ bool Logic::PickProp(THUAI6::PropType prop) return pComm->PickProp(prop, playerID); } -bool Logic::UseProp() +bool Logic::UseProp(THUAI6::PropType prop) { logger->debug("Called UseProp"); - return pComm->UseProp(playerID); + return pComm->UseProp(prop, playerID); } -bool Logic::UseSkill() +bool Logic::UseSkill(int32_t skill) { logger->debug("Called UseSkill"); - return pComm->UseSkill(playerID); + return pComm->UseSkill(skill, playerID); } bool Logic::SendMessage(int64_t toID, std::string message) @@ -129,22 +129,22 @@ bool Logic::StartLearning() return pComm->StartLearning(playerID); } -bool Logic::StartHelpMate() +bool Logic::StartTreatMate() { - logger->debug("Called StartHelpMate"); - return pComm->StartHelpMate(playerID); + logger->debug("Called StartTreatMate"); + return pComm->StartTreatMate(playerID); } -bool Logic::StartHealMate() +bool Logic::StartRescueMate() { - logger->debug("Called StartHealMate"); - return pComm->StartHealMate(playerID); + logger->debug("Called StartRescueMate"); + return pComm->StartRescueMate(playerID); } -bool Logic::Trick(double angle) +bool Logic::Attack(double angle) { - logger->debug("Called Trick"); - return pComm->Trick(angle, playerID); + logger->debug("Called Attack"); + return pComm->Attack(angle, playerID); } bool Logic::WaitThread() @@ -171,12 +171,14 @@ void Logic::ProcessMessage() case THUAI6::GameState::GameStart: logger->info("Game Start!"); - // 重新读取玩家的guid，guid确保人类在前屠夫在后 + // 重新读取玩家的guid，保证人类在前屠夫在后 playerGUIDs.clear(); - for (auto student : clientMsg.student_message()) - playerGUIDs.push_back(student.guid()); - for (auto tricker : clientMsg.tricker_message()) - playerGUIDs.push_back(tricker.guid()); + for (const auto& obj : clientMsg.obj_message()) + if (Proto2THUAI6::messageOfObjDict[obj.message_of_obj_case()] == THUAI6::MessageOfObj::StudentMessage) + playerGUIDs.push_back(obj.student_message().guid()); + for (const auto& obj : clientMsg.obj_message()) + if (Proto2THUAI6::messageOfObjDict[obj.message_of_obj_case()] == THUAI6::MessageOfObj::TrickerMessage) + playerGUIDs.push_back(obj.tricker_message().guid()); currentState->guids = playerGUIDs; bufferState->guids = playerGUIDs; @@ -189,10 +191,12 @@ void Logic::ProcessMessage() case THUAI6::GameState::GameRunning: // 重新读取玩家的guid，guid确保人类在前屠夫在后 playerGUIDs.clear(); - for (auto student : clientMsg.student_message()) - playerGUIDs.push_back(student.guid()); - for (auto tricker : clientMsg.tricker_message()) - playerGUIDs.push_back(tricker.guid()); + for (const auto& obj : clientMsg.obj_message()) + if (Proto2THUAI6::messageOfObjDict[obj.message_of_obj_case()] == THUAI6::MessageOfObj::StudentMessage) + playerGUIDs.push_back(obj.student_message().guid()); + for (const auto& obj : clientMsg.obj_message()) + if (Proto2THUAI6::messageOfObjDict[obj.message_of_obj_case()] == THUAI6::MessageOfObj::TrickerMessage) + playerGUIDs.push_back(obj.tricker_message().guid()); currentState->guids = playerGUIDs; bufferState->guids = playerGUIDs; @@ -228,60 +232,66 @@ void Logic::LoadBuffer(protobuf::MessageToClient& message) logger->debug("Buffer cleared!"); // 读取新的信息 - bufferState->gamemap = Proto2THUAI6::Protobuf2THUAI6Map(message.map_message()); + bufferState->gameMap = Proto2THUAI6::Protobuf2THUAI6Map(message.map_message()); + bufferState->gameInfo = Proto2THUAI6::Protobuf2THUAI6GameInfo(message.all_message()); if (playerType == THUAI6::PlayerType::StudentPlayer) { - for (const auto& item : message.student_message()) - { - if (item.player_id() == playerID) - { - bufferState->studentSelf = Proto2THUAI6::Protobuf2THUAI6Student(item); - } - bufferState->students.push_back(Proto2THUAI6::Protobuf2THUAI6Student(item)); - logger->debug("Add Student!"); - } - for (const auto& item : message.tricker_message()) - { - if (AssistFunction::HaveView(bufferState->studentSelf->viewRange, bufferState->studentSelf->x, bufferState->studentSelf->y, item.x(), item.y(), bufferState->studentSelf->place, Proto2THUAI6::placeTypeDict[item.place()], bufferState->gamemap)) + for (const auto& item : message.obj_message()) + if (Proto2THUAI6::messageOfObjDict[item.message_of_obj_case()] == THUAI6::MessageOfObj::StudentMessage) { - bufferState->trickers.push_back(Proto2THUAI6::Protobuf2THUAI6Tricker(item)); - logger->debug("Add Tricker!"); + if (item.student_message().player_id() == playerID) + { + bufferState->studentSelf = Proto2THUAI6::Protobuf2THUAI6Student(item.student_message()); + } + bufferState->students.push_back(Proto2THUAI6::Protobuf2THUAI6Student(item.student_message())); + logger->debug("Add Student!"); } - } + for (const auto& item : message.obj_message()) + if (Proto2THUAI6::messageOfObjDict[item.message_of_obj_case()] == THUAI6::MessageOfObj::TrickerMessage) + if (AssistFunction::HaveView(bufferState->studentSelf->viewRange, bufferState->studentSelf->x, bufferState->studentSelf->y, item.tricker_message().x(), item.tricker_message().y(), bufferState->studentSelf->place, Proto2THUAI6::placeTypeDict[item.tricker_message().place()], bufferState->gameMap->gameMap)) + { + bufferState->trickers.push_back(Proto2THUAI6::Protobuf2THUAI6Tricker(item.tricker_message())); + logger->debug("Add Tricker!"); + } } else { - for (const auto& item : message.tricker_message()) + for (const auto& item : message.obj_message()) { - if (item.player_id() == playerID) + if (Proto2THUAI6::messageOfObjDict[item.message_of_obj_case()] == THUAI6::MessageOfObj::TrickerMessage) { - bufferState->trickerSelf = Proto2THUAI6::Protobuf2THUAI6Tricker(item); + if (item.tricker_message().player_id() == playerID) + { + bufferState->trickerSelf = Proto2THUAI6::Protobuf2THUAI6Tricker(item.tricker_message()); + } + bufferState->trickers.push_back(Proto2THUAI6::Protobuf2THUAI6Tricker(item.tricker_message())); + logger->debug("Add Tricker!"); } - bufferState->trickers.push_back(Proto2THUAI6::Protobuf2THUAI6Tricker(item)); - logger->debug("Add Tricker!"); } - for (const auto& item : message.student_message()) - if (AssistFunction::HaveView(bufferState->trickerSelf->viewRange, bufferState->trickerSelf->x, bufferState->trickerSelf->y, item.x(), item.y(), bufferState->trickerSelf->place, Proto2THUAI6::placeTypeDict[item.place()], bufferState->gamemap)) - { - bufferState->students.push_back(Proto2THUAI6::Protobuf2THUAI6Student(item)); - logger->debug("Add Student!"); - } - } - for (const auto& item : message.prop_message()) - { - bufferState->props.push_back(Proto2THUAI6::Protobuf2THUAI6Prop(item)); - logger->debug("Add Prop!"); - } - for (const auto& item : message.bullet_message()) - { - bufferState->bullets.push_back(Proto2THUAI6::Protobuf2THUAI6Bullet(item)); - logger->debug("Add Bullet!"); - } - for (const auto& item : message.bombed_bullet_message()) - { - bufferState->bombedBullets.push_back(Proto2THUAI6::Protobuf2THUAI6BombedBullet(item)); - logger->debug("Add BombedBullet!"); + for (const auto& item : message.obj_message()) + if (Proto2THUAI6::messageOfObjDict[item.message_of_obj_case()] == THUAI6::MessageOfObj::StudentMessage) + if (AssistFunction::HaveView(bufferState->trickerSelf->viewRange, bufferState->trickerSelf->x, bufferState->trickerSelf->y, item.student_message().x(), item.student_message().y(), bufferState->trickerSelf->place, Proto2THUAI6::placeTypeDict[item.student_message().place()], bufferState->gameMap->gameMap)) + { + bufferState->students.push_back(Proto2THUAI6::Protobuf2THUAI6Student(item.student_message())); + logger->debug("Add Student!"); + } } + for (const auto& item : message.obj_message()) + switch (Proto2THUAI6::messageOfObjDict[item.message_of_obj_case()]) + { + case THUAI6::MessageOfObj::PropMessage: + bufferState->props.push_back(Proto2THUAI6::Protobuf2THUAI6Prop(item.prop_message())); + logger->debug("Add Prop!"); + break; + case THUAI6::MessageOfObj::BulletMessage: + bufferState->bullets.push_back(Proto2THUAI6::Protobuf2THUAI6Bullet(item.bullet_message())); + logger->debug("Add Bullet!"); + break; + case THUAI6::MessageOfObj::BombedBulletMessage: + bufferState->bombedBullets.push_back(Proto2THUAI6::Protobuf2THUAI6BombedBullet(item.bombed_bullet_message())); + logger->debug("Add BombedBullet!"); + break; + } if (asynchronous) { { diff --git a/CAPI/API/src/main.cpp b/CAPI/cpp/API/src/main.cpp similarity index 100% rename from CAPI/API/src/main.cpp rename to CAPI/cpp/API/src/main.cpp diff --git a/CAPI/CAPI.sln b/CAPI/cpp/CAPI.sln similarity index 100% rename from CAPI/CAPI.sln rename to CAPI/cpp/CAPI.sln diff --git a/CAPI/CMakeLists.txt b/CAPI/cpp/CMakeLists.txt similarity index 100% rename from CAPI/CMakeLists.txt rename to CAPI/cpp/CMakeLists.txt diff --git a/CAPI/cpp/Develop Progress.md b/CAPI/cpp/Develop Progress.md new file mode 100644 index 0000000..6b5988f --- /dev/null +++ b/CAPI/cpp/Develop Progress.md @@ -0,0 +1 @@ +更改规则后代码能够编译，但是有较多功能没有实现，例如新加的几个函数；同时，Debug模式的输出也有了较大差异，因此之后需要进行一定的重构。 \ No newline at end of file diff --git a/CAPI/README.md b/CAPI/cpp/README.md similarity index 100% rename from CAPI/README.md rename to CAPI/cpp/README.md diff --git a/CAPI/proto/Message2Clients.pb.cc b/CAPI/cpp/proto/Message2Clients.pb.cc similarity index 57% rename from CAPI/proto/Message2Clients.pb.cc rename to CAPI/cpp/proto/Message2Clients.pb.cc index 018054d..9506680 100644 --- a/CAPI/proto/Message2Clients.pb.cc +++ b/CAPI/cpp/proto/Message2Clients.pb.cc @@ -26,7 +26,7 @@ namespace protobuf ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.buff_)*/ {}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.speed_)*/ 0, /*decltype(_impl_.determination_)*/ 0, /*decltype(_impl_.time_until_skill_available_)*/ 0, /*decltype(_impl_.fail_num_)*/ 0, /*decltype(_impl_.place_)*/ 0, /*decltype(_impl_.prop_)*/ 0, /*decltype(_impl_.student_type_)*/ 0, /*decltype(_impl_.guid_)*/ int64_t{0}, /*decltype(_impl_.fail_time_)*/ 0, /*decltype(_impl_.state_)*/ 0, /*decltype(_impl_.view_range_)*/ 0, /*decltype(_impl_.emo_time_)*/ 0, /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.radius_)*/ 0, /*decltype(_impl_.damage_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.prop_)*/ {}, /*decltype(_impl_._prop_cached_byte_size_)*/ {0}, /*decltype(_impl_.buff_)*/ {}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.speed_)*/ 0, /*decltype(_impl_.determination_)*/ 0, /*decltype(_impl_.time_until_skill_available_)*/ 0, /*decltype(_impl_.fail_num_)*/ 0, /*decltype(_impl_.place_)*/ 0, /*decltype(_impl_.guid_)*/ int64_t{0}, /*decltype(_impl_.player_state_)*/ 0, /*decltype(_impl_.state_)*/ 0, /*decltype(_impl_.fail_time_)*/ 0, /*decltype(_impl_.emo_time_)*/ 0, /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.view_range_)*/ 0, /*decltype(_impl_.radius_)*/ 0, /*decltype(_impl_.danger_alert_)*/ 0, /*decltype(_impl_.damage_)*/ 0, /*decltype(_impl_.score_)*/ 0, /*decltype(_impl_.treat_progress_)*/ 0, /*decltype(_impl_.rescue_progress_)*/ 0, /*decltype(_impl_.student_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } struct MessageOfStudentDefaultTypeInternal @@ -48,7 +48,7 @@ namespace protobuf ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.buff_)*/ {}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.speed_)*/ 0, /*decltype(_impl_.damage_)*/ 0, /*decltype(_impl_.time_until_skill_available_)*/ 0, /*decltype(_impl_.place_)*/ 0, /*decltype(_impl_.prop_)*/ 0, /*decltype(_impl_.guid_)*/ int64_t{0}, /*decltype(_impl_.tricker_type_)*/ 0, /*decltype(_impl_.movable_)*/ false, /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.view_range_)*/ 0, /*decltype(_impl_.radius_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.prop_)*/ {}, /*decltype(_impl_._prop_cached_byte_size_)*/ {0}, /*decltype(_impl_.buff_)*/ {}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.speed_)*/ 0, /*decltype(_impl_.damage_)*/ 0, /*decltype(_impl_.time_until_skill_available_)*/ 0, /*decltype(_impl_.place_)*/ 0, /*decltype(_impl_.tricker_type_)*/ 0, /*decltype(_impl_.guid_)*/ int64_t{0}, /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.movable_)*/ false, /*decltype(_impl_.view_range_)*/ 0, /*decltype(_impl_.radius_)*/ 0, /*decltype(_impl_.player_state_)*/ 0, /*decltype(_impl_.trick_desire_)*/ 0, /*decltype(_impl_.class_volume_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } struct MessageOfTrickerDefaultTypeInternal @@ -154,6 +154,116 @@ namespace protobuf }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfPickedPropDefaultTypeInternal _MessageOfPickedProp_default_instance_; + PROTOBUF_CONSTEXPR MessageOfClassroom::MessageOfClassroom( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.progress_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + { + } + struct MessageOfClassroomDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfClassroomDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfClassroomDefaultTypeInternal() + { + } + union + { + MessageOfClassroom _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfClassroomDefaultTypeInternal _MessageOfClassroom_default_instance_; + PROTOBUF_CONSTEXPR MessageOfGate::MessageOfGate( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.progress_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + { + } + struct MessageOfGateDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfGateDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfGateDefaultTypeInternal() + { + } + union + { + MessageOfGate _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfGateDefaultTypeInternal _MessageOfGate_default_instance_; + PROTOBUF_CONSTEXPR MessageOfDoor::MessageOfDoor( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.is_open_)*/ false, /*decltype(_impl_._cached_size_)*/ {}} + { + } + struct MessageOfDoorDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfDoorDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfDoorDefaultTypeInternal() + { + } + union + { + MessageOfDoor _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfDoorDefaultTypeInternal _MessageOfDoor_default_instance_; + PROTOBUF_CONSTEXPR MessageOfChest::MessageOfChest( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.x_)*/ 0, /*decltype(_impl_.y_)*/ 0, /*decltype(_impl_.progress_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + { + } + struct MessageOfChestDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfChestDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfChestDefaultTypeInternal() + { + } + union + { + MessageOfChest _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfChestDefaultTypeInternal _MessageOfChest_default_instance_; + PROTOBUF_CONSTEXPR MessageOfMapObj::MessageOfMapObj( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.message_of_map_obj_)*/ {}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_._oneof_case_)*/ {}} + { + } + struct MessageOfMapObjDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfMapObjDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfMapObjDefaultTypeInternal() + { + } + union + { + MessageOfMapObj _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfMapObjDefaultTypeInternal _MessageOfMapObj_default_instance_; PROTOBUF_CONSTEXPR MessageOfMap_Row::MessageOfMap_Row( ::_pbi::ConstantInitialized ) : @@ -180,7 +290,7 @@ namespace protobuf ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.row_)*/ {}, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.row_)*/ {}, /*decltype(_impl_.map_obj_message_)*/ {}, /*decltype(_impl_._cached_size_)*/ {}} { } struct MessageOfMapDefaultTypeInternal @@ -198,11 +308,55 @@ namespace protobuf }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfMapDefaultTypeInternal _MessageOfMap_default_instance_; + PROTOBUF_CONSTEXPR MessageOfObj::MessageOfObj( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.message_of_obj_)*/ {}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_._oneof_case_)*/ {}} + { + } + struct MessageOfObjDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfObjDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfObjDefaultTypeInternal() + { + } + union + { + MessageOfObj _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfObjDefaultTypeInternal _MessageOfObj_default_instance_; + PROTOBUF_CONSTEXPR MessageOfAll::MessageOfAll( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.game_time_)*/ 0, /*decltype(_impl_.subject_left_)*/ 0, /*decltype(_impl_.student_graduated_)*/ 0, /*decltype(_impl_.student_quited_)*/ 0, /*decltype(_impl_.student_score_)*/ 0, /*decltype(_impl_.tricker_score_)*/ 0, /*decltype(_impl_.gate_opened_)*/ false, /*decltype(_impl_.hidden_gate_refreshed_)*/ false, /*decltype(_impl_.hidden_gate_opened_)*/ false, /*decltype(_impl_._cached_size_)*/ {}} + { + } + struct MessageOfAllDefaultTypeInternal + { + PROTOBUF_CONSTEXPR MessageOfAllDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~MessageOfAllDefaultTypeInternal() + { + } + union + { + MessageOfAll _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageOfAllDefaultTypeInternal _MessageOfAll_default_instance_; PROTOBUF_CONSTEXPR MessageToClient::MessageToClient( ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.student_message_)*/ {}, /*decltype(_impl_.tricker_message_)*/ {}, /*decltype(_impl_.prop_message_)*/ {}, /*decltype(_impl_.bullet_message_)*/ {}, /*decltype(_impl_.bombed_bullet_message_)*/ {}, /*decltype(_impl_.map_message_)*/ nullptr, /*decltype(_impl_.game_state_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.obj_message_)*/ {}, /*decltype(_impl_.map_message_)*/ nullptr, /*decltype(_impl_.all_message_)*/ nullptr, /*decltype(_impl_.game_state_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } struct MessageToClientDefaultTypeInternal @@ -287,7 +441,7 @@ namespace protobuf }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgResDefaultTypeInternal _MsgRes_default_instance_; } // namespace protobuf -static ::_pb::Metadata file_level_metadata_Message2Clients_2eproto[12]; +static ::_pb::Metadata file_level_metadata_Message2Clients_2eproto[19]; static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_Message2Clients_2eproto = nullptr; static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_Message2Clients_2eproto = nullptr; @@ -306,7 +460,7 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.time_until_skill_available_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.place_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.prop_), - PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.student_type_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.player_state_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.guid_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.state_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.fail_time_), @@ -315,6 +469,11 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.view_range_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.radius_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.damage_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.danger_alert_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.score_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.treat_progress_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.rescue_progress_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.student_type_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfStudent, _impl_.buff_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _internal_metadata_), @@ -335,6 +494,9 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.player_id_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.view_range_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.radius_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.player_state_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.trick_desire_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.class_volume_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfTricker, _impl_.buff_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfBullet, _internal_metadata_), @@ -388,6 +550,53 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfPickedProp, _impl_.facing_direction_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfPickedProp, _impl_.mapping_id_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfClassroom, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfClassroom, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfClassroom, _impl_.y_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfClassroom, _impl_.progress_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfGate, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfGate, _impl_.y_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfGate, _impl_.progress_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfDoor, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfDoor, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfDoor, _impl_.y_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfDoor, _impl_.is_open_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfChest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfChest, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfChest, _impl_.y_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfChest, _impl_.progress_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfMapObj, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfMapObj, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfMapObj, _impl_.message_of_map_obj_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfMap_Row, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -401,19 +610,44 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfMap, _impl_.row_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfMap, _impl_.map_obj_message_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfObj, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfObj, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfObj, _impl_.message_of_obj_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.game_time_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.subject_left_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.student_graduated_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.student_quited_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.student_score_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.tricker_score_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.gate_opened_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.hidden_gate_refreshed_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageOfAll, _impl_.hidden_gate_opened_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.student_message_), - PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.tricker_message_), - PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.prop_message_), - PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.bullet_message_), - PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.bombed_bullet_message_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.obj_message_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.map_message_), PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.game_state_), + PROTOBUF_FIELD_OFFSET(::protobuf::MessageToClient, _impl_.all_message_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::MoveRes, _internal_metadata_), ~0u, // no _extensions_ @@ -442,17 +676,24 @@ const uint32_t TableStruct_Message2Clients_2eproto::offsets[] PROTOBUF_SECTION_V }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::protobuf::MessageOfStudent)}, - {24, -1, -1, sizeof(::protobuf::MessageOfTricker)}, - {44, -1, -1, sizeof(::protobuf::MessageOfBullet)}, - {58, -1, -1, sizeof(::protobuf::MessageOfBombedBullet)}, - {70, -1, -1, sizeof(::protobuf::MessageOfProp)}, - {84, -1, -1, sizeof(::protobuf::MessageOfPickedProp)}, - {95, -1, -1, sizeof(::protobuf::MessageOfMap_Row)}, - {102, -1, -1, sizeof(::protobuf::MessageOfMap)}, - {109, -1, -1, sizeof(::protobuf::MessageToClient)}, - {122, -1, -1, sizeof(::protobuf::MoveRes)}, - {131, -1, -1, sizeof(::protobuf::BoolRes)}, - {138, -1, -1, sizeof(::protobuf::MsgRes)}, + {29, -1, -1, sizeof(::protobuf::MessageOfTricker)}, + {52, -1, -1, sizeof(::protobuf::MessageOfBullet)}, + {66, -1, -1, sizeof(::protobuf::MessageOfBombedBullet)}, + {78, -1, -1, sizeof(::protobuf::MessageOfProp)}, + {92, -1, -1, sizeof(::protobuf::MessageOfPickedProp)}, + {103, -1, -1, sizeof(::protobuf::MessageOfClassroom)}, + {112, -1, -1, sizeof(::protobuf::MessageOfGate)}, + {121, -1, -1, sizeof(::protobuf::MessageOfDoor)}, + {130, -1, -1, sizeof(::protobuf::MessageOfChest)}, + {139, -1, -1, sizeof(::protobuf::MessageOfMapObj)}, + {150, -1, -1, sizeof(::protobuf::MessageOfMap_Row)}, + {157, -1, -1, sizeof(::protobuf::MessageOfMap)}, + {165, -1, -1, sizeof(::protobuf::MessageOfObj)}, + {177, -1, -1, sizeof(::protobuf::MessageOfAll)}, + {192, -1, -1, sizeof(::protobuf::MessageToClient)}, + {202, -1, -1, sizeof(::protobuf::MoveRes)}, + {211, -1, -1, sizeof(::protobuf::BoolRes)}, + {218, -1, -1, sizeof(::protobuf::MsgRes)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -462,8 +703,15 @@ static const ::_pb::Message* const file_default_instances[] = { &::protobuf::_MessageOfBombedBullet_default_instance_._instance, &::protobuf::_MessageOfProp_default_instance_._instance, &::protobuf::_MessageOfPickedProp_default_instance_._instance, + &::protobuf::_MessageOfClassroom_default_instance_._instance, + &::protobuf::_MessageOfGate_default_instance_._instance, + &::protobuf::_MessageOfDoor_default_instance_._instance, + &::protobuf::_MessageOfChest_default_instance_._instance, + &::protobuf::_MessageOfMapObj_default_instance_._instance, &::protobuf::_MessageOfMap_Row_default_instance_._instance, &::protobuf::_MessageOfMap_default_instance_._instance, + &::protobuf::_MessageOfObj_default_instance_._instance, + &::protobuf::_MessageOfAll_default_instance_._instance, &::protobuf::_MessageToClient_default_instance_._instance, &::protobuf::_MoveRes_default_instance_._instance, &::protobuf::_BoolRes_default_instance_._instance, @@ -472,60 +720,88 @@ static const ::_pb::Message* const file_default_instances[] = { const char descriptor_table_protodef_Message2Clients_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\025Message2Clients.proto\022\010protobuf\032\021Messa" - "geType.proto\"\301\003\n\020MessageOfStudent\022\t\n\001x\030\001" + "geType.proto\"\303\004\n\020MessageOfStudent\022\t\n\001x\030\001" " \001(\005\022\t\n\001y\030\002 \001(\005\022\r\n\005speed\030\003 \001(\005\022\025\n\rdeterm" "ination\030\004 \001(\005\022\020\n\010fail_num\030\005 \001(\005\022\"\n\032time_" "until_skill_available\030\006 \001(\001\022\"\n\005place\030\007 \001" - "(\0162\023.protobuf.PlaceType\022 \n\004prop\030\010 \001(\0162\022." - "protobuf.PropType\022+\n\014student_type\030\t \001(\0162" - "\025.protobuf.StudentType\022\014\n\004guid\030\n \001(\003\022%\n\005" - "state\030\013 \001(\0162\026.protobuf.StudentState\022\021\n\tf" - "ail_time\030\014 \001(\001\022\020\n\010emo_time\030\016 \001(\001\022\021\n\tplay" - "er_id\030\017 \001(\003\022\022\n\nview_range\030\020 \001(\005\022\016\n\006radiu" - "s\030\021 \001(\005\022\016\n\006damage\030\022 \001(\005\022\'\n\004buff\030\023 \003(\0162\031." - "protobuf.StudentBuffType\"\335\002\n\020MessageOfTr" - "icker\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005\022\r\n\005speed\030\003 \001" - "(\005\022\016\n\006damage\030\004 \001(\005\022\"\n\032time_until_skill_a" - "vailable\030\005 \001(\001\022\"\n\005place\030\006 \001(\0162\023.protobuf" - ".PlaceType\022 \n\004prop\030\007 \001(\0162\022.protobuf.Prop" - "Type\022+\n\014tricker_type\030\010 \001(\0162\025.protobuf.Tr" - "ickerType\022\014\n\004guid\030\t \001(\003\022\017\n\007movable\030\n \001(\010" - "\022\021\n\tplayer_id\030\013 \001(\003\022\022\n\nview_range\030\014 \001(\005\022" - "\016\n\006radius\030\r \001(\005\022\'\n\004buff\030\016 \003(\0162\031.protobuf" - ".TrickerBuffType\"\317\001\n\017MessageOfBullet\022\"\n\004" - "type\030\001 \001(\0162\024.protobuf.BulletType\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\004team\030\006 \001(\0162\024.protobuf." - "PlayerType\022\"\n\005place\030\007 \001(\0162\023.protobuf.Pla" - "ceType\022\022\n\nbomb_range\030\010 \001(\001\"\223\001\n\025MessageOf" - "BombedBullet\022\"\n\004type\030\001 \001(\0162\024.protobuf.Bu" - "lletType\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\022\022\n\n" - "bomb_range\030\006 \001(\001\"\264\001\n\rMessageOfProp\022 \n\004ty" - "pe\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\004" - "guid\030\005 \001(\003\022\"\n\005place\030\006 \001(\0162\023.protobuf.Pla" - "ceType\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.p" - "rotobuf.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.prot" - "obuf.MessageOfMap.Row\032\'\n\003Row\022 \n\003col\030\001 \003(" - "\0162\023.protobuf.PlaceType\"\363\002\n\017MessageToClie" - "nt\0223\n\017student_message\030\001 \003(\0132\032.protobuf.M" - "essageOfStudent\0223\n\017tricker_message\030\002 \003(\013" - "2\032.protobuf.MessageOfTricker\022-\n\014prop_mes" - "sage\030\003 \003(\0132\027.protobuf.MessageOfProp\0221\n\016b" - "ullet_message\030\004 \003(\0132\031.protobuf.MessageOf" - "Bullet\022>\n\025bombed_bullet_message\030\005 \003(\0132\037." - "protobuf.MessageOfBombedBullet\022+\n\013map_me" - "ssage\030\006 \001(\0132\026.protobuf.MessageOfMap\022\'\n\ng" - "ame_state\030\007 \001(\0162\023.protobuf.GameState\"J\n\007" - "MoveRes\022\024\n\014actual_speed\030\001 \001(\003\022\024\n\014actual_" - "angle\030\002 \001(\001\022\023\n\013act_success\030\003 \001(\010\"\036\n\007Bool" - "Res\022\023\n\013act_success\030\001 \001(\010\"P\n\006MsgRes\022\024\n\014ha" - "ve_message\030\001 \001(\010\022\026\n\016from_player_id\030\002 \001(\003" - "\022\030\n\020message_received\030\003 \001(\tb\006proto3"; + "(\0162\023.protobuf.PlaceType\022 \n\004prop\030\010 \003(\0162\022." + "protobuf.PropType\022+\n\014player_state\030\t \001(\0162" + "\025.protobuf.PlayerState\022\014\n\004guid\030\n \001(\003\022$\n\005" + "state\030\013 \001(\0162\025.protobuf.PlayerState\022\021\n\tfa" + "il_time\030\014 \001(\001\022\020\n\010emo_time\030\016 \001(\001\022\021\n\tplaye" + "r_id\030\017 \001(\003\022\022\n\nview_range\030\020 \001(\005\022\016\n\006radius" + "\030\021 \001(\005\022\016\n\006damage\030\022 \001(\005\022\024\n\014danger_alert\030\023" + " \001(\001\022\r\n\005score\030\024 \001(\005\022\026\n\016treat_progress\030\025 " + "\001(\005\022\027\n\017rescue_progress\030\026 \001(\005\022+\n\014student_" + "type\030\027 \001(\0162\025.protobuf.StudentType\022\'\n\004buf" + "f\030\030 \003(\0162\031.protobuf.StudentBuffType\"\266\003\n\020M" + "essageOfTricker\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005\022\r\n" + "\005speed\030\003 \001(\005\022\016\n\006damage\030\004 \001(\005\022\"\n\032time_unt" + "il_skill_available\030\005 \001(\001\022\"\n\005place\030\006 \001(\0162" + "\023.protobuf.PlaceType\022 \n\004prop\030\007 \003(\0162\022.pro" + "tobuf.PropType\022+\n\014tricker_type\030\010 \001(\0162\025.p" + "rotobuf.TrickerType\022\014\n\004guid\030\t \001(\003\022\017\n\007mov" + "able\030\n \001(\010\022\021\n\tplayer_id\030\013 \001(\003\022\022\n\nview_ra" + "nge\030\014 \001(\005\022\016\n\006radius\030\r \001(\005\022+\n\014player_stat" + "e\030\016 \001(\0162\025.protobuf.PlayerState\022\024\n\014trick_" + "desire\030\017 \001(\001\022\024\n\014class_volume\030\020 \001(\001\022\'\n\004bu" + "ff\030\021 \003(\0162\031.protobuf.TrickerBuffType\"\317\001\n\017" + "MessageOfBullet\022\"\n\004type\030\001 \001(\0162\024.protobuf" + ".BulletType\022\t\n\001x\030\002 \001(\005\022\t\n\001y\030\003 \001(\005\022\030\n\020fac" + "ing_direction\030\004 \001(\001\022\014\n\004guid\030\005 \001(\003\022\"\n\004tea" + "m\030\006 \001(\0162\024.protobuf.PlayerType\022\"\n\005place\030\007" + " \001(\0162\023.protobuf.PlaceType\022\022\n\nbomb_range\030" + "\010 \001(\001\"\223\001\n\025MessageOfBombedBullet\022\"\n\004type\030" + "\001 \001(\0162\024.protobuf.BulletType\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\nm" + "apping_id\030\005 \001(\003\022\022\n\nbomb_range\030\006 \001(\001\"\264\001\n\r" + "MessageOfProp\022 \n\004type\030\001 \001(\0162\022.protobuf.P" + "ropType\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.PlaceType\022\014\n\004size\030\007 \001(\005\022" + "\021\n\tis_moving\030\010 \001(\010\"{\n\023MessageOfPickedPro" + "p\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\022MessageOfClas" + "sroom\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005\022\020\n\010progress\030" + "\003 \001(\005\"7\n\rMessageOfGate\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002" + " \001(\005\022\020\n\010progress\030\003 \001(\005\"6\n\rMessageOfDoor\022" + "\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005\022\017\n\007is_open\030\003 \001(\010\"8" + "\n\016MessageOfChest\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005\022\020" + "\n\010progress\030\003 \001(\005\"\367\001\n\017MessageOfMapObj\0229\n\021" + "classroom_message\030\001 \001(\0132\034.protobuf.Messa" + "geOfClassroomH\000\022/\n\014door_message\030\002 \001(\0132\027." + "protobuf.MessageOfDoorH\000\022/\n\014gate_message" + "\030\003 \001(\0132\027.protobuf.MessageOfGateH\000\0221\n\rche" + "st_message\030\004 \001(\0132\030.protobuf.MessageOfChe" + "stH\000B\024\n\022message_of_map_obj\"\224\001\n\014MessageOf" + "Map\022\'\n\003row\030\002 \003(\0132\032.protobuf.MessageOfMap" + ".Row\0222\n\017map_obj_message\030\003 \003(\0132\031.protobuf" + ".MessageOfMapObj\032\'\n\003Row\022 \n\003col\030\001 \003(\0162\023.p" + "rotobuf.PlaceType\"\266\002\n\014MessageOfObj\0225\n\017st" + "udent_message\030\001 \001(\0132\032.protobuf.MessageOf" + "StudentH\000\0225\n\017tricker_message\030\002 \001(\0132\032.pro" + "tobuf.MessageOfTrickerH\000\022/\n\014prop_message" + "\030\003 \001(\0132\027.protobuf.MessageOfPropH\000\0223\n\016bul" + "let_message\030\004 \001(\0132\031.protobuf.MessageOfBu" + "lletH\000\022@\n\025bombed_bullet_message\030\005 \001(\0132\037." + "protobuf.MessageOfBombedBulletH\000B\020\n\016mess" + "age_of_obj\"\350\001\n\014MessageOfAll\022\021\n\tgame_time" + "\030\001 \001(\005\022\024\n\014subject_left\030\002 \001(\005\022\031\n\021student_" + "graduated\030\003 \001(\005\022\026\n\016student_quited\030\004 \001(\005\022" + "\025\n\rstudent_score\030\005 \001(\005\022\025\n\rtricker_score\030" + "\006 \001(\005\022\023\n\013gate_opened\030\007 \001(\010\022\035\n\025hidden_gat" + "e_refreshed\030\010 \001(\010\022\032\n\022hidden_gate_opened\030" + "\t \001(\010\"\301\001\n\017MessageToClient\022+\n\013obj_message" + "\030\001 \003(\0132\026.protobuf.MessageOfObj\022+\n\013map_me" + "ssage\030\002 \001(\0132\026.protobuf.MessageOfMap\022\'\n\ng" + "ame_state\030\003 \001(\0162\023.protobuf.GameState\022+\n\013" + "all_message\030\004 \001(\0132\026.protobuf.MessageOfAl" + "l\"J\n\007MoveRes\022\024\n\014actual_speed\030\001 \001(\003\022\024\n\014ac" + "tual_angle\030\002 \001(\001\022\023\n\013act_success\030\003 \001(\010\"\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\016from_player_id\030" + "\002 \001(\003\022\030\n\020message_received\030\003 \001(\tb\006proto3"; static const ::_pbi::DescriptorTable* const descriptor_table_Message2Clients_2eproto_deps[1] = { &::descriptor_table_MessageType_2eproto, }; @@ -533,13 +809,13 @@ static ::_pbi::once_flag descriptor_table_Message2Clients_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_Message2Clients_2eproto = { false, false, - 2194, + 3319, descriptor_table_protodef_Message2Clients_2eproto, "Message2Clients.proto", &descriptor_table_Message2Clients_2eproto_once, descriptor_table_Message2Clients_2eproto_deps, 1, - 12, + 19, schemas, file_default_instances, TableStruct_Message2Clients_2eproto::offsets, @@ -576,10 +852,10 @@ namespace protobuf MessageOfStudent* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.buff_){from._impl_.buff_}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.speed_){}, decltype(_impl_.determination_){}, decltype(_impl_.time_until_skill_available_){}, decltype(_impl_.fail_num_){}, decltype(_impl_.place_){}, decltype(_impl_.prop_){}, decltype(_impl_.student_type_){}, decltype(_impl_.guid_){}, decltype(_impl_.fail_time_){}, decltype(_impl_.state_){}, decltype(_impl_.view_range_){}, decltype(_impl_.emo_time_){}, decltype(_impl_.player_id_){}, decltype(_impl_.radius_){}, decltype(_impl_.damage_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.prop_){from._impl_.prop_}, /*decltype(_impl_._prop_cached_byte_size_)*/ {0}, decltype(_impl_.buff_){from._impl_.buff_}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.speed_){}, decltype(_impl_.determination_){}, decltype(_impl_.time_until_skill_available_){}, decltype(_impl_.fail_num_){}, decltype(_impl_.place_){}, decltype(_impl_.guid_){}, decltype(_impl_.player_state_){}, decltype(_impl_.state_){}, decltype(_impl_.fail_time_){}, decltype(_impl_.emo_time_){}, decltype(_impl_.player_id_){}, decltype(_impl_.view_range_){}, decltype(_impl_.radius_){}, decltype(_impl_.danger_alert_){}, decltype(_impl_.damage_){}, decltype(_impl_.score_){}, decltype(_impl_.treat_progress_){}, decltype(_impl_.rescue_progress_){}, decltype(_impl_.student_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.damage_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.damage_)); + ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.student_type_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.student_type_)); // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfStudent) } @@ -590,7 +866,7 @@ namespace protobuf (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.buff_){arena}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.speed_){0}, decltype(_impl_.determination_){0}, decltype(_impl_.time_until_skill_available_){0}, decltype(_impl_.fail_num_){0}, decltype(_impl_.place_){0}, decltype(_impl_.prop_){0}, decltype(_impl_.student_type_){0}, decltype(_impl_.guid_){int64_t{0}}, decltype(_impl_.fail_time_){0}, decltype(_impl_.state_){0}, decltype(_impl_.view_range_){0}, decltype(_impl_.emo_time_){0}, decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.radius_){0}, decltype(_impl_.damage_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.prop_){arena}, /*decltype(_impl_._prop_cached_byte_size_)*/ {0}, decltype(_impl_.buff_){arena}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.speed_){0}, decltype(_impl_.determination_){0}, decltype(_impl_.time_until_skill_available_){0}, decltype(_impl_.fail_num_){0}, decltype(_impl_.place_){0}, decltype(_impl_.guid_){int64_t{0}}, decltype(_impl_.player_state_){0}, decltype(_impl_.state_){0}, decltype(_impl_.fail_time_){0}, decltype(_impl_.emo_time_){0}, decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.view_range_){0}, decltype(_impl_.radius_){0}, decltype(_impl_.danger_alert_){0}, decltype(_impl_.damage_){0}, decltype(_impl_.score_){0}, decltype(_impl_.treat_progress_){0}, decltype(_impl_.rescue_progress_){0}, decltype(_impl_.student_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } MessageOfStudent::~MessageOfStudent() @@ -607,6 +883,7 @@ namespace protobuf inline void MessageOfStudent::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.prop_.~RepeatedField(); _impl_.buff_.~RepeatedField(); } @@ -622,8 +899,9 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; + _impl_.prop_.Clear(); _impl_.buff_.Clear(); - ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.damage_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.damage_)); + ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.student_type_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.student_type_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -709,24 +987,29 @@ namespace protobuf else goto handle_unusual; continue; - // .protobuf.PropType prop = 8; + // repeated .protobuf.PropType prop = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) + { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_prop(), ptr, ctx); + CHK_(ptr); + } + else if (static_cast(tag) == 64) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_prop(static_cast<::protobuf::PropType>(val)); + _internal_add_prop(static_cast<::protobuf::PropType>(val)); } else goto handle_unusual; continue; - // .protobuf.StudentType student_type = 9; + // .protobuf.PlayerState player_state = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_student_type(static_cast<::protobuf::StudentType>(val)); + _internal_set_player_state(static_cast<::protobuf::PlayerState>(val)); } else goto handle_unusual; @@ -741,13 +1024,13 @@ namespace protobuf else goto handle_unusual; continue; - // .protobuf.StudentState state = 11; + // .protobuf.PlayerState state = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_state(static_cast<::protobuf::StudentState>(val)); + _internal_set_state(static_cast<::protobuf::PlayerState>(val)); } else goto handle_unusual; @@ -812,14 +1095,65 @@ namespace protobuf else goto handle_unusual; continue; - // repeated .protobuf.StudentBuffType buff = 19; + // double danger_alert = 19; case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 153)) + { + _impl_.danger_alert_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } + else + goto handle_unusual; + continue; + // int32 score = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) + { + _impl_.score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 treat_progress = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) + { + _impl_.treat_progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 rescue_progress = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) + { + _impl_.rescue_progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.StudentType student_type = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_student_type(static_cast<::protobuf::StudentType>(val)); + } + else + goto handle_unusual; + continue; + // repeated .protobuf.StudentBuffType buff = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_buff(), ptr, ctx); CHK_(ptr); } - else if (static_cast(tag) == 152) + else if (static_cast(tag) == 192) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); @@ -917,21 +1251,23 @@ namespace protobuf ); } - // .protobuf.PropType prop = 8; - if (this->_internal_prop() != 0) + // repeated .protobuf.PropType prop = 8; { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 8, this->_internal_prop(), target - ); + int byte_size = _impl_._prop_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) + { + target = stream->WriteEnumPacked( + 8, _impl_.prop_, byte_size, target + ); + } } - // .protobuf.StudentType student_type = 9; - if (this->_internal_student_type() != 0) + // .protobuf.PlayerState player_state = 9; + if (this->_internal_player_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( - 9, this->_internal_student_type(), target + 9, this->_internal_player_state(), target ); } @@ -942,7 +1278,7 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_guid(), target); } - // .protobuf.StudentState state = 11; + // .protobuf.PlayerState state = 11; if (this->_internal_state() != 0) { target = stream->EnsureSpace(target); @@ -1001,13 +1337,54 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt32ToArray(18, this->_internal_damage(), target); } - // repeated .protobuf.StudentBuffType buff = 19; + // double danger_alert = 19; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_danger_alert = this->_internal_danger_alert(); + uint64_t raw_danger_alert; + memcpy(&raw_danger_alert, &tmp_danger_alert, sizeof(tmp_danger_alert)); + if (raw_danger_alert != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(19, this->_internal_danger_alert(), target); + } + + // int32 score = 20; + if (this->_internal_score() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(20, this->_internal_score(), target); + } + + // int32 treat_progress = 21; + if (this->_internal_treat_progress() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(21, this->_internal_treat_progress(), target); + } + + // int32 rescue_progress = 22; + if (this->_internal_rescue_progress() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(22, this->_internal_rescue_progress(), target); + } + + // .protobuf.StudentType student_type = 23; + if (this->_internal_student_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 23, this->_internal_student_type(), target + ); + } + + // repeated .protobuf.StudentBuffType buff = 24; { int byte_size = _impl_._buff_cached_byte_size_.load(std::memory_order_relaxed); if (byte_size > 0) { target = stream->WriteEnumPacked( - 19, _impl_.buff_, byte_size, target + 24, _impl_.buff_, byte_size, target ); } } @@ -1031,7 +1408,27 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - // repeated .protobuf.StudentBuffType buff = 19; + // repeated .protobuf.PropType prop = 8; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_prop_size()); + for (unsigned int i = 0; i < count; i++) + { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_prop(static_cast(i)) + ); + } + if (data_size > 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._prop_cached_byte_size_.store(cached_size, std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .protobuf.StudentBuffType buff = 24; { size_t data_size = 0; unsigned int count = static_cast(this->_internal_buff_size()); @@ -1098,24 +1495,24 @@ namespace protobuf ::_pbi::WireFormatLite::EnumSize(this->_internal_place()); } - // .protobuf.PropType prop = 8; - if (this->_internal_prop() != 0) + // int64 guid = 10; + if (this->_internal_guid() != 0) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_prop()); + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_guid()); } - // .protobuf.StudentType student_type = 9; - if (this->_internal_student_type() != 0) + // .protobuf.PlayerState player_state = 9; + if (this->_internal_player_state() != 0) { total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_student_type()); + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_state()); } - // int64 guid = 10; - if (this->_internal_guid() != 0) + // .protobuf.PlayerState state = 11; + if (this->_internal_state() != 0) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_guid()); + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_state()); } // double fail_time = 12; @@ -1128,22 +1525,6 @@ namespace protobuf total_size += 1 + 8; } - // .protobuf.StudentState state = 11; - if (this->_internal_state() != 0) - { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_state()); - } - - // int32 view_range = 16; - if (this->_internal_view_range() != 0) - { - total_size += 2 + - ::_pbi::WireFormatLite::Int32Size( - this->_internal_view_range() - ); - } - // double emo_time = 14; static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_emo_time = this->_internal_emo_time(); @@ -1160,15 +1541,34 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } - // int32 radius = 17; - if (this->_internal_radius() != 0) - { + // int32 view_range = 16; + if (this->_internal_view_range() != 0) + { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size( + this->_internal_view_range() + ); + } + + // int32 radius = 17; + if (this->_internal_radius() != 0) + { total_size += 2 + ::_pbi::WireFormatLite::Int32Size( this->_internal_radius() ); } + // double danger_alert = 19; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_danger_alert = this->_internal_danger_alert(); + uint64_t raw_danger_alert; + memcpy(&raw_danger_alert, &tmp_danger_alert, sizeof(tmp_danger_alert)); + if (raw_danger_alert != 0) + { + total_size += 2 + 8; + } + // int32 damage = 18; if (this->_internal_damage() != 0) { @@ -1178,6 +1578,40 @@ namespace protobuf ); } + // int32 score = 20; + if (this->_internal_score() != 0) + { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size( + this->_internal_score() + ); + } + + // int32 treat_progress = 21; + if (this->_internal_treat_progress() != 0) + { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size( + this->_internal_treat_progress() + ); + } + + // int32 rescue_progress = 22; + if (this->_internal_rescue_progress() != 0) + { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size( + this->_internal_rescue_progress() + ); + } + + // .protobuf.StudentType student_type = 23; + if (this->_internal_student_type() != 0) + { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_student_type()); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -1198,6 +1632,7 @@ namespace protobuf uint32_t cached_has_bits = 0; (void)cached_has_bits; + _this->_impl_.prop_.MergeFrom(from._impl_.prop_); _this->_impl_.buff_.MergeFrom(from._impl_.buff_); if (from._internal_x() != 0) { @@ -1231,17 +1666,17 @@ namespace protobuf { _this->_internal_set_place(from._internal_place()); } - if (from._internal_prop() != 0) + if (from._internal_guid() != 0) { - _this->_internal_set_prop(from._internal_prop()); + _this->_internal_set_guid(from._internal_guid()); } - if (from._internal_student_type() != 0) + if (from._internal_player_state() != 0) { - _this->_internal_set_student_type(from._internal_student_type()); + _this->_internal_set_player_state(from._internal_player_state()); } - if (from._internal_guid() != 0) + if (from._internal_state() != 0) { - _this->_internal_set_guid(from._internal_guid()); + _this->_internal_set_state(from._internal_state()); } static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_fail_time = from._internal_fail_time(); @@ -1251,14 +1686,6 @@ namespace protobuf { _this->_internal_set_fail_time(from._internal_fail_time()); } - if (from._internal_state() != 0) - { - _this->_internal_set_state(from._internal_state()); - } - if (from._internal_view_range() != 0) - { - _this->_internal_set_view_range(from._internal_view_range()); - } static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_emo_time = from._internal_emo_time(); uint64_t raw_emo_time; @@ -1271,14 +1698,42 @@ namespace protobuf { _this->_internal_set_player_id(from._internal_player_id()); } + if (from._internal_view_range() != 0) + { + _this->_internal_set_view_range(from._internal_view_range()); + } if (from._internal_radius() != 0) { _this->_internal_set_radius(from._internal_radius()); } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_danger_alert = from._internal_danger_alert(); + uint64_t raw_danger_alert; + memcpy(&raw_danger_alert, &tmp_danger_alert, sizeof(tmp_danger_alert)); + if (raw_danger_alert != 0) + { + _this->_internal_set_danger_alert(from._internal_danger_alert()); + } if (from._internal_damage() != 0) { _this->_internal_set_damage(from._internal_damage()); } + if (from._internal_score() != 0) + { + _this->_internal_set_score(from._internal_score()); + } + if (from._internal_treat_progress() != 0) + { + _this->_internal_set_treat_progress(from._internal_treat_progress()); + } + if (from._internal_rescue_progress() != 0) + { + _this->_internal_set_rescue_progress(from._internal_rescue_progress()); + } + if (from._internal_student_type() != 0) + { + _this->_internal_set_student_type(from._internal_student_type()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } @@ -1300,9 +1755,10 @@ namespace protobuf { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.prop_.InternalSwap(&other->_impl_.prop_); _impl_.buff_.InternalSwap(&other->_impl_.buff_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MessageOfStudent, _impl_.damage_) + sizeof(MessageOfStudent::_impl_.damage_) - PROTOBUF_FIELD_OFFSET(MessageOfStudent, _impl_.x_)>( + PROTOBUF_FIELD_OFFSET(MessageOfStudent, _impl_.student_type_) + sizeof(MessageOfStudent::_impl_.student_type_) - PROTOBUF_FIELD_OFFSET(MessageOfStudent, _impl_.x_)>( reinterpret_cast(&_impl_.x_), reinterpret_cast(&other->_impl_.x_) ); @@ -1334,10 +1790,10 @@ namespace protobuf MessageOfTricker* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.buff_){from._impl_.buff_}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.speed_){}, decltype(_impl_.damage_){}, decltype(_impl_.time_until_skill_available_){}, decltype(_impl_.place_){}, decltype(_impl_.prop_){}, decltype(_impl_.guid_){}, decltype(_impl_.tricker_type_){}, decltype(_impl_.movable_){}, decltype(_impl_.player_id_){}, decltype(_impl_.view_range_){}, decltype(_impl_.radius_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.prop_){from._impl_.prop_}, /*decltype(_impl_._prop_cached_byte_size_)*/ {0}, decltype(_impl_.buff_){from._impl_.buff_}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.speed_){}, decltype(_impl_.damage_){}, decltype(_impl_.time_until_skill_available_){}, decltype(_impl_.place_){}, decltype(_impl_.tricker_type_){}, decltype(_impl_.guid_){}, decltype(_impl_.player_id_){}, decltype(_impl_.movable_){}, decltype(_impl_.view_range_){}, decltype(_impl_.radius_){}, decltype(_impl_.player_state_){}, decltype(_impl_.trick_desire_){}, decltype(_impl_.class_volume_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.radius_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.radius_)); + ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.class_volume_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.class_volume_)); // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfTricker) } @@ -1348,7 +1804,7 @@ namespace protobuf (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.buff_){arena}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.speed_){0}, decltype(_impl_.damage_){0}, decltype(_impl_.time_until_skill_available_){0}, decltype(_impl_.place_){0}, decltype(_impl_.prop_){0}, decltype(_impl_.guid_){int64_t{0}}, decltype(_impl_.tricker_type_){0}, decltype(_impl_.movable_){false}, decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.view_range_){0}, decltype(_impl_.radius_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.prop_){arena}, /*decltype(_impl_._prop_cached_byte_size_)*/ {0}, decltype(_impl_.buff_){arena}, /*decltype(_impl_._buff_cached_byte_size_)*/ {0}, decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.speed_){0}, decltype(_impl_.damage_){0}, decltype(_impl_.time_until_skill_available_){0}, decltype(_impl_.place_){0}, decltype(_impl_.tricker_type_){0}, decltype(_impl_.guid_){int64_t{0}}, decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.movable_){false}, decltype(_impl_.view_range_){0}, decltype(_impl_.radius_){0}, decltype(_impl_.player_state_){0}, decltype(_impl_.trick_desire_){0}, decltype(_impl_.class_volume_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } MessageOfTricker::~MessageOfTricker() @@ -1365,6 +1821,7 @@ namespace protobuf inline void MessageOfTricker::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.prop_.~RepeatedField(); _impl_.buff_.~RepeatedField(); } @@ -1380,8 +1837,9 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; + _impl_.prop_.Clear(); _impl_.buff_.Clear(); - ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.radius_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.radius_)); + ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.class_volume_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.class_volume_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1457,13 +1915,18 @@ namespace protobuf else goto handle_unusual; continue; - // .protobuf.PropType prop = 7; + // repeated .protobuf.PropType prop = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) + { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_prop(), ptr, ctx); + CHK_(ptr); + } + else if (static_cast(tag) == 56) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_prop(static_cast<::protobuf::PropType>(val)); + _internal_add_prop(static_cast<::protobuf::PropType>(val)); } else goto handle_unusual; @@ -1529,14 +1992,45 @@ namespace protobuf else goto handle_unusual; continue; - // repeated .protobuf.TrickerBuffType buff = 14; + // .protobuf.PlayerState player_state = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_player_state(static_cast<::protobuf::PlayerState>(val)); + } + else + goto handle_unusual; + continue; + // double trick_desire = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 121)) + { + _impl_.trick_desire_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } + else + goto handle_unusual; + continue; + // double class_volume = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 129)) + { + _impl_.class_volume_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } + else + goto handle_unusual; + continue; + // repeated .protobuf.TrickerBuffType buff = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_buff(), ptr, ctx); CHK_(ptr); } - else if (static_cast(tag) == 112) + else if (static_cast(tag) == 136) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); @@ -1627,13 +2121,15 @@ namespace protobuf ); } - // .protobuf.PropType prop = 7; - if (this->_internal_prop() != 0) + // repeated .protobuf.PropType prop = 7; { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 7, this->_internal_prop(), target - ); + int byte_size = _impl_._prop_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) + { + target = stream->WriteEnumPacked( + 7, _impl_.prop_, byte_size, target + ); + } } // .protobuf.TrickerType tricker_type = 8; @@ -1680,13 +2176,44 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt32ToArray(13, this->_internal_radius(), target); } - // repeated .protobuf.TrickerBuffType buff = 14; + // .protobuf.PlayerState player_state = 14; + if (this->_internal_player_state() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 14, this->_internal_player_state(), target + ); + } + + // double trick_desire = 15; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_trick_desire = this->_internal_trick_desire(); + uint64_t raw_trick_desire; + memcpy(&raw_trick_desire, &tmp_trick_desire, sizeof(tmp_trick_desire)); + if (raw_trick_desire != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(15, this->_internal_trick_desire(), target); + } + + // double class_volume = 16; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_class_volume = this->_internal_class_volume(); + uint64_t raw_class_volume; + memcpy(&raw_class_volume, &tmp_class_volume, sizeof(tmp_class_volume)); + if (raw_class_volume != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(16, this->_internal_class_volume(), target); + } + + // repeated .protobuf.TrickerBuffType buff = 17; { int byte_size = _impl_._buff_cached_byte_size_.load(std::memory_order_relaxed); if (byte_size > 0) { target = stream->WriteEnumPacked( - 14, _impl_.buff_, byte_size, target + 17, _impl_.buff_, byte_size, target ); } } @@ -1710,7 +2237,27 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - // repeated .protobuf.TrickerBuffType buff = 14; + // repeated .protobuf.PropType prop = 7; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_prop_size()); + for (unsigned int i = 0; i < count; i++) + { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_prop(static_cast(i)) + ); + } + if (data_size > 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._prop_cached_byte_size_.store(cached_size, std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .protobuf.TrickerBuffType buff = 17; { size_t data_size = 0; unsigned int count = static_cast(this->_internal_buff_size()); @@ -1722,7 +2269,7 @@ namespace protobuf } if (data_size > 0) { - total_size += 1 + + total_size += 2 + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); } int cached_size = ::_pbi::ToCachedSize(data_size); @@ -1771,11 +2318,11 @@ namespace protobuf ::_pbi::WireFormatLite::EnumSize(this->_internal_place()); } - // .protobuf.PropType prop = 7; - if (this->_internal_prop() != 0) + // .protobuf.TrickerType tricker_type = 8; + if (this->_internal_tricker_type() != 0) { total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_prop()); + ::_pbi::WireFormatLite::EnumSize(this->_internal_tricker_type()); } // int64 guid = 9; @@ -1784,11 +2331,10 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_guid()); } - // .protobuf.TrickerType tricker_type = 8; - if (this->_internal_tricker_type() != 0) + // int64 player_id = 11; + if (this->_internal_player_id() != 0) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_tricker_type()); + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } // bool movable = 10; @@ -1797,12 +2343,6 @@ namespace protobuf total_size += 1 + 1; } - // int64 player_id = 11; - if (this->_internal_player_id() != 0) - { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); - } - // int32 view_range = 12; if (this->_internal_view_range() != 0) { @@ -1815,6 +2355,33 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_radius()); } + // .protobuf.PlayerState player_state = 14; + if (this->_internal_player_state() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_state()); + } + + // double trick_desire = 15; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_trick_desire = this->_internal_trick_desire(); + uint64_t raw_trick_desire; + memcpy(&raw_trick_desire, &tmp_trick_desire, sizeof(tmp_trick_desire)); + if (raw_trick_desire != 0) + { + total_size += 1 + 8; + } + + // double class_volume = 16; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_class_volume = this->_internal_class_volume(); + uint64_t raw_class_volume; + memcpy(&raw_class_volume, &tmp_class_volume, sizeof(tmp_class_volume)); + if (raw_class_volume != 0) + { + total_size += 2 + 8; + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -1835,6 +2402,7 @@ namespace protobuf uint32_t cached_has_bits = 0; (void)cached_has_bits; + _this->_impl_.prop_.MergeFrom(from._impl_.prop_); _this->_impl_.buff_.MergeFrom(from._impl_.buff_); if (from._internal_x() != 0) { @@ -1864,26 +2432,22 @@ namespace protobuf { _this->_internal_set_place(from._internal_place()); } - if (from._internal_prop() != 0) + if (from._internal_tricker_type() != 0) { - _this->_internal_set_prop(from._internal_prop()); + _this->_internal_set_tricker_type(from._internal_tricker_type()); } if (from._internal_guid() != 0) { _this->_internal_set_guid(from._internal_guid()); } - if (from._internal_tricker_type() != 0) + if (from._internal_player_id() != 0) { - _this->_internal_set_tricker_type(from._internal_tricker_type()); + _this->_internal_set_player_id(from._internal_player_id()); } if (from._internal_movable() != 0) { _this->_internal_set_movable(from._internal_movable()); } - if (from._internal_player_id() != 0) - { - _this->_internal_set_player_id(from._internal_player_id()); - } if (from._internal_view_range() != 0) { _this->_internal_set_view_range(from._internal_view_range()); @@ -1892,6 +2456,26 @@ namespace protobuf { _this->_internal_set_radius(from._internal_radius()); } + if (from._internal_player_state() != 0) + { + _this->_internal_set_player_state(from._internal_player_state()); + } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_trick_desire = from._internal_trick_desire(); + uint64_t raw_trick_desire; + memcpy(&raw_trick_desire, &tmp_trick_desire, sizeof(tmp_trick_desire)); + if (raw_trick_desire != 0) + { + _this->_internal_set_trick_desire(from._internal_trick_desire()); + } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_class_volume = from._internal_class_volume(); + uint64_t raw_class_volume; + memcpy(&raw_class_volume, &tmp_class_volume, sizeof(tmp_class_volume)); + if (raw_class_volume != 0) + { + _this->_internal_set_class_volume(from._internal_class_volume()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } @@ -1913,9 +2497,10 @@ namespace protobuf { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.prop_.InternalSwap(&other->_impl_.prop_); _impl_.buff_.InternalSwap(&other->_impl_.buff_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MessageOfTricker, _impl_.radius_) + sizeof(MessageOfTricker::_impl_.radius_) - PROTOBUF_FIELD_OFFSET(MessageOfTricker, _impl_.x_)>( + PROTOBUF_FIELD_OFFSET(MessageOfTricker, _impl_.class_volume_) + sizeof(MessageOfTricker::_impl_.class_volume_) - PROTOBUF_FIELD_OFFSET(MessageOfTricker, _impl_.x_)>( reinterpret_cast(&_impl_.x_), reinterpret_cast(&other->_impl_.x_) ); @@ -3507,42 +4092,43 @@ namespace protobuf // =================================================================== - class MessageOfMap_Row::_Internal + class MessageOfClassroom::_Internal { public: }; - MessageOfMap_Row::MessageOfMap_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : + MessageOfClassroom::MessageOfClassroom(::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.MessageOfMap.Row) + // @@protoc_insertion_point(arena_constructor:protobuf.MessageOfClassroom) } - MessageOfMap_Row::MessageOfMap_Row(const MessageOfMap_Row& from) : + MessageOfClassroom::MessageOfClassroom(const MessageOfClassroom& from) : ::PROTOBUF_NAMESPACE_ID::Message() { - MessageOfMap_Row* const _this = this; + MessageOfClassroom* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.col_){from._impl_.col_}, /*decltype(_impl_._col_cached_byte_size_)*/ {0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.progress_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfMap.Row) + ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.progress_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.progress_)); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfClassroom) } - inline void MessageOfMap_Row::SharedCtor( + inline void MessageOfClassroom::SharedCtor( ::_pb::Arena* arena, bool is_message_owned ) { (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.col_){arena}, /*decltype(_impl_._col_cached_byte_size_)*/ {0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.progress_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } - MessageOfMap_Row::~MessageOfMap_Row() + MessageOfClassroom::~MessageOfClassroom() { - // @@protoc_insertion_point(destructor:protobuf.MessageOfMap.Row) + // @@protoc_insertion_point(destructor:protobuf.MessageOfClassroom) if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { (void)arena; @@ -3551,29 +4137,28 @@ namespace protobuf SharedDtor(); } - inline void MessageOfMap_Row::SharedDtor() + inline void MessageOfClassroom::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.col_.~RepeatedField(); } - void MessageOfMap_Row::SetCachedSize(int size) const + void MessageOfClassroom::SetCachedSize(int size) const { _impl_._cached_size_.Set(size); } - void MessageOfMap_Row::Clear() + void MessageOfClassroom::Clear() { - // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfMap.Row) + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfClassroom) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - _impl_.col_.Clear(); + ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.progress_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.progress_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } - const char* MessageOfMap_Row::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) + const char* MessageOfClassroom::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) \ if (PROTOBUF_PREDICT_FALSE(!(x))) \ @@ -3584,18 +4169,32 @@ namespace protobuf ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .protobuf.PlaceType col = 1; + // int32 x = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_col(), ptr, ctx); + _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } - else if (static_cast(tag) == 8) + else + goto handle_unusual; + continue; + // int32 y = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 progress = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - _internal_add_col(static_cast<::protobuf::PlaceType>(val)); } else goto handle_unusual; @@ -3626,23 +4225,33 @@ namespace protobuf #undef CHK_ } - uint8_t* MessageOfMap_Row::_InternalSerialize( + uint8_t* MessageOfClassroom::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream ) const { - // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfMap.Row) + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfClassroom) uint32_t cached_has_bits = 0; (void)cached_has_bits; - // repeated .protobuf.PlaceType col = 1; + // int32 x = 1; + if (this->_internal_x() != 0) { - int byte_size = _impl_._col_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) - { - target = stream->WriteEnumPacked( - 1, _impl_.col_, byte_size, target - ); - } + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target); + } + + // int32 progress = 3; + if (this->_internal_progress() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_progress(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) @@ -3651,85 +4260,98 @@ namespace protobuf _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream ); } - // @@protoc_insertion_point(serialize_to_array_end:protobuf.MessageOfMap.Row) + // @@protoc_insertion_point(serialize_to_array_end:protobuf.MessageOfClassroom) return target; } - size_t MessageOfMap_Row::ByteSizeLong() const + size_t MessageOfClassroom::ByteSizeLong() const { - // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfMap.Row) + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfClassroom) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - // repeated .protobuf.PlaceType col = 1; + // int32 x = 1; + if (this->_internal_x() != 0) { - size_t data_size = 0; - unsigned int count = static_cast(this->_internal_col_size()); - for (unsigned int i = 0; i < count; i++) - { - data_size += ::_pbi::WireFormatLite::EnumSize( - this->_internal_col(static_cast(i)) - ); - } - if (data_size > 0) - { - total_size += 1 + - ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); - } - int cached_size = ::_pbi::ToCachedSize(data_size); - _impl_._col_cached_byte_size_.store(cached_size, std::memory_order_relaxed); - total_size += data_size; + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_x()); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_y()); + } + + // int32 progress = 3; + if (this->_internal_progress() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_progress()); } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfMap_Row::_class_data_ = { + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfClassroom::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MessageOfMap_Row::MergeImpl}; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfMap_Row::GetClassData() const + MessageOfClassroom::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfClassroom::GetClassData() const { return &_class_data_; } - void MessageOfMap_Row::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + void MessageOfClassroom::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfMap.Row) + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfClassroom) GOOGLE_DCHECK_NE(&from, _this); uint32_t cached_has_bits = 0; (void)cached_has_bits; - _this->_impl_.col_.MergeFrom(from._impl_.col_); + if (from._internal_x() != 0) + { + _this->_internal_set_x(from._internal_x()); + } + if (from._internal_y() != 0) + { + _this->_internal_set_y(from._internal_y()); + } + if (from._internal_progress() != 0) + { + _this->_internal_set_progress(from._internal_progress()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } - void MessageOfMap_Row::CopyFrom(const MessageOfMap_Row& from) + void MessageOfClassroom::CopyFrom(const MessageOfClassroom& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfMap.Row) + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfClassroom) if (&from == this) return; Clear(); MergeFrom(from); } - bool MessageOfMap_Row::IsInitialized() const + bool MessageOfClassroom::IsInitialized() const { return true; } - void MessageOfMap_Row::InternalSwap(MessageOfMap_Row* other) + void MessageOfClassroom::InternalSwap(MessageOfClassroom* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.col_.InternalSwap(&other->_impl_.col_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MessageOfClassroom, _impl_.progress_) + sizeof(MessageOfClassroom::_impl_.progress_) - PROTOBUF_FIELD_OFFSET(MessageOfClassroom, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_) + ); } - ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfMap_Row::GetMetadata() const + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfClassroom::GetMetadata() const { return ::_pbi::AssignDescriptors( &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[6] @@ -3738,42 +4360,43 @@ namespace protobuf // =================================================================== - class MessageOfMap::_Internal + class MessageOfGate::_Internal { public: }; - MessageOfMap::MessageOfMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : + MessageOfGate::MessageOfGate(::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.MessageOfMap) + // @@protoc_insertion_point(arena_constructor:protobuf.MessageOfGate) } - MessageOfMap::MessageOfMap(const MessageOfMap& from) : + MessageOfGate::MessageOfGate(const MessageOfGate& from) : ::PROTOBUF_NAMESPACE_ID::Message() { - MessageOfMap* const _this = this; + MessageOfGate* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.row_){from._impl_.row_}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.progress_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfMap) + ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.progress_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.progress_)); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfGate) } - inline void MessageOfMap::SharedCtor( + inline void MessageOfGate::SharedCtor( ::_pb::Arena* arena, bool is_message_owned ) { (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.row_){arena}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.progress_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } - MessageOfMap::~MessageOfMap() + MessageOfGate::~MessageOfGate() { - // @@protoc_insertion_point(destructor:protobuf.MessageOfMap) + // @@protoc_insertion_point(destructor:protobuf.MessageOfGate) if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { (void)arena; @@ -3782,29 +4405,28 @@ namespace protobuf SharedDtor(); } - inline void MessageOfMap::SharedDtor() + inline void MessageOfGate::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.row_.~RepeatedPtrField(); } - void MessageOfMap::SetCachedSize(int size) const + void MessageOfGate::SetCachedSize(int size) const { _impl_._cached_size_.Set(size); } - void MessageOfMap::Clear() + void MessageOfGate::Clear() { - // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfMap) + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfGate) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - _impl_.row_.Clear(); + ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.progress_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.progress_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } - const char* MessageOfMap::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) + const char* MessageOfGate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) \ if (PROTOBUF_PREDICT_FALSE(!(x))) \ @@ -3815,19 +4437,32 @@ namespace protobuf ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .protobuf.MessageOfMap.Row row = 2; + // int32 x = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) + { + _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 y = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - ptr -= 1; - do - { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_row(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) - break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 progress = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); } else goto handle_unusual; @@ -3858,23 +4493,2533 @@ namespace protobuf #undef CHK_ } - uint8_t* MessageOfMap::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream - ) const - { - // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfMap) - uint32_t cached_has_bits = 0; - (void)cached_has_bits; + uint8_t* MessageOfGate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfGate) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 x = 1; + if (this->_internal_x() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target); + } + + // int32 progress = 3; + if (this->_internal_progress() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_progress(), 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.MessageOfGate) + return target; + } + + size_t MessageOfGate::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfGate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // int32 x = 1; + if (this->_internal_x() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_x()); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_y()); + } + + // int32 progress = 3; + if (this->_internal_progress() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_progress()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfGate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfGate::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfGate::GetClassData() const + { + return &_class_data_; + } + + void MessageOfGate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfGate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_x() != 0) + { + _this->_internal_set_x(from._internal_x()); + } + if (from._internal_y() != 0) + { + _this->_internal_set_y(from._internal_y()); + } + if (from._internal_progress() != 0) + { + _this->_internal_set_progress(from._internal_progress()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfGate::CopyFrom(const MessageOfGate& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfGate) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfGate::IsInitialized() const + { + return true; + } + + void MessageOfGate::InternalSwap(MessageOfGate* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MessageOfGate, _impl_.progress_) + sizeof(MessageOfGate::_impl_.progress_) - PROTOBUF_FIELD_OFFSET(MessageOfGate, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_) + ); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfGate::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[7] + ); + } + + // =================================================================== + + class MessageOfDoor::_Internal + { + public: + }; + + MessageOfDoor::MessageOfDoor(::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.MessageOfDoor) + } + MessageOfDoor::MessageOfDoor(const MessageOfDoor& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfDoor* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.is_open_){}, /*decltype(_impl_._cached_size_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.is_open_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.is_open_)); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfDoor) + } + + inline void MessageOfDoor::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.is_open_){false}, /*decltype(_impl_._cached_size_)*/ {}}; + } + + MessageOfDoor::~MessageOfDoor() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfDoor) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfDoor::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + } + + void MessageOfDoor::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfDoor::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfDoor) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.is_open_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.is_open_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfDoor::_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) + { + // int32 x = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) + { + _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 y = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // bool is_open = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.is_open_ = ::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* MessageOfDoor::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfDoor) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 x = 1; + if (this->_internal_x() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target); + } + + // bool is_open = 3; + if (this->_internal_is_open() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_open(), 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.MessageOfDoor) + return target; + } + + size_t MessageOfDoor::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfDoor) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // int32 x = 1; + if (this->_internal_x() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_x()); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_y()); + } + + // bool is_open = 3; + if (this->_internal_is_open() != 0) + { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfDoor::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfDoor::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfDoor::GetClassData() const + { + return &_class_data_; + } + + void MessageOfDoor::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfDoor) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_x() != 0) + { + _this->_internal_set_x(from._internal_x()); + } + if (from._internal_y() != 0) + { + _this->_internal_set_y(from._internal_y()); + } + if (from._internal_is_open() != 0) + { + _this->_internal_set_is_open(from._internal_is_open()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfDoor::CopyFrom(const MessageOfDoor& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfDoor) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfDoor::IsInitialized() const + { + return true; + } + + void MessageOfDoor::InternalSwap(MessageOfDoor* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MessageOfDoor, _impl_.is_open_) + sizeof(MessageOfDoor::_impl_.is_open_) - PROTOBUF_FIELD_OFFSET(MessageOfDoor, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_) + ); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfDoor::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[8] + ); + } + + // =================================================================== + + class MessageOfChest::_Internal + { + public: + }; + + MessageOfChest::MessageOfChest(::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.MessageOfChest) + } + MessageOfChest::MessageOfChest(const MessageOfChest& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfChest* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.x_){}, decltype(_impl_.y_){}, decltype(_impl_.progress_){}, /*decltype(_impl_._cached_size_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.x_, &from._impl_.x_, static_cast(reinterpret_cast(&_impl_.progress_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.progress_)); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfChest) + } + + inline void MessageOfChest::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.x_){0}, decltype(_impl_.y_){0}, decltype(_impl_.progress_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + } + + MessageOfChest::~MessageOfChest() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfChest) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfChest::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + } + + void MessageOfChest::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfChest::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfChest) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast(reinterpret_cast(&_impl_.progress_) - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.progress_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfChest::_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) + { + // int32 x = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) + { + _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 y = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 progress = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* MessageOfChest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfChest) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 x = 1; + if (this->_internal_x() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target); + } + + // int32 progress = 3; + if (this->_internal_progress() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_progress(), 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.MessageOfChest) + return target; + } + + size_t MessageOfChest::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfChest) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // int32 x = 1; + if (this->_internal_x() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_x()); + } + + // int32 y = 2; + if (this->_internal_y() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_y()); + } + + // int32 progress = 3; + if (this->_internal_progress() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_progress()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfChest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfChest::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfChest::GetClassData() const + { + return &_class_data_; + } + + void MessageOfChest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfChest) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_x() != 0) + { + _this->_internal_set_x(from._internal_x()); + } + if (from._internal_y() != 0) + { + _this->_internal_set_y(from._internal_y()); + } + if (from._internal_progress() != 0) + { + _this->_internal_set_progress(from._internal_progress()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfChest::CopyFrom(const MessageOfChest& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfChest) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfChest::IsInitialized() const + { + return true; + } + + void MessageOfChest::InternalSwap(MessageOfChest* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MessageOfChest, _impl_.progress_) + sizeof(MessageOfChest::_impl_.progress_) - PROTOBUF_FIELD_OFFSET(MessageOfChest, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_) + ); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfChest::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[9] + ); + } + + // =================================================================== + + class MessageOfMapObj::_Internal + { + public: + static const ::protobuf::MessageOfClassroom& classroom_message(const MessageOfMapObj* msg); + static const ::protobuf::MessageOfDoor& door_message(const MessageOfMapObj* msg); + static const ::protobuf::MessageOfGate& gate_message(const MessageOfMapObj* msg); + static const ::protobuf::MessageOfChest& chest_message(const MessageOfMapObj* msg); + }; + + const ::protobuf::MessageOfClassroom& + MessageOfMapObj::_Internal::classroom_message(const MessageOfMapObj* msg) + { + return *msg->_impl_.message_of_map_obj_.classroom_message_; + } + const ::protobuf::MessageOfDoor& + MessageOfMapObj::_Internal::door_message(const MessageOfMapObj* msg) + { + return *msg->_impl_.message_of_map_obj_.door_message_; + } + const ::protobuf::MessageOfGate& + MessageOfMapObj::_Internal::gate_message(const MessageOfMapObj* msg) + { + return *msg->_impl_.message_of_map_obj_.gate_message_; + } + const ::protobuf::MessageOfChest& + MessageOfMapObj::_Internal::chest_message(const MessageOfMapObj* msg) + { + return *msg->_impl_.message_of_map_obj_.chest_message_; + } + void MessageOfMapObj::set_allocated_classroom_message(::protobuf::MessageOfClassroom* classroom_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_map_obj(); + if (classroom_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(classroom_message); + if (message_arena != submessage_arena) + { + classroom_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, classroom_message, submessage_arena + ); + } + set_has_classroom_message(); + _impl_.message_of_map_obj_.classroom_message_ = classroom_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfMapObj.classroom_message) + } + void MessageOfMapObj::set_allocated_door_message(::protobuf::MessageOfDoor* door_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_map_obj(); + if (door_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(door_message); + if (message_arena != submessage_arena) + { + door_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, door_message, submessage_arena + ); + } + set_has_door_message(); + _impl_.message_of_map_obj_.door_message_ = door_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfMapObj.door_message) + } + void MessageOfMapObj::set_allocated_gate_message(::protobuf::MessageOfGate* gate_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_map_obj(); + if (gate_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gate_message); + if (message_arena != submessage_arena) + { + gate_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, gate_message, submessage_arena + ); + } + set_has_gate_message(); + _impl_.message_of_map_obj_.gate_message_ = gate_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfMapObj.gate_message) + } + void MessageOfMapObj::set_allocated_chest_message(::protobuf::MessageOfChest* chest_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_map_obj(); + if (chest_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chest_message); + if (message_arena != submessage_arena) + { + chest_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, chest_message, submessage_arena + ); + } + set_has_chest_message(); + _impl_.message_of_map_obj_.chest_message_ = chest_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfMapObj.chest_message) + } + MessageOfMapObj::MessageOfMapObj(::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.MessageOfMapObj) + } + MessageOfMapObj::MessageOfMapObj(const MessageOfMapObj& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfMapObj* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.message_of_map_obj_){}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_._oneof_case_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_message_of_map_obj(); + switch (from.message_of_map_obj_case()) + { + case kClassroomMessage: + { + _this->_internal_mutable_classroom_message()->::protobuf::MessageOfClassroom::MergeFrom( + from._internal_classroom_message() + ); + break; + } + case kDoorMessage: + { + _this->_internal_mutable_door_message()->::protobuf::MessageOfDoor::MergeFrom( + from._internal_door_message() + ); + break; + } + case kGateMessage: + { + _this->_internal_mutable_gate_message()->::protobuf::MessageOfGate::MergeFrom( + from._internal_gate_message() + ); + break; + } + case kChestMessage: + { + _this->_internal_mutable_chest_message()->::protobuf::MessageOfChest::MergeFrom( + from._internal_chest_message() + ); + break; + } + case MESSAGE_OF_MAP_OBJ_NOT_SET: + { + break; + } + } + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfMapObj) + } + + inline void MessageOfMapObj::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.message_of_map_obj_){}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_._oneof_case_)*/ {}}; + clear_has_message_of_map_obj(); + } + + MessageOfMapObj::~MessageOfMapObj() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfMapObj) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfMapObj::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (has_message_of_map_obj()) + { + clear_message_of_map_obj(); + } + } + + void MessageOfMapObj::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfMapObj::clear_message_of_map_obj() + { + // @@protoc_insertion_point(one_of_clear_start:protobuf.MessageOfMapObj) + switch (message_of_map_obj_case()) + { + case kClassroomMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.classroom_message_; + } + break; + } + case kDoorMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.door_message_; + } + break; + } + case kGateMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.gate_message_; + } + break; + } + case kChestMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.chest_message_; + } + break; + } + case MESSAGE_OF_MAP_OBJ_NOT_SET: + { + break; + } + } + _impl_._oneof_case_[0] = MESSAGE_OF_MAP_OBJ_NOT_SET; + } + + void MessageOfMapObj::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfMapObj) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + clear_message_of_map_obj(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfMapObj::_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) + { + // .protobuf.MessageOfClassroom classroom_message = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) + { + ptr = ctx->ParseMessage(_internal_mutable_classroom_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfDoor door_message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) + { + ptr = ctx->ParseMessage(_internal_mutable_door_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfGate gate_message = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) + { + ptr = ctx->ParseMessage(_internal_mutable_gate_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfChest chest_message = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) + { + ptr = ctx->ParseMessage(_internal_mutable_chest_message(), 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* MessageOfMapObj::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfMapObj) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // .protobuf.MessageOfClassroom classroom_message = 1; + if (_internal_has_classroom_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::classroom_message(this), _Internal::classroom_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfDoor door_message = 2; + if (_internal_has_door_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::door_message(this), _Internal::door_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfGate gate_message = 3; + if (_internal_has_gate_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::gate_message(this), _Internal::gate_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfChest chest_message = 4; + if (_internal_has_chest_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::chest_message(this), _Internal::chest_message(this).GetCachedSize(), target, stream); + } + + 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.MessageOfMapObj) + return target; + } + + size_t MessageOfMapObj::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfMapObj) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (message_of_map_obj_case()) + { + // .protobuf.MessageOfClassroom classroom_message = 1; + case kClassroomMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_map_obj_.classroom_message_ + ); + break; + } + // .protobuf.MessageOfDoor door_message = 2; + case kDoorMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_map_obj_.door_message_ + ); + break; + } + // .protobuf.MessageOfGate gate_message = 3; + case kGateMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_map_obj_.gate_message_ + ); + break; + } + // .protobuf.MessageOfChest chest_message = 4; + case kChestMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_map_obj_.chest_message_ + ); + break; + } + case MESSAGE_OF_MAP_OBJ_NOT_SET: + { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfMapObj::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfMapObj::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfMapObj::GetClassData() const + { + return &_class_data_; + } + + void MessageOfMapObj::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfMapObj) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (from.message_of_map_obj_case()) + { + case kClassroomMessage: + { + _this->_internal_mutable_classroom_message()->::protobuf::MessageOfClassroom::MergeFrom( + from._internal_classroom_message() + ); + break; + } + case kDoorMessage: + { + _this->_internal_mutable_door_message()->::protobuf::MessageOfDoor::MergeFrom( + from._internal_door_message() + ); + break; + } + case kGateMessage: + { + _this->_internal_mutable_gate_message()->::protobuf::MessageOfGate::MergeFrom( + from._internal_gate_message() + ); + break; + } + case kChestMessage: + { + _this->_internal_mutable_chest_message()->::protobuf::MessageOfChest::MergeFrom( + from._internal_chest_message() + ); + break; + } + case MESSAGE_OF_MAP_OBJ_NOT_SET: + { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfMapObj::CopyFrom(const MessageOfMapObj& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfMapObj) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfMapObj::IsInitialized() const + { + return true; + } + + void MessageOfMapObj::InternalSwap(MessageOfMapObj* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.message_of_map_obj_, other->_impl_.message_of_map_obj_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfMapObj::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[10] + ); + } + + // =================================================================== + + class MessageOfMap_Row::_Internal + { + public: + }; + + MessageOfMap_Row::MessageOfMap_Row(::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.MessageOfMap.Row) + } + MessageOfMap_Row::MessageOfMap_Row(const MessageOfMap_Row& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfMap_Row* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.col_){from._impl_.col_}, /*decltype(_impl_._col_cached_byte_size_)*/ {0}, /*decltype(_impl_._cached_size_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfMap.Row) + } + + inline void MessageOfMap_Row::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.col_){arena}, /*decltype(_impl_._col_cached_byte_size_)*/ {0}, /*decltype(_impl_._cached_size_)*/ {}}; + } + + MessageOfMap_Row::~MessageOfMap_Row() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfMap.Row) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfMap_Row::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.col_.~RepeatedField(); + } + + void MessageOfMap_Row::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfMap_Row::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfMap.Row) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + _impl_.col_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfMap_Row::_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) + { + // repeated .protobuf.PlaceType col = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) + { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_col(), ptr, ctx); + CHK_(ptr); + } + else if (static_cast(tag) == 8) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_add_col(static_cast<::protobuf::PlaceType>(val)); + } + 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* MessageOfMap_Row::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfMap.Row) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated .protobuf.PlaceType col = 1; + { + int byte_size = _impl_._col_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) + { + target = stream->WriteEnumPacked( + 1, _impl_.col_, byte_size, 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.MessageOfMap.Row) + return target; + } + + size_t MessageOfMap_Row::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfMap.Row) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .protobuf.PlaceType col = 1; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_col_size()); + for (unsigned int i = 0; i < count; i++) + { + data_size += ::_pbi::WireFormatLite::EnumSize( + this->_internal_col(static_cast(i)) + ); + } + if (data_size > 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._col_cached_byte_size_.store(cached_size, std::memory_order_relaxed); + total_size += data_size; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfMap_Row::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfMap_Row::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfMap_Row::GetClassData() const + { + return &_class_data_; + } + + void MessageOfMap_Row::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfMap.Row) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + _this->_impl_.col_.MergeFrom(from._impl_.col_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfMap_Row::CopyFrom(const MessageOfMap_Row& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfMap.Row) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfMap_Row::IsInitialized() const + { + return true; + } + + void MessageOfMap_Row::InternalSwap(MessageOfMap_Row* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.col_.InternalSwap(&other->_impl_.col_); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfMap_Row::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[11] + ); + } + + // =================================================================== + + class MessageOfMap::_Internal + { + public: + }; + + MessageOfMap::MessageOfMap(::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.MessageOfMap) + } + MessageOfMap::MessageOfMap(const MessageOfMap& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfMap* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.row_){from._impl_.row_}, decltype(_impl_.map_obj_message_){from._impl_.map_obj_message_}, /*decltype(_impl_._cached_size_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfMap) + } + + inline void MessageOfMap::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.row_){arena}, decltype(_impl_.map_obj_message_){arena}, /*decltype(_impl_._cached_size_)*/ {}}; + } + + MessageOfMap::~MessageOfMap() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfMap) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfMap::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.row_.~RepeatedPtrField(); + _impl_.map_obj_message_.~RepeatedPtrField(); + } + + void MessageOfMap::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfMap::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfMap) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + _impl_.row_.Clear(); + _impl_.map_obj_message_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfMap::_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) + { + // repeated .protobuf.MessageOfMap.Row row = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) + { + ptr -= 1; + do + { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_row(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } + else + goto handle_unusual; + continue; + // repeated .protobuf.MessageOfMapObj map_obj_message = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) + { + ptr -= 1; + do + { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_map_obj_message(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(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* MessageOfMap::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfMap) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated .protobuf.MessageOfMap.Row row = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_row_size()); + i < n; + i++) + { + const auto& repfield = this->_internal_row(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .protobuf.MessageOfMapObj map_obj_message = 3; + for (unsigned i = 0, + n = static_cast(this->_internal_map_obj_message_size()); + i < n; + i++) + { + const auto& repfield = this->_internal_map_obj_message(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + 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.MessageOfMap) + return target; + } + + size_t MessageOfMap::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfMap) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .protobuf.MessageOfMap.Row row = 2; + total_size += 1UL * this->_internal_row_size(); + for (const auto& msg : this->_impl_.row_) + { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .protobuf.MessageOfMapObj map_obj_message = 3; + total_size += 1UL * this->_internal_map_obj_message_size(); + for (const auto& msg : this->_impl_.map_obj_message_) + { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfMap::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfMap::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfMap::GetClassData() const + { + return &_class_data_; + } + + void MessageOfMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfMap) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + _this->_impl_.row_.MergeFrom(from._impl_.row_); + _this->_impl_.map_obj_message_.MergeFrom(from._impl_.map_obj_message_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfMap::CopyFrom(const MessageOfMap& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfMap) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfMap::IsInitialized() const + { + return true; + } + + void MessageOfMap::InternalSwap(MessageOfMap* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.row_.InternalSwap(&other->_impl_.row_); + _impl_.map_obj_message_.InternalSwap(&other->_impl_.map_obj_message_); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfMap::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[12] + ); + } + + // =================================================================== + + class MessageOfObj::_Internal + { + public: + static const ::protobuf::MessageOfStudent& student_message(const MessageOfObj* msg); + static const ::protobuf::MessageOfTricker& tricker_message(const MessageOfObj* msg); + static const ::protobuf::MessageOfProp& prop_message(const MessageOfObj* msg); + static const ::protobuf::MessageOfBullet& bullet_message(const MessageOfObj* msg); + static const ::protobuf::MessageOfBombedBullet& bombed_bullet_message(const MessageOfObj* msg); + }; + + const ::protobuf::MessageOfStudent& + MessageOfObj::_Internal::student_message(const MessageOfObj* msg) + { + return *msg->_impl_.message_of_obj_.student_message_; + } + const ::protobuf::MessageOfTricker& + MessageOfObj::_Internal::tricker_message(const MessageOfObj* msg) + { + return *msg->_impl_.message_of_obj_.tricker_message_; + } + const ::protobuf::MessageOfProp& + MessageOfObj::_Internal::prop_message(const MessageOfObj* msg) + { + return *msg->_impl_.message_of_obj_.prop_message_; + } + const ::protobuf::MessageOfBullet& + MessageOfObj::_Internal::bullet_message(const MessageOfObj* msg) + { + return *msg->_impl_.message_of_obj_.bullet_message_; + } + const ::protobuf::MessageOfBombedBullet& + MessageOfObj::_Internal::bombed_bullet_message(const MessageOfObj* msg) + { + return *msg->_impl_.message_of_obj_.bombed_bullet_message_; + } + void MessageOfObj::set_allocated_student_message(::protobuf::MessageOfStudent* student_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_obj(); + if (student_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(student_message); + if (message_arena != submessage_arena) + { + student_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, student_message, submessage_arena + ); + } + set_has_student_message(); + _impl_.message_of_obj_.student_message_ = student_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfObj.student_message) + } + void MessageOfObj::set_allocated_tricker_message(::protobuf::MessageOfTricker* tricker_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_obj(); + if (tricker_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tricker_message); + if (message_arena != submessage_arena) + { + tricker_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tricker_message, submessage_arena + ); + } + set_has_tricker_message(); + _impl_.message_of_obj_.tricker_message_ = tricker_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfObj.tricker_message) + } + void MessageOfObj::set_allocated_prop_message(::protobuf::MessageOfProp* prop_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_obj(); + if (prop_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(prop_message); + if (message_arena != submessage_arena) + { + prop_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, prop_message, submessage_arena + ); + } + set_has_prop_message(); + _impl_.message_of_obj_.prop_message_ = prop_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfObj.prop_message) + } + void MessageOfObj::set_allocated_bullet_message(::protobuf::MessageOfBullet* bullet_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_obj(); + if (bullet_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bullet_message); + if (message_arena != submessage_arena) + { + bullet_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bullet_message, submessage_arena + ); + } + set_has_bullet_message(); + _impl_.message_of_obj_.bullet_message_ = bullet_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfObj.bullet_message) + } + void MessageOfObj::set_allocated_bombed_bullet_message(::protobuf::MessageOfBombedBullet* bombed_bullet_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_message_of_obj(); + if (bombed_bullet_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bombed_bullet_message); + if (message_arena != submessage_arena) + { + bombed_bullet_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bombed_bullet_message, submessage_arena + ); + } + set_has_bombed_bullet_message(); + _impl_.message_of_obj_.bombed_bullet_message_ = bombed_bullet_message; + } + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageOfObj.bombed_bullet_message) + } + MessageOfObj::MessageOfObj(::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.MessageOfObj) + } + MessageOfObj::MessageOfObj(const MessageOfObj& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfObj* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.message_of_obj_){}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_._oneof_case_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_message_of_obj(); + switch (from.message_of_obj_case()) + { + case kStudentMessage: + { + _this->_internal_mutable_student_message()->::protobuf::MessageOfStudent::MergeFrom( + from._internal_student_message() + ); + break; + } + case kTrickerMessage: + { + _this->_internal_mutable_tricker_message()->::protobuf::MessageOfTricker::MergeFrom( + from._internal_tricker_message() + ); + break; + } + case kPropMessage: + { + _this->_internal_mutable_prop_message()->::protobuf::MessageOfProp::MergeFrom( + from._internal_prop_message() + ); + break; + } + case kBulletMessage: + { + _this->_internal_mutable_bullet_message()->::protobuf::MessageOfBullet::MergeFrom( + from._internal_bullet_message() + ); + break; + } + case kBombedBulletMessage: + { + _this->_internal_mutable_bombed_bullet_message()->::protobuf::MessageOfBombedBullet::MergeFrom( + from._internal_bombed_bullet_message() + ); + break; + } + case MESSAGE_OF_OBJ_NOT_SET: + { + break; + } + } + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfObj) + } + + inline void MessageOfObj::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.message_of_obj_){}, /*decltype(_impl_._cached_size_)*/ {}, /*decltype(_impl_._oneof_case_)*/ {}}; + clear_has_message_of_obj(); + } + + MessageOfObj::~MessageOfObj() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfObj) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfObj::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (has_message_of_obj()) + { + clear_message_of_obj(); + } + } + + void MessageOfObj::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfObj::clear_message_of_obj() + { + // @@protoc_insertion_point(one_of_clear_start:protobuf.MessageOfObj) + switch (message_of_obj_case()) + { + case kStudentMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.student_message_; + } + break; + } + case kTrickerMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.tricker_message_; + } + break; + } + case kPropMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.prop_message_; + } + break; + } + case kBulletMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.bullet_message_; + } + break; + } + case kBombedBulletMessage: + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.bombed_bullet_message_; + } + break; + } + case MESSAGE_OF_OBJ_NOT_SET: + { + break; + } + } + _impl_._oneof_case_[0] = MESSAGE_OF_OBJ_NOT_SET; + } + + void MessageOfObj::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfObj) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + clear_message_of_obj(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfObj::_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) + { + // .protobuf.MessageOfStudent student_message = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) + { + ptr = ctx->ParseMessage(_internal_mutable_student_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfTricker tricker_message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) + { + ptr = ctx->ParseMessage(_internal_mutable_tricker_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfProp prop_message = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) + { + ptr = ctx->ParseMessage(_internal_mutable_prop_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfBullet bullet_message = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) + { + ptr = ctx->ParseMessage(_internal_mutable_bullet_message(), ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) + { + ptr = ctx->ParseMessage(_internal_mutable_bombed_bullet_message(), 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* MessageOfObj::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfObj) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // .protobuf.MessageOfStudent student_message = 1; + if (_internal_has_student_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::student_message(this), _Internal::student_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfTricker tricker_message = 2; + if (_internal_has_tricker_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::tricker_message(this), _Internal::tricker_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfProp prop_message = 3; + if (_internal_has_prop_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::prop_message(this), _Internal::prop_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfBullet bullet_message = 4; + if (_internal_has_bullet_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::bullet_message(this), _Internal::bullet_message(this).GetCachedSize(), target, stream); + } + + // .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; + if (_internal_has_bombed_bullet_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::bombed_bullet_message(this), _Internal::bombed_bullet_message(this).GetCachedSize(), target, stream); + } + + 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.MessageOfObj) + return target; + } + + size_t MessageOfObj::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfObj) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (message_of_obj_case()) + { + // .protobuf.MessageOfStudent student_message = 1; + case kStudentMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_obj_.student_message_ + ); + break; + } + // .protobuf.MessageOfTricker tricker_message = 2; + case kTrickerMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_obj_.tricker_message_ + ); + break; + } + // .protobuf.MessageOfProp prop_message = 3; + case kPropMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_obj_.prop_message_ + ); + break; + } + // .protobuf.MessageOfBullet bullet_message = 4; + case kBulletMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_obj_.bullet_message_ + ); + break; + } + // .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; + case kBombedBulletMessage: + { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_of_obj_.bombed_bullet_message_ + ); + break; + } + case MESSAGE_OF_OBJ_NOT_SET: + { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfObj::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageOfObj::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfObj::GetClassData() const + { + return &_class_data_; + } + + void MessageOfObj::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfObj) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (from.message_of_obj_case()) + { + case kStudentMessage: + { + _this->_internal_mutable_student_message()->::protobuf::MessageOfStudent::MergeFrom( + from._internal_student_message() + ); + break; + } + case kTrickerMessage: + { + _this->_internal_mutable_tricker_message()->::protobuf::MessageOfTricker::MergeFrom( + from._internal_tricker_message() + ); + break; + } + case kPropMessage: + { + _this->_internal_mutable_prop_message()->::protobuf::MessageOfProp::MergeFrom( + from._internal_prop_message() + ); + break; + } + case kBulletMessage: + { + _this->_internal_mutable_bullet_message()->::protobuf::MessageOfBullet::MergeFrom( + from._internal_bullet_message() + ); + break; + } + case kBombedBulletMessage: + { + _this->_internal_mutable_bombed_bullet_message()->::protobuf::MessageOfBombedBullet::MergeFrom( + from._internal_bombed_bullet_message() + ); + break; + } + case MESSAGE_OF_OBJ_NOT_SET: + { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void MessageOfObj::CopyFrom(const MessageOfObj& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfObj) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool MessageOfObj::IsInitialized() const + { + return true; + } + + void MessageOfObj::InternalSwap(MessageOfObj* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.message_of_obj_, other->_impl_.message_of_obj_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); + } + + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfObj::GetMetadata() const + { + return ::_pbi::AssignDescriptors( + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[13] + ); + } + + // =================================================================== + + class MessageOfAll::_Internal + { + public: + }; + + MessageOfAll::MessageOfAll(::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.MessageOfAll) + } + MessageOfAll::MessageOfAll(const MessageOfAll& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + MessageOfAll* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.game_time_){}, decltype(_impl_.subject_left_){}, decltype(_impl_.student_graduated_){}, decltype(_impl_.student_quited_){}, decltype(_impl_.student_score_){}, decltype(_impl_.tricker_score_){}, decltype(_impl_.gate_opened_){}, decltype(_impl_.hidden_gate_refreshed_){}, decltype(_impl_.hidden_gate_opened_){}, /*decltype(_impl_._cached_size_)*/ {}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.game_time_, &from._impl_.game_time_, static_cast(reinterpret_cast(&_impl_.hidden_gate_opened_) - reinterpret_cast(&_impl_.game_time_)) + sizeof(_impl_.hidden_gate_opened_)); + // @@protoc_insertion_point(copy_constructor:protobuf.MessageOfAll) + } + + inline void MessageOfAll::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned + ) + { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.game_time_){0}, decltype(_impl_.subject_left_){0}, decltype(_impl_.student_graduated_){0}, decltype(_impl_.student_quited_){0}, decltype(_impl_.student_score_){0}, decltype(_impl_.tricker_score_){0}, decltype(_impl_.gate_opened_){false}, decltype(_impl_.hidden_gate_refreshed_){false}, decltype(_impl_.hidden_gate_opened_){false}, /*decltype(_impl_._cached_size_)*/ {}}; + } + + MessageOfAll::~MessageOfAll() + { + // @@protoc_insertion_point(destructor:protobuf.MessageOfAll) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void MessageOfAll::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + } + + void MessageOfAll::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void MessageOfAll::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.MessageOfAll) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::memset(&_impl_.game_time_, 0, static_cast(reinterpret_cast(&_impl_.hidden_gate_opened_) - reinterpret_cast(&_impl_.game_time_)) + sizeof(_impl_.hidden_gate_opened_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* MessageOfAll::_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) + { + // int32 game_time = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) + { + _impl_.game_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 subject_left = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + _impl_.subject_left_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 student_graduated = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.student_graduated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 student_quited = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) + { + _impl_.student_quited_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 student_score = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) + { + _impl_.student_score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // int32 tricker_score = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) + { + _impl_.tricker_score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // bool gate_opened = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) + { + _impl_.gate_opened_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // bool hidden_gate_refreshed = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) + { + _impl_.hidden_gate_refreshed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // bool hidden_gate_opened = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) + { + _impl_.hidden_gate_opened_ = ::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* MessageOfAll::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.MessageOfAll) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // int32 game_time = 1; + if (this->_internal_game_time() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_game_time(), target); + } + + // int32 subject_left = 2; + if (this->_internal_subject_left() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_subject_left(), target); + } + + // int32 student_graduated = 3; + if (this->_internal_student_graduated() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_student_graduated(), target); + } + + // int32 student_quited = 4; + if (this->_internal_student_quited() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_student_quited(), target); + } + + // int32 student_score = 5; + if (this->_internal_student_score() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_student_score(), target); + } - // repeated .protobuf.MessageOfMap.Row row = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_row_size()); - i < n; - i++) + // int32 tricker_score = 6; + if (this->_internal_tricker_score() != 0) { - const auto& repfield = this->_internal_row(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_tricker_score(), target); + } + + // bool gate_opened = 7; + if (this->_internal_gate_opened() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_gate_opened(), target); + } + + // bool hidden_gate_refreshed = 8; + if (this->_internal_hidden_gate_refreshed() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_hidden_gate_refreshed(), target); + } + + // bool hidden_gate_opened = 9; + if (this->_internal_hidden_gate_opened() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_hidden_gate_opened(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) @@ -3883,76 +7028,161 @@ namespace protobuf _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream ); } - // @@protoc_insertion_point(serialize_to_array_end:protobuf.MessageOfMap) + // @@protoc_insertion_point(serialize_to_array_end:protobuf.MessageOfAll) return target; } - size_t MessageOfMap::ByteSizeLong() const + size_t MessageOfAll::ByteSizeLong() const { - // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfMap) + // @@protoc_insertion_point(message_byte_size_start:protobuf.MessageOfAll) size_t total_size = 0; uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - // repeated .protobuf.MessageOfMap.Row row = 2; - total_size += 1UL * this->_internal_row_size(); - for (const auto& msg : this->_impl_.row_) + // int32 game_time = 1; + if (this->_internal_game_time() != 0) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_game_time()); + } + + // int32 subject_left = 2; + if (this->_internal_subject_left() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_subject_left()); + } + + // int32 student_graduated = 3; + if (this->_internal_student_graduated() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_student_graduated()); + } + + // int32 student_quited = 4; + if (this->_internal_student_quited() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_student_quited()); + } + + // int32 student_score = 5; + if (this->_internal_student_score() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_student_score()); + } + + // int32 tricker_score = 6; + if (this->_internal_tricker_score() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_tricker_score()); + } + + // bool gate_opened = 7; + if (this->_internal_gate_opened() != 0) + { + total_size += 1 + 1; + } + + // bool hidden_gate_refreshed = 8; + if (this->_internal_hidden_gate_refreshed() != 0) + { + total_size += 1 + 1; + } + + // bool hidden_gate_opened = 9; + if (this->_internal_hidden_gate_opened() != 0) + { + total_size += 1 + 1; } return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfMap::_class_data_ = { + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageOfAll::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MessageOfMap::MergeImpl}; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfMap::GetClassData() const + MessageOfAll::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* MessageOfAll::GetClassData() const { return &_class_data_; } - void MessageOfMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + void MessageOfAll::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfMap) + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.MessageOfAll) GOOGLE_DCHECK_NE(&from, _this); uint32_t cached_has_bits = 0; (void)cached_has_bits; - _this->_impl_.row_.MergeFrom(from._impl_.row_); + if (from._internal_game_time() != 0) + { + _this->_internal_set_game_time(from._internal_game_time()); + } + if (from._internal_subject_left() != 0) + { + _this->_internal_set_subject_left(from._internal_subject_left()); + } + if (from._internal_student_graduated() != 0) + { + _this->_internal_set_student_graduated(from._internal_student_graduated()); + } + if (from._internal_student_quited() != 0) + { + _this->_internal_set_student_quited(from._internal_student_quited()); + } + if (from._internal_student_score() != 0) + { + _this->_internal_set_student_score(from._internal_student_score()); + } + if (from._internal_tricker_score() != 0) + { + _this->_internal_set_tricker_score(from._internal_tricker_score()); + } + if (from._internal_gate_opened() != 0) + { + _this->_internal_set_gate_opened(from._internal_gate_opened()); + } + if (from._internal_hidden_gate_refreshed() != 0) + { + _this->_internal_set_hidden_gate_refreshed(from._internal_hidden_gate_refreshed()); + } + if (from._internal_hidden_gate_opened() != 0) + { + _this->_internal_set_hidden_gate_opened(from._internal_hidden_gate_opened()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } - void MessageOfMap::CopyFrom(const MessageOfMap& from) + void MessageOfAll::CopyFrom(const MessageOfAll& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfMap) + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.MessageOfAll) if (&from == this) return; Clear(); MergeFrom(from); } - bool MessageOfMap::IsInitialized() const + bool MessageOfAll::IsInitialized() const { return true; } - void MessageOfMap::InternalSwap(MessageOfMap* other) + void MessageOfAll::InternalSwap(MessageOfAll* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.row_.InternalSwap(&other->_impl_.row_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MessageOfAll, _impl_.hidden_gate_opened_) + sizeof(MessageOfAll::_impl_.hidden_gate_opened_) - PROTOBUF_FIELD_OFFSET(MessageOfAll, _impl_.game_time_)>( + reinterpret_cast(&_impl_.game_time_), + reinterpret_cast(&other->_impl_.game_time_) + ); } - ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfMap::GetMetadata() const + ::PROTOBUF_NAMESPACE_ID::Metadata MessageOfAll::GetMetadata() const { return ::_pbi::AssignDescriptors( - &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[7] + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[14] ); } @@ -3962,6 +7192,7 @@ namespace protobuf { public: static const ::protobuf::MessageOfMap& map_message(const MessageToClient* msg); + static const ::protobuf::MessageOfAll& all_message(const MessageToClient* msg); }; const ::protobuf::MessageOfMap& @@ -3969,6 +7200,11 @@ namespace protobuf { return *msg->_impl_.map_message_; } + const ::protobuf::MessageOfAll& + MessageToClient::_Internal::all_message(const MessageToClient* msg) + { + return *msg->_impl_.all_message_; + } MessageToClient::MessageToClient(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { @@ -3981,13 +7217,17 @@ namespace protobuf MessageToClient* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.student_message_){from._impl_.student_message_}, decltype(_impl_.tricker_message_){from._impl_.tricker_message_}, decltype(_impl_.prop_message_){from._impl_.prop_message_}, decltype(_impl_.bullet_message_){from._impl_.bullet_message_}, decltype(_impl_.bombed_bullet_message_){from._impl_.bombed_bullet_message_}, decltype(_impl_.map_message_){nullptr}, decltype(_impl_.game_state_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.obj_message_){from._impl_.obj_message_}, decltype(_impl_.map_message_){nullptr}, decltype(_impl_.all_message_){nullptr}, decltype(_impl_.game_state_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_map_message()) { _this->_impl_.map_message_ = new ::protobuf::MessageOfMap(*from._impl_.map_message_); } + if (from._internal_has_all_message()) + { + _this->_impl_.all_message_ = new ::protobuf::MessageOfAll(*from._impl_.all_message_); + } _this->_impl_.game_state_ = from._impl_.game_state_; // @@protoc_insertion_point(copy_constructor:protobuf.MessageToClient) } @@ -3999,7 +7239,7 @@ namespace protobuf (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.student_message_){arena}, decltype(_impl_.tricker_message_){arena}, decltype(_impl_.prop_message_){arena}, decltype(_impl_.bullet_message_){arena}, decltype(_impl_.bombed_bullet_message_){arena}, decltype(_impl_.map_message_){nullptr}, decltype(_impl_.game_state_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.obj_message_){arena}, decltype(_impl_.map_message_){nullptr}, decltype(_impl_.all_message_){nullptr}, decltype(_impl_.game_state_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } MessageToClient::~MessageToClient() @@ -4016,13 +7256,11 @@ namespace protobuf inline void MessageToClient::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.student_message_.~RepeatedPtrField(); - _impl_.tricker_message_.~RepeatedPtrField(); - _impl_.prop_message_.~RepeatedPtrField(); - _impl_.bullet_message_.~RepeatedPtrField(); - _impl_.bombed_bullet_message_.~RepeatedPtrField(); + _impl_.obj_message_.~RepeatedPtrField(); if (this != internal_default_instance()) delete _impl_.map_message_; + if (this != internal_default_instance()) + delete _impl_.all_message_; } void MessageToClient::SetCachedSize(int size) const @@ -4037,16 +7275,17 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - _impl_.student_message_.Clear(); - _impl_.tricker_message_.Clear(); - _impl_.prop_message_.Clear(); - _impl_.bullet_message_.Clear(); - _impl_.bombed_bullet_message_.Clear(); + _impl_.obj_message_.Clear(); if (GetArenaForAllocation() == nullptr && _impl_.map_message_ != nullptr) { delete _impl_.map_message_; } _impl_.map_message_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.all_message_ != nullptr) + { + delete _impl_.all_message_; + } + _impl_.all_message_ = nullptr; _impl_.game_state_ = 0; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4062,7 +7301,7 @@ namespace protobuf ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .protobuf.MessageOfStudent student_message = 1; + // repeated .protobuf.MessageOfObj obj_message = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { @@ -4070,7 +7309,7 @@ namespace protobuf do { ptr += 1; - ptr = ctx->ParseMessage(_internal_add_student_message(), ptr); + ptr = ctx->ParseMessage(_internal_add_obj_message(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; @@ -4079,91 +7318,33 @@ namespace protobuf else goto handle_unusual; continue; - // repeated .protobuf.MessageOfTricker tricker_message = 2; + // .protobuf.MessageOfMap map_message = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do - { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_tricker_message(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) - break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + ptr = ctx->ParseMessage(_internal_mutable_map_message(), ptr); + CHK_(ptr); } else goto handle_unusual; continue; - // repeated .protobuf.MessageOfProp prop_message = 3; + // .protobuf.GameState game_state = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - ptr -= 1; - do - { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_prop_message(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) - break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_game_state(static_cast<::protobuf::GameState>(val)); } else goto handle_unusual; continue; - // repeated .protobuf.MessageOfBullet bullet_message = 4; + // .protobuf.MessageOfAll all_message = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr -= 1; - do - { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_bullet_message(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) - break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } - else - goto handle_unusual; - continue; - // repeated .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) - { - ptr -= 1; - do - { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_bombed_bullet_message(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) - break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); - } - else - goto handle_unusual; - continue; - // .protobuf.MessageOfMap map_message = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) - { - ptr = ctx->ParseMessage(_internal_mutable_map_message(), ptr); - CHK_(ptr); - } - else - goto handle_unusual; - continue; - // .protobuf.GameState game_state = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) - { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + ptr = ctx->ParseMessage(_internal_mutable_all_message(), ptr); CHK_(ptr); - _internal_set_game_state(static_cast<::protobuf::GameState>(val)); } else goto handle_unusual; @@ -4202,77 +7383,40 @@ namespace protobuf uint32_t cached_has_bits = 0; (void)cached_has_bits; - // repeated .protobuf.MessageOfStudent student_message = 1; + // repeated .protobuf.MessageOfObj obj_message = 1; for (unsigned i = 0, - n = static_cast(this->_internal_student_message_size()); + n = static_cast(this->_internal_obj_message_size()); i < n; i++) { - const auto& repfield = this->_internal_student_message(i); + const auto& repfield = this->_internal_obj_message(i); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); } - // repeated .protobuf.MessageOfTricker tricker_message = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_tricker_message_size()); - i < n; - i++) - { - const auto& repfield = this->_internal_tricker_message(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - // repeated .protobuf.MessageOfProp prop_message = 3; - for (unsigned i = 0, - n = static_cast(this->_internal_prop_message_size()); - i < n; - i++) - { - const auto& repfield = this->_internal_prop_message(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); - } - - // repeated .protobuf.MessageOfBullet bullet_message = 4; - for (unsigned i = 0, - n = static_cast(this->_internal_bullet_message_size()); - i < n; - i++) - { - const auto& repfield = this->_internal_bullet_message(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); - } - - // repeated .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; - for (unsigned i = 0, - n = static_cast(this->_internal_bombed_bullet_message_size()); - i < n; - i++) - { - const auto& repfield = this->_internal_bombed_bullet_message(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); - } - - // .protobuf.MessageOfMap map_message = 6; + // .protobuf.MessageOfMap map_message = 2; if (this->_internal_has_map_message()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::map_message(this), _Internal::map_message(this).GetCachedSize(), target, stream); + InternalWriteMessage(2, _Internal::map_message(this), _Internal::map_message(this).GetCachedSize(), target, stream); } - // .protobuf.GameState game_state = 7; + // .protobuf.GameState game_state = 3; if (this->_internal_game_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( - 7, this->_internal_game_state(), target + 3, this->_internal_game_state(), target ); } + // .protobuf.MessageOfAll all_message = 4; + if (this->_internal_has_all_message()) + { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::all_message(this), _Internal::all_message(this).GetCachedSize(), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -4292,56 +7436,33 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - // repeated .protobuf.MessageOfStudent student_message = 1; - total_size += 1UL * this->_internal_student_message_size(); - for (const auto& msg : this->_impl_.student_message_) - { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .protobuf.MessageOfTricker tricker_message = 2; - total_size += 1UL * this->_internal_tricker_message_size(); - for (const auto& msg : this->_impl_.tricker_message_) - { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .protobuf.MessageOfProp prop_message = 3; - total_size += 1UL * this->_internal_prop_message_size(); - for (const auto& msg : this->_impl_.prop_message_) - { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .protobuf.MessageOfBullet bullet_message = 4; - total_size += 1UL * this->_internal_bullet_message_size(); - for (const auto& msg : this->_impl_.bullet_message_) + // repeated .protobuf.MessageOfObj obj_message = 1; + total_size += 1UL * this->_internal_obj_message_size(); + for (const auto& msg : this->_impl_.obj_message_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; - total_size += 1UL * this->_internal_bombed_bullet_message_size(); - for (const auto& msg : this->_impl_.bombed_bullet_message_) + // .protobuf.MessageOfMap map_message = 2; + if (this->_internal_has_map_message()) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.map_message_ + ); } - // .protobuf.MessageOfMap map_message = 6; - if (this->_internal_has_map_message()) + // .protobuf.MessageOfAll all_message = 4; + if (this->_internal_has_all_message()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.map_message_ + *_impl_.all_message_ ); } - // .protobuf.GameState game_state = 7; + // .protobuf.GameState game_state = 3; if (this->_internal_game_state() != 0) { total_size += 1 + @@ -4368,17 +7489,19 @@ namespace protobuf uint32_t cached_has_bits = 0; (void)cached_has_bits; - _this->_impl_.student_message_.MergeFrom(from._impl_.student_message_); - _this->_impl_.tricker_message_.MergeFrom(from._impl_.tricker_message_); - _this->_impl_.prop_message_.MergeFrom(from._impl_.prop_message_); - _this->_impl_.bullet_message_.MergeFrom(from._impl_.bullet_message_); - _this->_impl_.bombed_bullet_message_.MergeFrom(from._impl_.bombed_bullet_message_); + _this->_impl_.obj_message_.MergeFrom(from._impl_.obj_message_); if (from._internal_has_map_message()) { _this->_internal_mutable_map_message()->::protobuf::MessageOfMap::MergeFrom( from._internal_map_message() ); } + if (from._internal_has_all_message()) + { + _this->_internal_mutable_all_message()->::protobuf::MessageOfAll::MergeFrom( + from._internal_all_message() + ); + } if (from._internal_game_state() != 0) { _this->_internal_set_game_state(from._internal_game_state()); @@ -4404,11 +7527,7 @@ namespace protobuf { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.student_message_.InternalSwap(&other->_impl_.student_message_); - _impl_.tricker_message_.InternalSwap(&other->_impl_.tricker_message_); - _impl_.prop_message_.InternalSwap(&other->_impl_.prop_message_); - _impl_.bullet_message_.InternalSwap(&other->_impl_.bullet_message_); - _impl_.bombed_bullet_message_.InternalSwap(&other->_impl_.bombed_bullet_message_); + _impl_.obj_message_.InternalSwap(&other->_impl_.obj_message_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(MessageToClient, _impl_.game_state_) + sizeof(MessageToClient::_impl_.game_state_) - PROTOBUF_FIELD_OFFSET(MessageToClient, _impl_.map_message_)>( reinterpret_cast(&_impl_.map_message_), @@ -4419,7 +7538,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::Metadata MessageToClient::GetMetadata() const { return ::_pbi::AssignDescriptors( - &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[8] + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[15] ); } @@ -4699,7 +7818,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::Metadata MoveRes::GetMetadata() const { return ::_pbi::AssignDescriptors( - &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[9] + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[16] ); } @@ -4909,7 +8028,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::Metadata BoolRes::GetMetadata() const { return ::_pbi::AssignDescriptors( - &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[10] + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[17] ); } @@ -5205,7 +8324,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::Metadata MsgRes::GetMetadata() const { return ::_pbi::AssignDescriptors( - &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[11] + &descriptor_table_Message2Clients_2eproto_getter, &descriptor_table_Message2Clients_2eproto_once, file_level_metadata_Message2Clients_2eproto[18] ); } @@ -5249,6 +8368,36 @@ PROTOBUF_NOINLINE ::protobuf::MessageOfPickedProp* return Arena::CreateMessageInternal<::protobuf::MessageOfPickedProp>(arena); } template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfClassroom* + Arena::CreateMaybeMessage<::protobuf::MessageOfClassroom>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfClassroom>(arena); +} +template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfGate* + Arena::CreateMaybeMessage<::protobuf::MessageOfGate>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfGate>(arena); +} +template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfDoor* + Arena::CreateMaybeMessage<::protobuf::MessageOfDoor>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfDoor>(arena); +} +template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfChest* + Arena::CreateMaybeMessage<::protobuf::MessageOfChest>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfChest>(arena); +} +template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfMapObj* + Arena::CreateMaybeMessage<::protobuf::MessageOfMapObj>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfMapObj>(arena); +} +template<> PROTOBUF_NOINLINE ::protobuf::MessageOfMap_Row* Arena::CreateMaybeMessage<::protobuf::MessageOfMap_Row>(Arena* arena) { @@ -5261,6 +8410,18 @@ PROTOBUF_NOINLINE ::protobuf::MessageOfMap* return Arena::CreateMessageInternal<::protobuf::MessageOfMap>(arena); } template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfObj* + Arena::CreateMaybeMessage<::protobuf::MessageOfObj>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfObj>(arena); +} +template<> +PROTOBUF_NOINLINE ::protobuf::MessageOfAll* + Arena::CreateMaybeMessage<::protobuf::MessageOfAll>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::MessageOfAll>(arena); +} +template<> PROTOBUF_NOINLINE ::protobuf::MessageToClient* Arena::CreateMaybeMessage<::protobuf::MessageToClient>(Arena* arena) { diff --git a/CAPI/proto/Message2Clients.pb.h b/CAPI/cpp/proto/Message2Clients.pb.h similarity index 55% rename from CAPI/proto/Message2Clients.pb.h rename to CAPI/cpp/proto/Message2Clients.pb.h index 2a337bd..bd4288f 100644 --- a/CAPI/proto/Message2Clients.pb.h +++ b/CAPI/cpp/proto/Message2Clients.pb.h @@ -52,18 +52,39 @@ namespace protobuf class BoolRes; struct BoolResDefaultTypeInternal; extern BoolResDefaultTypeInternal _BoolRes_default_instance_; + class MessageOfAll; + struct MessageOfAllDefaultTypeInternal; + extern MessageOfAllDefaultTypeInternal _MessageOfAll_default_instance_; class MessageOfBombedBullet; struct MessageOfBombedBulletDefaultTypeInternal; extern MessageOfBombedBulletDefaultTypeInternal _MessageOfBombedBullet_default_instance_; class MessageOfBullet; struct MessageOfBulletDefaultTypeInternal; extern MessageOfBulletDefaultTypeInternal _MessageOfBullet_default_instance_; + class MessageOfChest; + struct MessageOfChestDefaultTypeInternal; + extern MessageOfChestDefaultTypeInternal _MessageOfChest_default_instance_; + class MessageOfClassroom; + struct MessageOfClassroomDefaultTypeInternal; + extern MessageOfClassroomDefaultTypeInternal _MessageOfClassroom_default_instance_; + class MessageOfDoor; + struct MessageOfDoorDefaultTypeInternal; + extern MessageOfDoorDefaultTypeInternal _MessageOfDoor_default_instance_; + class MessageOfGate; + struct MessageOfGateDefaultTypeInternal; + extern MessageOfGateDefaultTypeInternal _MessageOfGate_default_instance_; class MessageOfMap; struct MessageOfMapDefaultTypeInternal; extern MessageOfMapDefaultTypeInternal _MessageOfMap_default_instance_; + class MessageOfMapObj; + struct MessageOfMapObjDefaultTypeInternal; + extern MessageOfMapObjDefaultTypeInternal _MessageOfMapObj_default_instance_; class MessageOfMap_Row; struct MessageOfMap_RowDefaultTypeInternal; extern MessageOfMap_RowDefaultTypeInternal _MessageOfMap_Row_default_instance_; + class MessageOfObj; + struct MessageOfObjDefaultTypeInternal; + extern MessageOfObjDefaultTypeInternal _MessageOfObj_default_instance_; class MessageOfPickedProp; struct MessageOfPickedPropDefaultTypeInternal; extern MessageOfPickedPropDefaultTypeInternal _MessageOfPickedProp_default_instance_; @@ -90,14 +111,28 @@ PROTOBUF_NAMESPACE_OPEN template<> ::protobuf::BoolRes* Arena::CreateMaybeMessage<::protobuf::BoolRes>(Arena*); template<> +::protobuf::MessageOfAll* Arena::CreateMaybeMessage<::protobuf::MessageOfAll>(Arena*); +template<> ::protobuf::MessageOfBombedBullet* Arena::CreateMaybeMessage<::protobuf::MessageOfBombedBullet>(Arena*); template<> ::protobuf::MessageOfBullet* Arena::CreateMaybeMessage<::protobuf::MessageOfBullet>(Arena*); template<> +::protobuf::MessageOfChest* Arena::CreateMaybeMessage<::protobuf::MessageOfChest>(Arena*); +template<> +::protobuf::MessageOfClassroom* Arena::CreateMaybeMessage<::protobuf::MessageOfClassroom>(Arena*); +template<> +::protobuf::MessageOfDoor* Arena::CreateMaybeMessage<::protobuf::MessageOfDoor>(Arena*); +template<> +::protobuf::MessageOfGate* Arena::CreateMaybeMessage<::protobuf::MessageOfGate>(Arena*); +template<> ::protobuf::MessageOfMap* Arena::CreateMaybeMessage<::protobuf::MessageOfMap>(Arena*); template<> +::protobuf::MessageOfMapObj* Arena::CreateMaybeMessage<::protobuf::MessageOfMapObj>(Arena*); +template<> ::protobuf::MessageOfMap_Row* Arena::CreateMaybeMessage<::protobuf::MessageOfMap_Row>(Arena*); template<> +::protobuf::MessageOfObj* Arena::CreateMaybeMessage<::protobuf::MessageOfObj>(Arena*); +template<> ::protobuf::MessageOfPickedProp* Arena::CreateMaybeMessage<::protobuf::MessageOfPickedProp>(Arena*); template<> ::protobuf::MessageOfProp* Arena::CreateMaybeMessage<::protobuf::MessageOfProp>(Arena*); @@ -275,7 +310,8 @@ namespace protobuf enum : int { - kBuffFieldNumber = 19, + kPropFieldNumber = 8, + kBuffFieldNumber = 24, kXFieldNumber = 1, kYFieldNumber = 2, kSpeedFieldNumber = 3, @@ -283,18 +319,43 @@ namespace protobuf kTimeUntilSkillAvailableFieldNumber = 6, kFailNumFieldNumber = 5, kPlaceFieldNumber = 7, - kPropFieldNumber = 8, - kStudentTypeFieldNumber = 9, kGuidFieldNumber = 10, - kFailTimeFieldNumber = 12, + kPlayerStateFieldNumber = 9, kStateFieldNumber = 11, - kViewRangeFieldNumber = 16, + kFailTimeFieldNumber = 12, kEmoTimeFieldNumber = 14, kPlayerIdFieldNumber = 15, + kViewRangeFieldNumber = 16, kRadiusFieldNumber = 17, + kDangerAlertFieldNumber = 19, kDamageFieldNumber = 18, + kScoreFieldNumber = 20, + kTreatProgressFieldNumber = 21, + kRescueProgressFieldNumber = 22, + kStudentTypeFieldNumber = 23, }; - // repeated .protobuf.StudentBuffType buff = 19; + // repeated .protobuf.PropType prop = 8; + int prop_size() const; + + private: + int _internal_prop_size() const; + + public: + void clear_prop(); + + private: + ::protobuf::PropType _internal_prop(int index) const; + void _internal_add_prop(::protobuf::PropType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_prop(); + + public: + ::protobuf::PropType prop(int index) const; + void set_prop(int index, ::protobuf::PropType value); + void add_prop(::protobuf::PropType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& prop() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_prop(); + + // repeated .protobuf.StudentBuffType buff = 24; int buff_size() const; private: @@ -384,26 +445,6 @@ namespace protobuf ::protobuf::PlaceType _internal_place() const; void _internal_set_place(::protobuf::PlaceType value); - public: - // .protobuf.PropType prop = 8; - void clear_prop(); - ::protobuf::PropType prop() const; - void set_prop(::protobuf::PropType value); - - private: - ::protobuf::PropType _internal_prop() const; - void _internal_set_prop(::protobuf::PropType value); - - public: - // .protobuf.StudentType student_type = 9; - void clear_student_type(); - ::protobuf::StudentType student_type() const; - void set_student_type(::protobuf::StudentType value); - - private: - ::protobuf::StudentType _internal_student_type() const; - void _internal_set_student_type(::protobuf::StudentType value); - public: // int64 guid = 10; void clear_guid(); @@ -415,34 +456,34 @@ namespace protobuf void _internal_set_guid(int64_t value); public: - // double fail_time = 12; - void clear_fail_time(); - double fail_time() const; - void set_fail_time(double value); + // .protobuf.PlayerState player_state = 9; + void clear_player_state(); + ::protobuf::PlayerState player_state() const; + void set_player_state(::protobuf::PlayerState value); private: - double _internal_fail_time() const; - void _internal_set_fail_time(double value); + ::protobuf::PlayerState _internal_player_state() const; + void _internal_set_player_state(::protobuf::PlayerState value); public: - // .protobuf.StudentState state = 11; + // .protobuf.PlayerState state = 11; void clear_state(); - ::protobuf::StudentState state() const; - void set_state(::protobuf::StudentState value); + ::protobuf::PlayerState state() const; + void set_state(::protobuf::PlayerState value); private: - ::protobuf::StudentState _internal_state() const; - void _internal_set_state(::protobuf::StudentState value); + ::protobuf::PlayerState _internal_state() const; + void _internal_set_state(::protobuf::PlayerState value); public: - // int32 view_range = 16; - void clear_view_range(); - int32_t view_range() const; - void set_view_range(int32_t value); + // double fail_time = 12; + void clear_fail_time(); + double fail_time() const; + void set_fail_time(double value); private: - int32_t _internal_view_range() const; - void _internal_set_view_range(int32_t value); + double _internal_fail_time() const; + void _internal_set_fail_time(double value); public: // double emo_time = 14; @@ -464,6 +505,16 @@ namespace protobuf int64_t _internal_player_id() const; void _internal_set_player_id(int64_t value); + public: + // int32 view_range = 16; + void clear_view_range(); + int32_t view_range() const; + void set_view_range(int32_t value); + + private: + int32_t _internal_view_range() const; + void _internal_set_view_range(int32_t value); + public: // int32 radius = 17; void clear_radius(); @@ -474,6 +525,16 @@ namespace protobuf int32_t _internal_radius() const; void _internal_set_radius(int32_t value); + public: + // double danger_alert = 19; + void clear_danger_alert(); + double danger_alert() const; + void set_danger_alert(double value); + + private: + double _internal_danger_alert() const; + void _internal_set_danger_alert(double value); + public: // int32 damage = 18; void clear_damage(); @@ -484,6 +545,46 @@ namespace protobuf int32_t _internal_damage() const; void _internal_set_damage(int32_t value); + public: + // int32 score = 20; + void clear_score(); + int32_t score() const; + void set_score(int32_t value); + + private: + int32_t _internal_score() const; + void _internal_set_score(int32_t value); + + public: + // int32 treat_progress = 21; + void clear_treat_progress(); + int32_t treat_progress() const; + void set_treat_progress(int32_t value); + + private: + int32_t _internal_treat_progress() const; + void _internal_set_treat_progress(int32_t value); + + public: + // int32 rescue_progress = 22; + void clear_rescue_progress(); + int32_t rescue_progress() const; + void set_rescue_progress(int32_t value); + + private: + int32_t _internal_rescue_progress() const; + void _internal_set_rescue_progress(int32_t value); + + public: + // .protobuf.StudentType student_type = 23; + void clear_student_type(); + ::protobuf::StudentType student_type() const; + void set_student_type(::protobuf::StudentType value); + + private: + ::protobuf::StudentType _internal_student_type() const; + void _internal_set_student_type(::protobuf::StudentType value); + public: // @@protoc_insertion_point(class_scope:protobuf.MessageOfStudent) @@ -496,6 +597,8 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedField prop_; + mutable std::atomic _prop_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField buff_; mutable std::atomic _buff_cached_byte_size_; int32_t x_; @@ -505,16 +608,20 @@ namespace protobuf double time_until_skill_available_; int32_t fail_num_; int place_; - int prop_; - int student_type_; int64_t guid_; - double fail_time_; + int player_state_; int state_; - int32_t view_range_; + double fail_time_; double emo_time_; int64_t player_id_; + int32_t view_range_; int32_t radius_; + double danger_alert_; int32_t damage_; + int32_t score_; + int32_t treat_progress_; + int32_t rescue_progress_; + int student_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -683,22 +790,46 @@ namespace protobuf enum : int { - kBuffFieldNumber = 14, + kPropFieldNumber = 7, + kBuffFieldNumber = 17, kXFieldNumber = 1, kYFieldNumber = 2, kSpeedFieldNumber = 3, kDamageFieldNumber = 4, kTimeUntilSkillAvailableFieldNumber = 5, kPlaceFieldNumber = 6, - kPropFieldNumber = 7, - kGuidFieldNumber = 9, kTrickerTypeFieldNumber = 8, - kMovableFieldNumber = 10, + kGuidFieldNumber = 9, kPlayerIdFieldNumber = 11, + kMovableFieldNumber = 10, kViewRangeFieldNumber = 12, kRadiusFieldNumber = 13, + kPlayerStateFieldNumber = 14, + kTrickDesireFieldNumber = 15, + kClassVolumeFieldNumber = 16, }; - // repeated .protobuf.TrickerBuffType buff = 14; + // repeated .protobuf.PropType prop = 7; + int prop_size() const; + + private: + int _internal_prop_size() const; + + public: + void clear_prop(); + + private: + ::protobuf::PropType _internal_prop(int index) const; + void _internal_add_prop(::protobuf::PropType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_prop(); + + public: + ::protobuf::PropType prop(int index) const; + void set_prop(int index, ::protobuf::PropType value); + void add_prop(::protobuf::PropType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& prop() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_prop(); + + // repeated .protobuf.TrickerBuffType buff = 17; int buff_size() const; private: @@ -779,14 +910,14 @@ namespace protobuf void _internal_set_place(::protobuf::PlaceType value); public: - // .protobuf.PropType prop = 7; - void clear_prop(); - ::protobuf::PropType prop() const; - void set_prop(::protobuf::PropType value); + // .protobuf.TrickerType tricker_type = 8; + void clear_tricker_type(); + ::protobuf::TrickerType tricker_type() const; + void set_tricker_type(::protobuf::TrickerType value); private: - ::protobuf::PropType _internal_prop() const; - void _internal_set_prop(::protobuf::PropType value); + ::protobuf::TrickerType _internal_tricker_type() const; + void _internal_set_tricker_type(::protobuf::TrickerType value); public: // int64 guid = 9; @@ -799,14 +930,14 @@ namespace protobuf void _internal_set_guid(int64_t value); public: - // .protobuf.TrickerType tricker_type = 8; - void clear_tricker_type(); - ::protobuf::TrickerType tricker_type() const; - void set_tricker_type(::protobuf::TrickerType value); + // int64 player_id = 11; + void clear_player_id(); + int64_t player_id() const; + void set_player_id(int64_t value); private: - ::protobuf::TrickerType _internal_tricker_type() const; - void _internal_set_tricker_type(::protobuf::TrickerType value); + int64_t _internal_player_id() const; + void _internal_set_player_id(int64_t value); public: // bool movable = 10; @@ -818,16 +949,6 @@ namespace protobuf bool _internal_movable() const; void _internal_set_movable(bool value); - public: - // int64 player_id = 11; - 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: // int32 view_range = 12; void clear_view_range(); @@ -848,6 +969,36 @@ namespace protobuf int32_t _internal_radius() const; void _internal_set_radius(int32_t value); + public: + // .protobuf.PlayerState player_state = 14; + void clear_player_state(); + ::protobuf::PlayerState player_state() const; + void set_player_state(::protobuf::PlayerState value); + + private: + ::protobuf::PlayerState _internal_player_state() const; + void _internal_set_player_state(::protobuf::PlayerState value); + + public: + // double trick_desire = 15; + void clear_trick_desire(); + double trick_desire() const; + void set_trick_desire(double value); + + private: + double _internal_trick_desire() const; + void _internal_set_trick_desire(double value); + + public: + // double class_volume = 16; + void clear_class_volume(); + double class_volume() const; + void set_class_volume(double value); + + private: + double _internal_class_volume() const; + void _internal_set_class_volume(double value); + public: // @@protoc_insertion_point(class_scope:protobuf.MessageOfTricker) @@ -860,6 +1011,8 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedField prop_; + mutable std::atomic _prop_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField buff_; mutable std::atomic _buff_cached_byte_size_; int32_t x_; @@ -868,13 +1021,15 @@ namespace protobuf int32_t damage_; double time_until_skill_available_; int place_; - int prop_; - int64_t guid_; int tricker_type_; - bool movable_; + int64_t guid_; int64_t player_id_; + bool movable_; int32_t view_range_; int32_t radius_; + int player_state_; + double trick_desire_; + double class_volume_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -1929,31 +2084,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class MessageOfMap_Row final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfMap.Row) */ + class MessageOfClassroom final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfClassroom) */ { public: - inline MessageOfMap_Row() : - MessageOfMap_Row(nullptr) + inline MessageOfClassroom() : + MessageOfClassroom(nullptr) { } - ~MessageOfMap_Row() override; - explicit PROTOBUF_CONSTEXPR MessageOfMap_Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~MessageOfClassroom() override; + explicit PROTOBUF_CONSTEXPR MessageOfClassroom(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - MessageOfMap_Row(const MessageOfMap_Row& from); - MessageOfMap_Row(MessageOfMap_Row&& from) noexcept + MessageOfClassroom(const MessageOfClassroom& from); + MessageOfClassroom(MessageOfClassroom&& from) noexcept : - MessageOfMap_Row() + MessageOfClassroom() { *this = ::std::move(from); } - inline MessageOfMap_Row& operator=(const MessageOfMap_Row& from) + inline MessageOfClassroom& operator=(const MessageOfClassroom& from) { CopyFrom(from); return *this; } - inline MessageOfMap_Row& operator=(MessageOfMap_Row&& from) noexcept + inline MessageOfClassroom& operator=(MessageOfClassroom&& from) noexcept { if (this == &from) return *this; @@ -1984,24 +2139,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const MessageOfMap_Row& default_instance() + static const MessageOfClassroom& default_instance() { return *internal_default_instance(); } - static inline const MessageOfMap_Row* internal_default_instance() + static inline const MessageOfClassroom* internal_default_instance() { - return reinterpret_cast( - &_MessageOfMap_Row_default_instance_ + return reinterpret_cast( + &_MessageOfClassroom_default_instance_ ); } static constexpr int kIndexInFileMessages = 6; - friend void swap(MessageOfMap_Row& a, MessageOfMap_Row& b) + friend void swap(MessageOfClassroom& a, MessageOfClassroom& b) { a.Swap(&b); } - inline void Swap(MessageOfMap_Row* other) + inline void Swap(MessageOfClassroom* other) { if (other == this) return; @@ -2020,7 +2175,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MessageOfMap_Row* other) + void UnsafeArenaSwap(MessageOfClassroom* other) { if (other == this) return; @@ -2030,16 +2185,16 @@ namespace protobuf // implements Message ---------------------------------------------- - MessageOfMap_Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + MessageOfClassroom* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MessageOfMap_Row& from); + void CopyFrom(const MessageOfClassroom& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const MessageOfMap_Row& from) + void MergeFrom(const MessageOfClassroom& from) { - MessageOfMap_Row::MergeImpl(*this, from); + MessageOfClassroom::MergeImpl(*this, from); } private: @@ -2063,17 +2218,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(MessageOfMap_Row* other); + void InternalSwap(MessageOfClassroom* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.MessageOfMap.Row"; + return "protobuf.MessageOfClassroom"; } protected: - explicit MessageOfMap_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit MessageOfClassroom(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -2087,30 +2242,41 @@ namespace protobuf enum : int { - kColFieldNumber = 1, + kXFieldNumber = 1, + kYFieldNumber = 2, + kProgressFieldNumber = 3, }; - // repeated .protobuf.PlaceType col = 1; - int col_size() const; + // int32 x = 1; + void clear_x(); + int32_t x() const; + void set_x(int32_t value); private: - int _internal_col_size() const; + int32_t _internal_x() const; + void _internal_set_x(int32_t value); public: - void clear_col(); + // int32 y = 2; + void clear_y(); + int32_t y() const; + void set_y(int32_t value); private: - ::protobuf::PlaceType _internal_col(int index) const; - void _internal_add_col(::protobuf::PlaceType value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_col(); + int32_t _internal_y() const; + void _internal_set_y(int32_t value); public: - ::protobuf::PlaceType col(int index) const; - void set_col(int index, ::protobuf::PlaceType value); - void add_col(::protobuf::PlaceType value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField& col() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_col(); + // int32 progress = 3; + void clear_progress(); + int32_t progress() const; + void set_progress(int32_t value); - // @@protoc_insertion_point(class_scope:protobuf.MessageOfMap.Row) + private: + int32_t _internal_progress() const; + void _internal_set_progress(int32_t value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.MessageOfClassroom) private: class _Internal; @@ -2121,8 +2287,9 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedField col_; - mutable std::atomic _col_cached_byte_size_; + int32_t x_; + int32_t y_; + int32_t progress_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -2133,31 +2300,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class MessageOfMap final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfMap) */ + class MessageOfGate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfGate) */ { public: - inline MessageOfMap() : - MessageOfMap(nullptr) + inline MessageOfGate() : + MessageOfGate(nullptr) { } - ~MessageOfMap() override; - explicit PROTOBUF_CONSTEXPR MessageOfMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~MessageOfGate() override; + explicit PROTOBUF_CONSTEXPR MessageOfGate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - MessageOfMap(const MessageOfMap& from); - MessageOfMap(MessageOfMap&& from) noexcept + MessageOfGate(const MessageOfGate& from); + MessageOfGate(MessageOfGate&& from) noexcept : - MessageOfMap() + MessageOfGate() { *this = ::std::move(from); } - inline MessageOfMap& operator=(const MessageOfMap& from) + inline MessageOfGate& operator=(const MessageOfGate& from) { CopyFrom(from); return *this; } - inline MessageOfMap& operator=(MessageOfMap&& from) noexcept + inline MessageOfGate& operator=(MessageOfGate&& from) noexcept { if (this == &from) return *this; @@ -2188,24 +2355,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const MessageOfMap& default_instance() + static const MessageOfGate& default_instance() { return *internal_default_instance(); } - static inline const MessageOfMap* internal_default_instance() + static inline const MessageOfGate* internal_default_instance() { - return reinterpret_cast( - &_MessageOfMap_default_instance_ + return reinterpret_cast( + &_MessageOfGate_default_instance_ ); } static constexpr int kIndexInFileMessages = 7; - friend void swap(MessageOfMap& a, MessageOfMap& b) + friend void swap(MessageOfGate& a, MessageOfGate& b) { a.Swap(&b); } - inline void Swap(MessageOfMap* other) + inline void Swap(MessageOfGate* other) { if (other == this) return; @@ -2224,7 +2391,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MessageOfMap* other) + void UnsafeArenaSwap(MessageOfGate* other) { if (other == this) return; @@ -2234,16 +2401,16 @@ namespace protobuf // implements Message ---------------------------------------------- - MessageOfMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + MessageOfGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MessageOfMap& from); + void CopyFrom(const MessageOfGate& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const MessageOfMap& from) + void MergeFrom(const MessageOfGate& from) { - MessageOfMap::MergeImpl(*this, from); + MessageOfGate::MergeImpl(*this, from); } private: @@ -2267,17 +2434,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(MessageOfMap* other); + void InternalSwap(MessageOfGate* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.MessageOfMap"; + return "protobuf.MessageOfGate"; } protected: - explicit MessageOfMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit MessageOfGate(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -2287,37 +2454,45 @@ namespace protobuf // nested types ---------------------------------------------------- - typedef MessageOfMap_Row Row; - // accessors ------------------------------------------------------- enum : int { - kRowFieldNumber = 2, + kXFieldNumber = 1, + kYFieldNumber = 2, + kProgressFieldNumber = 3, }; - // repeated .protobuf.MessageOfMap.Row row = 2; - int row_size() const; + // int32 x = 1; + void clear_x(); + int32_t x() const; + void set_x(int32_t value); private: - int _internal_row_size() const; + int32_t _internal_x() const; + void _internal_set_x(int32_t value); public: - void clear_row(); - ::protobuf::MessageOfMap_Row* mutable_row(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>* - mutable_row(); + // int32 y = 2; + void clear_y(); + int32_t y() const; + void set_y(int32_t value); private: - const ::protobuf::MessageOfMap_Row& _internal_row(int index) const; - ::protobuf::MessageOfMap_Row* _internal_add_row(); + int32_t _internal_y() const; + void _internal_set_y(int32_t value); public: - const ::protobuf::MessageOfMap_Row& row(int index) const; - ::protobuf::MessageOfMap_Row* add_row(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>& - row() const; + // int32 progress = 3; + void clear_progress(); + int32_t progress() const; + void set_progress(int32_t value); - // @@protoc_insertion_point(class_scope:protobuf.MessageOfMap) + private: + int32_t _internal_progress() const; + void _internal_set_progress(int32_t value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.MessageOfGate) private: class _Internal; @@ -2328,7 +2503,9 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row> row_; + int32_t x_; + int32_t y_; + int32_t progress_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -2339,31 +2516,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class MessageToClient final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageToClient) */ + class MessageOfDoor final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfDoor) */ { public: - inline MessageToClient() : - MessageToClient(nullptr) + inline MessageOfDoor() : + MessageOfDoor(nullptr) { } - ~MessageToClient() override; - explicit PROTOBUF_CONSTEXPR MessageToClient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~MessageOfDoor() override; + explicit PROTOBUF_CONSTEXPR MessageOfDoor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - MessageToClient(const MessageToClient& from); - MessageToClient(MessageToClient&& from) noexcept + MessageOfDoor(const MessageOfDoor& from); + MessageOfDoor(MessageOfDoor&& from) noexcept : - MessageToClient() + MessageOfDoor() { *this = ::std::move(from); } - inline MessageToClient& operator=(const MessageToClient& from) + inline MessageOfDoor& operator=(const MessageOfDoor& from) { CopyFrom(from); return *this; } - inline MessageToClient& operator=(MessageToClient&& from) noexcept + inline MessageOfDoor& operator=(MessageOfDoor&& from) noexcept { if (this == &from) return *this; @@ -2394,24 +2571,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const MessageToClient& default_instance() + static const MessageOfDoor& default_instance() { return *internal_default_instance(); } - static inline const MessageToClient* internal_default_instance() + static inline const MessageOfDoor* internal_default_instance() { - return reinterpret_cast( - &_MessageToClient_default_instance_ + return reinterpret_cast( + &_MessageOfDoor_default_instance_ ); } static constexpr int kIndexInFileMessages = 8; - friend void swap(MessageToClient& a, MessageToClient& b) + friend void swap(MessageOfDoor& a, MessageOfDoor& b) { a.Swap(&b); } - inline void Swap(MessageToClient* other) + inline void Swap(MessageOfDoor* other) { if (other == this) return; @@ -2430,7 +2607,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MessageToClient* other) + void UnsafeArenaSwap(MessageOfDoor* other) { if (other == this) return; @@ -2440,16 +2617,16 @@ namespace protobuf // implements Message ---------------------------------------------- - MessageToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + MessageOfDoor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MessageToClient& from); + void CopyFrom(const MessageOfDoor& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const MessageToClient& from) + void MergeFrom(const MessageOfDoor& from) { - MessageToClient::MergeImpl(*this, from); + MessageOfDoor::MergeImpl(*this, from); } private: @@ -2473,17 +2650,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(MessageToClient* other); + void InternalSwap(MessageOfDoor* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.MessageToClient"; + return "protobuf.MessageOfDoor"; } protected: - explicit MessageToClient(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit MessageOfDoor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -2497,158 +2674,41 @@ namespace protobuf enum : int { - kStudentMessageFieldNumber = 1, - kTrickerMessageFieldNumber = 2, - kPropMessageFieldNumber = 3, - kBulletMessageFieldNumber = 4, - kBombedBulletMessageFieldNumber = 5, - kMapMessageFieldNumber = 6, - kGameStateFieldNumber = 7, + kXFieldNumber = 1, + kYFieldNumber = 2, + kIsOpenFieldNumber = 3, }; - // repeated .protobuf.MessageOfStudent student_message = 1; - int student_message_size() const; - - private: - int _internal_student_message_size() const; - - public: - void clear_student_message(); - ::protobuf::MessageOfStudent* mutable_student_message(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfStudent>* - mutable_student_message(); - - private: - const ::protobuf::MessageOfStudent& _internal_student_message(int index) const; - ::protobuf::MessageOfStudent* _internal_add_student_message(); - - public: - const ::protobuf::MessageOfStudent& student_message(int index) const; - ::protobuf::MessageOfStudent* add_student_message(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfStudent>& - student_message() const; - - // repeated .protobuf.MessageOfTricker tricker_message = 2; - int tricker_message_size() const; - - private: - int _internal_tricker_message_size() const; - - public: - void clear_tricker_message(); - ::protobuf::MessageOfTricker* mutable_tricker_message(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfTricker>* - mutable_tricker_message(); - - private: - const ::protobuf::MessageOfTricker& _internal_tricker_message(int index) const; - ::protobuf::MessageOfTricker* _internal_add_tricker_message(); - - public: - const ::protobuf::MessageOfTricker& tricker_message(int index) const; - ::protobuf::MessageOfTricker* add_tricker_message(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfTricker>& - tricker_message() const; - - // repeated .protobuf.MessageOfProp prop_message = 3; - int prop_message_size() const; - - private: - int _internal_prop_message_size() const; - - public: - void clear_prop_message(); - ::protobuf::MessageOfProp* mutable_prop_message(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfProp>* - mutable_prop_message(); - - private: - const ::protobuf::MessageOfProp& _internal_prop_message(int index) const; - ::protobuf::MessageOfProp* _internal_add_prop_message(); - - public: - const ::protobuf::MessageOfProp& prop_message(int index) const; - ::protobuf::MessageOfProp* add_prop_message(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfProp>& - prop_message() const; - - // repeated .protobuf.MessageOfBullet bullet_message = 4; - int bullet_message_size() const; - - private: - int _internal_bullet_message_size() const; - - public: - void clear_bullet_message(); - ::protobuf::MessageOfBullet* mutable_bullet_message(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBullet>* - mutable_bullet_message(); - - private: - const ::protobuf::MessageOfBullet& _internal_bullet_message(int index) const; - ::protobuf::MessageOfBullet* _internal_add_bullet_message(); - - public: - const ::protobuf::MessageOfBullet& bullet_message(int index) const; - ::protobuf::MessageOfBullet* add_bullet_message(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBullet>& - bullet_message() const; - - // repeated .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; - int bombed_bullet_message_size() const; - - private: - int _internal_bombed_bullet_message_size() const; - - public: - void clear_bombed_bullet_message(); - ::protobuf::MessageOfBombedBullet* mutable_bombed_bullet_message(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBombedBullet>* - mutable_bombed_bullet_message(); - - private: - const ::protobuf::MessageOfBombedBullet& _internal_bombed_bullet_message(int index) const; - ::protobuf::MessageOfBombedBullet* _internal_add_bombed_bullet_message(); - - public: - const ::protobuf::MessageOfBombedBullet& bombed_bullet_message(int index) const; - ::protobuf::MessageOfBombedBullet* add_bombed_bullet_message(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBombedBullet>& - bombed_bullet_message() const; - - // .protobuf.MessageOfMap map_message = 6; - bool has_map_message() const; + // int32 x = 1; + void clear_x(); + int32_t x() const; + void set_x(int32_t value); private: - bool _internal_has_map_message() const; + int32_t _internal_x() const; + void _internal_set_x(int32_t value); public: - void clear_map_message(); - const ::protobuf::MessageOfMap& map_message() const; - PROTOBUF_NODISCARD ::protobuf::MessageOfMap* release_map_message(); - ::protobuf::MessageOfMap* mutable_map_message(); - void set_allocated_map_message(::protobuf::MessageOfMap* map_message); + // int32 y = 2; + void clear_y(); + int32_t y() const; + void set_y(int32_t value); private: - const ::protobuf::MessageOfMap& _internal_map_message() const; - ::protobuf::MessageOfMap* _internal_mutable_map_message(); + int32_t _internal_y() const; + void _internal_set_y(int32_t value); public: - void unsafe_arena_set_allocated_map_message( - ::protobuf::MessageOfMap* map_message - ); - ::protobuf::MessageOfMap* unsafe_arena_release_map_message(); - - // .protobuf.GameState game_state = 7; - void clear_game_state(); - ::protobuf::GameState game_state() const; - void set_game_state(::protobuf::GameState value); + // bool is_open = 3; + void clear_is_open(); + bool is_open() const; + void set_is_open(bool value); private: - ::protobuf::GameState _internal_game_state() const; - void _internal_set_game_state(::protobuf::GameState value); + bool _internal_is_open() const; + void _internal_set_is_open(bool value); public: - // @@protoc_insertion_point(class_scope:protobuf.MessageToClient) + // @@protoc_insertion_point(class_scope:protobuf.MessageOfDoor) private: class _Internal; @@ -2659,13 +2719,9 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfStudent> student_message_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfTricker> tricker_message_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfProp> prop_message_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBullet> bullet_message_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBombedBullet> bombed_bullet_message_; - ::protobuf::MessageOfMap* map_message_; - int game_state_; + int32_t x_; + int32_t y_; + bool is_open_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -2676,31 +2732,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class MoveRes final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MoveRes) */ + class MessageOfChest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfChest) */ { public: - inline MoveRes() : - MoveRes(nullptr) + inline MessageOfChest() : + MessageOfChest(nullptr) { } - ~MoveRes() override; - explicit PROTOBUF_CONSTEXPR MoveRes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~MessageOfChest() override; + explicit PROTOBUF_CONSTEXPR MessageOfChest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - MoveRes(const MoveRes& from); - MoveRes(MoveRes&& from) noexcept + MessageOfChest(const MessageOfChest& from); + MessageOfChest(MessageOfChest&& from) noexcept : - MoveRes() + MessageOfChest() { *this = ::std::move(from); } - inline MoveRes& operator=(const MoveRes& from) + inline MessageOfChest& operator=(const MessageOfChest& from) { CopyFrom(from); return *this; } - inline MoveRes& operator=(MoveRes&& from) noexcept + inline MessageOfChest& operator=(MessageOfChest&& from) noexcept { if (this == &from) return *this; @@ -2731,24 +2787,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const MoveRes& default_instance() + static const MessageOfChest& default_instance() { return *internal_default_instance(); } - static inline const MoveRes* internal_default_instance() + static inline const MessageOfChest* internal_default_instance() { - return reinterpret_cast( - &_MoveRes_default_instance_ + return reinterpret_cast( + &_MessageOfChest_default_instance_ ); } static constexpr int kIndexInFileMessages = 9; - friend void swap(MoveRes& a, MoveRes& b) + friend void swap(MessageOfChest& a, MessageOfChest& b) { a.Swap(&b); } - inline void Swap(MoveRes* other) + inline void Swap(MessageOfChest* other) { if (other == this) return; @@ -2767,7 +2823,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MoveRes* other) + void UnsafeArenaSwap(MessageOfChest* other) { if (other == this) return; @@ -2777,16 +2833,16 @@ namespace protobuf // implements Message ---------------------------------------------- - MoveRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + MessageOfChest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MoveRes& from); + void CopyFrom(const MessageOfChest& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const MoveRes& from) + void MergeFrom(const MessageOfChest& from) { - MoveRes::MergeImpl(*this, from); + MessageOfChest::MergeImpl(*this, from); } private: @@ -2810,17 +2866,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(MoveRes* other); + void InternalSwap(MessageOfChest* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.MoveRes"; + return "protobuf.MessageOfChest"; } protected: - explicit MoveRes(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit MessageOfChest(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -2834,41 +2890,41 @@ namespace protobuf enum : int { - kActualSpeedFieldNumber = 1, - kActualAngleFieldNumber = 2, - kActSuccessFieldNumber = 3, + kXFieldNumber = 1, + kYFieldNumber = 2, + kProgressFieldNumber = 3, }; - // int64 actual_speed = 1; - void clear_actual_speed(); - int64_t actual_speed() const; - void set_actual_speed(int64_t value); + // int32 x = 1; + void clear_x(); + int32_t x() const; + void set_x(int32_t value); private: - int64_t _internal_actual_speed() const; - void _internal_set_actual_speed(int64_t value); + int32_t _internal_x() const; + void _internal_set_x(int32_t value); public: - // double actual_angle = 2; - void clear_actual_angle(); - double actual_angle() const; - void set_actual_angle(double value); + // int32 y = 2; + void clear_y(); + int32_t y() const; + void set_y(int32_t value); private: - double _internal_actual_angle() const; - void _internal_set_actual_angle(double value); + int32_t _internal_y() const; + void _internal_set_y(int32_t value); public: - // bool act_success = 3; - void clear_act_success(); - bool act_success() const; - void set_act_success(bool value); + // int32 progress = 3; + void clear_progress(); + int32_t progress() const; + void set_progress(int32_t value); private: - bool _internal_act_success() const; - void _internal_set_act_success(bool value); + int32_t _internal_progress() const; + void _internal_set_progress(int32_t value); public: - // @@protoc_insertion_point(class_scope:protobuf.MoveRes) + // @@protoc_insertion_point(class_scope:protobuf.MessageOfChest) private: class _Internal; @@ -2879,9 +2935,9 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { - int64_t actual_speed_; - double actual_angle_; - bool act_success_; + int32_t x_; + int32_t y_; + int32_t progress_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -2892,31 +2948,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class BoolRes final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.BoolRes) */ + class MessageOfMapObj final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfMapObj) */ { public: - inline BoolRes() : - BoolRes(nullptr) + inline MessageOfMapObj() : + MessageOfMapObj(nullptr) { } - ~BoolRes() override; - explicit PROTOBUF_CONSTEXPR BoolRes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~MessageOfMapObj() override; + explicit PROTOBUF_CONSTEXPR MessageOfMapObj(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - BoolRes(const BoolRes& from); - BoolRes(BoolRes&& from) noexcept + MessageOfMapObj(const MessageOfMapObj& from); + MessageOfMapObj(MessageOfMapObj&& from) noexcept : - BoolRes() + MessageOfMapObj() { *this = ::std::move(from); } - inline BoolRes& operator=(const BoolRes& from) + inline MessageOfMapObj& operator=(const MessageOfMapObj& from) { CopyFrom(from); return *this; } - inline BoolRes& operator=(BoolRes&& from) noexcept + inline MessageOfMapObj& operator=(MessageOfMapObj&& from) noexcept { if (this == &from) return *this; @@ -2947,24 +3003,33 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const BoolRes& default_instance() + static const MessageOfMapObj& default_instance() { return *internal_default_instance(); } - static inline const BoolRes* internal_default_instance() + enum MessageOfMapObjCase { - return reinterpret_cast( - &_BoolRes_default_instance_ + kClassroomMessage = 1, + kDoorMessage = 2, + kGateMessage = 3, + kChestMessage = 4, + MESSAGE_OF_MAP_OBJ_NOT_SET = 0, + }; + + static inline const MessageOfMapObj* internal_default_instance() + { + return reinterpret_cast( + &_MessageOfMapObj_default_instance_ ); } static constexpr int kIndexInFileMessages = 10; - friend void swap(BoolRes& a, BoolRes& b) + friend void swap(MessageOfMapObj& a, MessageOfMapObj& b) { a.Swap(&b); } - inline void Swap(BoolRes* other) + inline void Swap(MessageOfMapObj* other) { if (other == this) return; @@ -2983,7 +3048,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(BoolRes* other) + void UnsafeArenaSwap(MessageOfMapObj* other) { if (other == this) return; @@ -2993,16 +3058,16 @@ namespace protobuf // implements Message ---------------------------------------------- - BoolRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + MessageOfMapObj* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const BoolRes& from); + void CopyFrom(const MessageOfMapObj& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const BoolRes& from) + void MergeFrom(const MessageOfMapObj& from) { - BoolRes::MergeImpl(*this, from); + MessageOfMapObj::MergeImpl(*this, from); } private: @@ -3026,17 +3091,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(BoolRes* other); + void InternalSwap(MessageOfMapObj* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.BoolRes"; + return "protobuf.MessageOfMapObj"; } protected: - explicit BoolRes(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit MessageOfMapObj(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -3050,31 +3115,137 @@ namespace protobuf enum : int { - kActSuccessFieldNumber = 1, + kClassroomMessageFieldNumber = 1, + kDoorMessageFieldNumber = 2, + kGateMessageFieldNumber = 3, + kChestMessageFieldNumber = 4, }; - // bool act_success = 1; - void clear_act_success(); - bool act_success() const; - void set_act_success(bool value); + // .protobuf.MessageOfClassroom classroom_message = 1; + bool has_classroom_message() const; private: - bool _internal_act_success() const; - void _internal_set_act_success(bool value); + bool _internal_has_classroom_message() const; public: - // @@protoc_insertion_point(class_scope:protobuf.BoolRes) + void clear_classroom_message(); + const ::protobuf::MessageOfClassroom& classroom_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfClassroom* release_classroom_message(); + ::protobuf::MessageOfClassroom* mutable_classroom_message(); + void set_allocated_classroom_message(::protobuf::MessageOfClassroom* classroom_message); private: - class _Internal; + const ::protobuf::MessageOfClassroom& _internal_classroom_message() const; + ::protobuf::MessageOfClassroom* _internal_mutable_classroom_message(); - template - friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ - { - bool act_success_; + public: + void unsafe_arena_set_allocated_classroom_message( + ::protobuf::MessageOfClassroom* classroom_message + ); + ::protobuf::MessageOfClassroom* unsafe_arena_release_classroom_message(); + + // .protobuf.MessageOfDoor door_message = 2; + bool has_door_message() const; + + private: + bool _internal_has_door_message() const; + + public: + void clear_door_message(); + const ::protobuf::MessageOfDoor& door_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfDoor* release_door_message(); + ::protobuf::MessageOfDoor* mutable_door_message(); + void set_allocated_door_message(::protobuf::MessageOfDoor* door_message); + + private: + const ::protobuf::MessageOfDoor& _internal_door_message() const; + ::protobuf::MessageOfDoor* _internal_mutable_door_message(); + + public: + void unsafe_arena_set_allocated_door_message( + ::protobuf::MessageOfDoor* door_message + ); + ::protobuf::MessageOfDoor* unsafe_arena_release_door_message(); + + // .protobuf.MessageOfGate gate_message = 3; + bool has_gate_message() const; + + private: + bool _internal_has_gate_message() const; + + public: + void clear_gate_message(); + const ::protobuf::MessageOfGate& gate_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfGate* release_gate_message(); + ::protobuf::MessageOfGate* mutable_gate_message(); + void set_allocated_gate_message(::protobuf::MessageOfGate* gate_message); + + private: + const ::protobuf::MessageOfGate& _internal_gate_message() const; + ::protobuf::MessageOfGate* _internal_mutable_gate_message(); + + public: + void unsafe_arena_set_allocated_gate_message( + ::protobuf::MessageOfGate* gate_message + ); + ::protobuf::MessageOfGate* unsafe_arena_release_gate_message(); + + // .protobuf.MessageOfChest chest_message = 4; + bool has_chest_message() const; + + private: + bool _internal_has_chest_message() const; + + public: + void clear_chest_message(); + const ::protobuf::MessageOfChest& chest_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfChest* release_chest_message(); + ::protobuf::MessageOfChest* mutable_chest_message(); + void set_allocated_chest_message(::protobuf::MessageOfChest* chest_message); + + private: + const ::protobuf::MessageOfChest& _internal_chest_message() const; + ::protobuf::MessageOfChest* _internal_mutable_chest_message(); + + public: + void unsafe_arena_set_allocated_chest_message( + ::protobuf::MessageOfChest* chest_message + ); + ::protobuf::MessageOfChest* unsafe_arena_release_chest_message(); + + void clear_message_of_map_obj(); + MessageOfMapObjCase message_of_map_obj_case() const; + // @@protoc_insertion_point(class_scope:protobuf.MessageOfMapObj) + + private: + class _Internal; + void set_has_classroom_message(); + void set_has_door_message(); + void set_has_gate_message(); + void set_has_chest_message(); + + inline bool has_message_of_map_obj() const; + inline void clear_has_message_of_map_obj(); + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + union MessageOfMapObjUnion + { + constexpr MessageOfMapObjUnion() : + _constinit_{} + { + } + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::protobuf::MessageOfClassroom* classroom_message_; + ::protobuf::MessageOfDoor* door_message_; + ::protobuf::MessageOfGate* gate_message_; + ::protobuf::MessageOfChest* chest_message_; + } message_of_map_obj_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t _oneof_case_[1]; }; union { @@ -3084,31 +3255,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class MsgRes final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MsgRes) */ + class MessageOfMap_Row final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfMap.Row) */ { public: - inline MsgRes() : - MsgRes(nullptr) + inline MessageOfMap_Row() : + MessageOfMap_Row(nullptr) { } - ~MsgRes() override; - explicit PROTOBUF_CONSTEXPR MsgRes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~MessageOfMap_Row() override; + explicit PROTOBUF_CONSTEXPR MessageOfMap_Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - MsgRes(const MsgRes& from); - MsgRes(MsgRes&& from) noexcept + MessageOfMap_Row(const MessageOfMap_Row& from); + MessageOfMap_Row(MessageOfMap_Row&& from) noexcept : - MsgRes() + MessageOfMap_Row() { *this = ::std::move(from); } - inline MsgRes& operator=(const MsgRes& from) + inline MessageOfMap_Row& operator=(const MessageOfMap_Row& from) { CopyFrom(from); return *this; } - inline MsgRes& operator=(MsgRes&& from) noexcept + inline MessageOfMap_Row& operator=(MessageOfMap_Row&& from) noexcept { if (this == &from) return *this; @@ -3139,24 +3310,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const MsgRes& default_instance() + static const MessageOfMap_Row& default_instance() { return *internal_default_instance(); } - static inline const MsgRes* internal_default_instance() + static inline const MessageOfMap_Row* internal_default_instance() { - return reinterpret_cast( - &_MsgRes_default_instance_ + return reinterpret_cast( + &_MessageOfMap_Row_default_instance_ ); } static constexpr int kIndexInFileMessages = 11; - friend void swap(MsgRes& a, MsgRes& b) + friend void swap(MessageOfMap_Row& a, MessageOfMap_Row& b) { a.Swap(&b); } - inline void Swap(MsgRes* other) + inline void Swap(MessageOfMap_Row* other) { if (other == this) return; @@ -3175,7 +3346,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(MsgRes* other) + void UnsafeArenaSwap(MessageOfMap_Row* other) { if (other == this) return; @@ -3185,16 +3356,16 @@ namespace protobuf // implements Message ---------------------------------------------- - MsgRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + MessageOfMap_Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MsgRes& from); + void CopyFrom(const MessageOfMap_Row& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const MsgRes& from) + void MergeFrom(const MessageOfMap_Row& from) { - MsgRes::MergeImpl(*this, from); + MessageOfMap_Row::MergeImpl(*this, from); } private: @@ -3218,17 +3389,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(MsgRes* other); + void InternalSwap(MessageOfMap_Row* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.MsgRes"; + return "protobuf.MessageOfMap.Row"; } protected: - explicit MsgRes(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit MessageOfMap_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -3242,46 +3413,30 @@ namespace protobuf enum : int { - kMessageReceivedFieldNumber = 3, - kFromPlayerIdFieldNumber = 2, - kHaveMessageFieldNumber = 1, + kColFieldNumber = 1, }; - // string message_received = 3; - void clear_message_received(); - const std::string& message_received() const; - template - 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); + // repeated .protobuf.PlaceType col = 1; + int col_size() const; 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(); + int _internal_col_size() const; 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); + void clear_col(); private: - int64_t _internal_from_player_id() const; - void _internal_set_from_player_id(int64_t value); + ::protobuf::PlaceType _internal_col(int index) const; + void _internal_add_col(::protobuf::PlaceType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_col(); 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); + ::protobuf::PlaceType col(int index) const; + void set_col(int index, ::protobuf::PlaceType value); + void add_col(::protobuf::PlaceType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& col() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_col(); - public: - // @@protoc_insertion_point(class_scope:protobuf.MsgRes) + // @@protoc_insertion_point(class_scope:protobuf.MessageOfMap.Row) private: class _Internal; @@ -3292,9 +3447,8 @@ namespace protobuf typedef void DestructorSkippable_; struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_received_; - int64_t from_player_id_; - bool have_message_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField col_; + mutable std::atomic _col_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -3303,1879 +3457,5130 @@ namespace protobuf }; friend struct ::TableStruct_Message2Clients_2eproto; }; - // =================================================================== - - // =================================================================== - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ - // MessageOfStudent - - // int32 x = 1; - inline void MessageOfStudent::clear_x() - { - _impl_.x_ = 0; - } - inline int32_t MessageOfStudent::_internal_x() const - { - return _impl_.x_; - } - inline int32_t MessageOfStudent::x() const - { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.x) - return _internal_x(); - } - inline void MessageOfStudent::_internal_set_x(int32_t value) - { - _impl_.x_ = value; - } - inline void MessageOfStudent::set_x(int32_t value) - { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.x) - } + // ------------------------------------------------------------------- - // int32 y = 2; - inline void MessageOfStudent::clear_y() - { - _impl_.y_ = 0; - } - inline int32_t MessageOfStudent::_internal_y() const - { - return _impl_.y_; - } - inline int32_t MessageOfStudent::y() const - { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.y) - return _internal_y(); - } - inline void MessageOfStudent::_internal_set_y(int32_t value) - { - _impl_.y_ = value; - } - inline void MessageOfStudent::set_y(int32_t value) + class MessageOfMap final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfMap) */ { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.y) - } + public: + inline MessageOfMap() : + MessageOfMap(nullptr) + { + } + ~MessageOfMap() override; + explicit PROTOBUF_CONSTEXPR MessageOfMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - // int32 speed = 3; - inline void MessageOfStudent::clear_speed() - { - _impl_.speed_ = 0; - } - inline int32_t MessageOfStudent::_internal_speed() const - { - return _impl_.speed_; - } - inline int32_t MessageOfStudent::speed() const - { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.speed) - return _internal_speed(); - } - inline void MessageOfStudent::_internal_set_speed(int32_t value) - { - _impl_.speed_ = value; - } - inline void MessageOfStudent::set_speed(int32_t value) - { - _internal_set_speed(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.speed) - } + MessageOfMap(const MessageOfMap& from); + MessageOfMap(MessageOfMap&& from) noexcept + : + MessageOfMap() + { + *this = ::std::move(from); + } - // int32 determination = 4; - inline void MessageOfStudent::clear_determination() - { - _impl_.determination_ = 0; - } - inline int32_t MessageOfStudent::_internal_determination() const - { - return _impl_.determination_; - } - inline int32_t MessageOfStudent::determination() const - { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.determination) - return _internal_determination(); - } - inline void MessageOfStudent::_internal_set_determination(int32_t value) + inline MessageOfMap& operator=(const MessageOfMap& from) + { + CopyFrom(from); + return *this; + } + inline MessageOfMap& operator=(MessageOfMap&& 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 MessageOfMap& default_instance() + { + return *internal_default_instance(); + } + static inline const MessageOfMap* internal_default_instance() + { + return reinterpret_cast( + &_MessageOfMap_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(MessageOfMap& a, MessageOfMap& b) + { + a.Swap(&b); + } + inline void Swap(MessageOfMap* 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(MessageOfMap* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MessageOfMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MessageOfMap& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MessageOfMap& from) + { + MessageOfMap::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(MessageOfMap* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.MessageOfMap"; + } + + protected: + explicit MessageOfMap(::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 ---------------------------------------------------- + + typedef MessageOfMap_Row Row; + + // accessors ------------------------------------------------------- + + enum : int + { + kRowFieldNumber = 2, + kMapObjMessageFieldNumber = 3, + }; + // repeated .protobuf.MessageOfMap.Row row = 2; + int row_size() const; + + private: + int _internal_row_size() const; + + public: + void clear_row(); + ::protobuf::MessageOfMap_Row* mutable_row(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>* + mutable_row(); + + private: + const ::protobuf::MessageOfMap_Row& _internal_row(int index) const; + ::protobuf::MessageOfMap_Row* _internal_add_row(); + + public: + const ::protobuf::MessageOfMap_Row& row(int index) const; + ::protobuf::MessageOfMap_Row* add_row(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>& + row() const; + + // repeated .protobuf.MessageOfMapObj map_obj_message = 3; + int map_obj_message_size() const; + + private: + int _internal_map_obj_message_size() const; + + public: + void clear_map_obj_message(); + ::protobuf::MessageOfMapObj* mutable_map_obj_message(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMapObj>* + mutable_map_obj_message(); + + private: + const ::protobuf::MessageOfMapObj& _internal_map_obj_message(int index) const; + ::protobuf::MessageOfMapObj* _internal_add_map_obj_message(); + + public: + const ::protobuf::MessageOfMapObj& map_obj_message(int index) const; + ::protobuf::MessageOfMapObj* add_map_obj_message(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMapObj>& + map_obj_message() const; + + // @@protoc_insertion_point(class_scope:protobuf.MessageOfMap) + + private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row> row_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMapObj> map_obj_message_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union + { + Impl_ _impl_; + }; + friend struct ::TableStruct_Message2Clients_2eproto; + }; + // ------------------------------------------------------------------- + + class MessageOfObj final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfObj) */ + { + public: + inline MessageOfObj() : + MessageOfObj(nullptr) + { + } + ~MessageOfObj() override; + explicit PROTOBUF_CONSTEXPR MessageOfObj(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageOfObj(const MessageOfObj& from); + MessageOfObj(MessageOfObj&& from) noexcept + : + MessageOfObj() + { + *this = ::std::move(from); + } + + inline MessageOfObj& operator=(const MessageOfObj& from) + { + CopyFrom(from); + return *this; + } + inline MessageOfObj& operator=(MessageOfObj&& 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 MessageOfObj& default_instance() + { + return *internal_default_instance(); + } + enum MessageOfObjCase + { + kStudentMessage = 1, + kTrickerMessage = 2, + kPropMessage = 3, + kBulletMessage = 4, + kBombedBulletMessage = 5, + MESSAGE_OF_OBJ_NOT_SET = 0, + }; + + static inline const MessageOfObj* internal_default_instance() + { + return reinterpret_cast( + &_MessageOfObj_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(MessageOfObj& a, MessageOfObj& b) + { + a.Swap(&b); + } + inline void Swap(MessageOfObj* 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(MessageOfObj* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MessageOfObj* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MessageOfObj& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MessageOfObj& from) + { + MessageOfObj::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(MessageOfObj* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.MessageOfObj"; + } + + protected: + explicit MessageOfObj(::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 + { + kStudentMessageFieldNumber = 1, + kTrickerMessageFieldNumber = 2, + kPropMessageFieldNumber = 3, + kBulletMessageFieldNumber = 4, + kBombedBulletMessageFieldNumber = 5, + }; + // .protobuf.MessageOfStudent student_message = 1; + bool has_student_message() const; + + private: + bool _internal_has_student_message() const; + + public: + void clear_student_message(); + const ::protobuf::MessageOfStudent& student_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfStudent* release_student_message(); + ::protobuf::MessageOfStudent* mutable_student_message(); + void set_allocated_student_message(::protobuf::MessageOfStudent* student_message); + + private: + const ::protobuf::MessageOfStudent& _internal_student_message() const; + ::protobuf::MessageOfStudent* _internal_mutable_student_message(); + + public: + void unsafe_arena_set_allocated_student_message( + ::protobuf::MessageOfStudent* student_message + ); + ::protobuf::MessageOfStudent* unsafe_arena_release_student_message(); + + // .protobuf.MessageOfTricker tricker_message = 2; + bool has_tricker_message() const; + + private: + bool _internal_has_tricker_message() const; + + public: + void clear_tricker_message(); + const ::protobuf::MessageOfTricker& tricker_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfTricker* release_tricker_message(); + ::protobuf::MessageOfTricker* mutable_tricker_message(); + void set_allocated_tricker_message(::protobuf::MessageOfTricker* tricker_message); + + private: + const ::protobuf::MessageOfTricker& _internal_tricker_message() const; + ::protobuf::MessageOfTricker* _internal_mutable_tricker_message(); + + public: + void unsafe_arena_set_allocated_tricker_message( + ::protobuf::MessageOfTricker* tricker_message + ); + ::protobuf::MessageOfTricker* unsafe_arena_release_tricker_message(); + + // .protobuf.MessageOfProp prop_message = 3; + bool has_prop_message() const; + + private: + bool _internal_has_prop_message() const; + + public: + void clear_prop_message(); + const ::protobuf::MessageOfProp& prop_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfProp* release_prop_message(); + ::protobuf::MessageOfProp* mutable_prop_message(); + void set_allocated_prop_message(::protobuf::MessageOfProp* prop_message); + + private: + const ::protobuf::MessageOfProp& _internal_prop_message() const; + ::protobuf::MessageOfProp* _internal_mutable_prop_message(); + + public: + void unsafe_arena_set_allocated_prop_message( + ::protobuf::MessageOfProp* prop_message + ); + ::protobuf::MessageOfProp* unsafe_arena_release_prop_message(); + + // .protobuf.MessageOfBullet bullet_message = 4; + bool has_bullet_message() const; + + private: + bool _internal_has_bullet_message() const; + + public: + void clear_bullet_message(); + const ::protobuf::MessageOfBullet& bullet_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfBullet* release_bullet_message(); + ::protobuf::MessageOfBullet* mutable_bullet_message(); + void set_allocated_bullet_message(::protobuf::MessageOfBullet* bullet_message); + + private: + const ::protobuf::MessageOfBullet& _internal_bullet_message() const; + ::protobuf::MessageOfBullet* _internal_mutable_bullet_message(); + + public: + void unsafe_arena_set_allocated_bullet_message( + ::protobuf::MessageOfBullet* bullet_message + ); + ::protobuf::MessageOfBullet* unsafe_arena_release_bullet_message(); + + // .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; + bool has_bombed_bullet_message() const; + + private: + bool _internal_has_bombed_bullet_message() const; + + public: + void clear_bombed_bullet_message(); + const ::protobuf::MessageOfBombedBullet& bombed_bullet_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfBombedBullet* release_bombed_bullet_message(); + ::protobuf::MessageOfBombedBullet* mutable_bombed_bullet_message(); + void set_allocated_bombed_bullet_message(::protobuf::MessageOfBombedBullet* bombed_bullet_message); + + private: + const ::protobuf::MessageOfBombedBullet& _internal_bombed_bullet_message() const; + ::protobuf::MessageOfBombedBullet* _internal_mutable_bombed_bullet_message(); + + public: + void unsafe_arena_set_allocated_bombed_bullet_message( + ::protobuf::MessageOfBombedBullet* bombed_bullet_message + ); + ::protobuf::MessageOfBombedBullet* unsafe_arena_release_bombed_bullet_message(); + + void clear_message_of_obj(); + MessageOfObjCase message_of_obj_case() const; + // @@protoc_insertion_point(class_scope:protobuf.MessageOfObj) + + private: + class _Internal; + void set_has_student_message(); + void set_has_tricker_message(); + void set_has_prop_message(); + void set_has_bullet_message(); + void set_has_bombed_bullet_message(); + + inline bool has_message_of_obj() const; + inline void clear_has_message_of_obj(); + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + union MessageOfObjUnion + { + constexpr MessageOfObjUnion() : + _constinit_{} + { + } + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::protobuf::MessageOfStudent* student_message_; + ::protobuf::MessageOfTricker* tricker_message_; + ::protobuf::MessageOfProp* prop_message_; + ::protobuf::MessageOfBullet* bullet_message_; + ::protobuf::MessageOfBombedBullet* bombed_bullet_message_; + } message_of_obj_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t _oneof_case_[1]; + }; + union + { + Impl_ _impl_; + }; + friend struct ::TableStruct_Message2Clients_2eproto; + }; + // ------------------------------------------------------------------- + + class MessageOfAll final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageOfAll) */ + { + public: + inline MessageOfAll() : + MessageOfAll(nullptr) + { + } + ~MessageOfAll() override; + explicit PROTOBUF_CONSTEXPR MessageOfAll(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageOfAll(const MessageOfAll& from); + MessageOfAll(MessageOfAll&& from) noexcept + : + MessageOfAll() + { + *this = ::std::move(from); + } + + inline MessageOfAll& operator=(const MessageOfAll& from) + { + CopyFrom(from); + return *this; + } + inline MessageOfAll& operator=(MessageOfAll&& 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 MessageOfAll& default_instance() + { + return *internal_default_instance(); + } + static inline const MessageOfAll* internal_default_instance() + { + return reinterpret_cast( + &_MessageOfAll_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(MessageOfAll& a, MessageOfAll& b) + { + a.Swap(&b); + } + inline void Swap(MessageOfAll* 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(MessageOfAll* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MessageOfAll* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MessageOfAll& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MessageOfAll& from) + { + MessageOfAll::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(MessageOfAll* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.MessageOfAll"; + } + + protected: + explicit MessageOfAll(::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 + { + kGameTimeFieldNumber = 1, + kSubjectLeftFieldNumber = 2, + kStudentGraduatedFieldNumber = 3, + kStudentQuitedFieldNumber = 4, + kStudentScoreFieldNumber = 5, + kTrickerScoreFieldNumber = 6, + kGateOpenedFieldNumber = 7, + kHiddenGateRefreshedFieldNumber = 8, + kHiddenGateOpenedFieldNumber = 9, + }; + // int32 game_time = 1; + void clear_game_time(); + int32_t game_time() const; + void set_game_time(int32_t value); + + private: + int32_t _internal_game_time() const; + void _internal_set_game_time(int32_t value); + + public: + // int32 subject_left = 2; + void clear_subject_left(); + int32_t subject_left() const; + void set_subject_left(int32_t value); + + private: + int32_t _internal_subject_left() const; + void _internal_set_subject_left(int32_t value); + + public: + // int32 student_graduated = 3; + void clear_student_graduated(); + int32_t student_graduated() const; + void set_student_graduated(int32_t value); + + private: + int32_t _internal_student_graduated() const; + void _internal_set_student_graduated(int32_t value); + + public: + // int32 student_quited = 4; + void clear_student_quited(); + int32_t student_quited() const; + void set_student_quited(int32_t value); + + private: + int32_t _internal_student_quited() const; + void _internal_set_student_quited(int32_t value); + + public: + // int32 student_score = 5; + void clear_student_score(); + int32_t student_score() const; + void set_student_score(int32_t value); + + private: + int32_t _internal_student_score() const; + void _internal_set_student_score(int32_t value); + + public: + // int32 tricker_score = 6; + void clear_tricker_score(); + int32_t tricker_score() const; + void set_tricker_score(int32_t value); + + private: + int32_t _internal_tricker_score() const; + void _internal_set_tricker_score(int32_t value); + + public: + // bool gate_opened = 7; + void clear_gate_opened(); + bool gate_opened() const; + void set_gate_opened(bool value); + + private: + bool _internal_gate_opened() const; + void _internal_set_gate_opened(bool value); + + public: + // bool hidden_gate_refreshed = 8; + void clear_hidden_gate_refreshed(); + bool hidden_gate_refreshed() const; + void set_hidden_gate_refreshed(bool value); + + private: + bool _internal_hidden_gate_refreshed() const; + void _internal_set_hidden_gate_refreshed(bool value); + + public: + // bool hidden_gate_opened = 9; + void clear_hidden_gate_opened(); + bool hidden_gate_opened() const; + void set_hidden_gate_opened(bool value); + + private: + bool _internal_hidden_gate_opened() const; + void _internal_set_hidden_gate_opened(bool value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.MessageOfAll) + + private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + int32_t game_time_; + int32_t subject_left_; + int32_t student_graduated_; + int32_t student_quited_; + int32_t student_score_; + int32_t tricker_score_; + bool gate_opened_; + bool hidden_gate_refreshed_; + bool hidden_gate_opened_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union + { + Impl_ _impl_; + }; + friend struct ::TableStruct_Message2Clients_2eproto; + }; + // ------------------------------------------------------------------- + + class MessageToClient final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MessageToClient) */ + { + public: + inline MessageToClient() : + MessageToClient(nullptr) + { + } + ~MessageToClient() override; + explicit PROTOBUF_CONSTEXPR MessageToClient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageToClient(const MessageToClient& from); + MessageToClient(MessageToClient&& from) noexcept + : + MessageToClient() + { + *this = ::std::move(from); + } + + inline MessageToClient& operator=(const MessageToClient& from) + { + CopyFrom(from); + return *this; + } + inline MessageToClient& operator=(MessageToClient&& 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 MessageToClient& default_instance() + { + return *internal_default_instance(); + } + static inline const MessageToClient* internal_default_instance() + { + return reinterpret_cast( + &_MessageToClient_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(MessageToClient& a, MessageToClient& b) + { + a.Swap(&b); + } + inline void Swap(MessageToClient* 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(MessageToClient* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MessageToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MessageToClient& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MessageToClient& from) + { + MessageToClient::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(MessageToClient* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.MessageToClient"; + } + + protected: + explicit MessageToClient(::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 + { + kObjMessageFieldNumber = 1, + kMapMessageFieldNumber = 2, + kAllMessageFieldNumber = 4, + kGameStateFieldNumber = 3, + }; + // repeated .protobuf.MessageOfObj obj_message = 1; + int obj_message_size() const; + + private: + int _internal_obj_message_size() const; + + public: + void clear_obj_message(); + ::protobuf::MessageOfObj* mutable_obj_message(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfObj>* + mutable_obj_message(); + + private: + const ::protobuf::MessageOfObj& _internal_obj_message(int index) const; + ::protobuf::MessageOfObj* _internal_add_obj_message(); + + public: + const ::protobuf::MessageOfObj& obj_message(int index) const; + ::protobuf::MessageOfObj* add_obj_message(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfObj>& + obj_message() const; + + // .protobuf.MessageOfMap map_message = 2; + bool has_map_message() const; + + private: + bool _internal_has_map_message() const; + + public: + void clear_map_message(); + const ::protobuf::MessageOfMap& map_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfMap* release_map_message(); + ::protobuf::MessageOfMap* mutable_map_message(); + void set_allocated_map_message(::protobuf::MessageOfMap* map_message); + + private: + const ::protobuf::MessageOfMap& _internal_map_message() const; + ::protobuf::MessageOfMap* _internal_mutable_map_message(); + + public: + void unsafe_arena_set_allocated_map_message( + ::protobuf::MessageOfMap* map_message + ); + ::protobuf::MessageOfMap* unsafe_arena_release_map_message(); + + // .protobuf.MessageOfAll all_message = 4; + bool has_all_message() const; + + private: + bool _internal_has_all_message() const; + + public: + void clear_all_message(); + const ::protobuf::MessageOfAll& all_message() const; + PROTOBUF_NODISCARD ::protobuf::MessageOfAll* release_all_message(); + ::protobuf::MessageOfAll* mutable_all_message(); + void set_allocated_all_message(::protobuf::MessageOfAll* all_message); + + private: + const ::protobuf::MessageOfAll& _internal_all_message() const; + ::protobuf::MessageOfAll* _internal_mutable_all_message(); + + public: + void unsafe_arena_set_allocated_all_message( + ::protobuf::MessageOfAll* all_message + ); + ::protobuf::MessageOfAll* unsafe_arena_release_all_message(); + + // .protobuf.GameState game_state = 3; + void clear_game_state(); + ::protobuf::GameState game_state() const; + void set_game_state(::protobuf::GameState value); + + private: + ::protobuf::GameState _internal_game_state() const; + void _internal_set_game_state(::protobuf::GameState value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.MessageToClient) + + private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfObj> obj_message_; + ::protobuf::MessageOfMap* map_message_; + ::protobuf::MessageOfAll* all_message_; + int game_state_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union + { + Impl_ _impl_; + }; + friend struct ::TableStruct_Message2Clients_2eproto; + }; + // ------------------------------------------------------------------- + + class MoveRes final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.MoveRes) */ + { + public: + inline MoveRes() : + MoveRes(nullptr) + { + } + ~MoveRes() override; + explicit PROTOBUF_CONSTEXPR MoveRes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MoveRes(const MoveRes& from); + MoveRes(MoveRes&& from) noexcept + : + MoveRes() + { + *this = ::std::move(from); + } + + inline MoveRes& operator=(const MoveRes& from) + { + CopyFrom(from); + return *this; + } + inline MoveRes& operator=(MoveRes&& 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 MoveRes& default_instance() + { + return *internal_default_instance(); + } + static inline const MoveRes* internal_default_instance() + { + return reinterpret_cast( + &_MoveRes_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(MoveRes& a, MoveRes& b) + { + a.Swap(&b); + } + inline void Swap(MoveRes* 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(MoveRes* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MoveRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MoveRes& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MoveRes& from) + { + MoveRes::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(MoveRes* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.MoveRes"; + } + + protected: + explicit MoveRes(::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 + { + kActualSpeedFieldNumber = 1, + kActualAngleFieldNumber = 2, + kActSuccessFieldNumber = 3, + }; + // int64 actual_speed = 1; + void clear_actual_speed(); + int64_t actual_speed() const; + void set_actual_speed(int64_t value); + + private: + int64_t _internal_actual_speed() const; + void _internal_set_actual_speed(int64_t value); + + public: + // double actual_angle = 2; + void clear_actual_angle(); + double actual_angle() const; + void set_actual_angle(double value); + + private: + double _internal_actual_angle() const; + void _internal_set_actual_angle(double value); + + public: + // bool act_success = 3; + void clear_act_success(); + bool act_success() const; + void set_act_success(bool value); + + private: + bool _internal_act_success() const; + void _internal_set_act_success(bool value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.MoveRes) + + private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + int64_t actual_speed_; + double actual_angle_; + bool act_success_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union + { + Impl_ _impl_; + }; + friend struct ::TableStruct_Message2Clients_2eproto; + }; + // ------------------------------------------------------------------- + + class BoolRes final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.BoolRes) */ + { + public: + inline BoolRes() : + BoolRes(nullptr) + { + } + ~BoolRes() override; + explicit PROTOBUF_CONSTEXPR BoolRes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BoolRes(const BoolRes& from); + BoolRes(BoolRes&& from) noexcept + : + BoolRes() + { + *this = ::std::move(from); + } + + inline BoolRes& operator=(const BoolRes& from) + { + CopyFrom(from); + return *this; + } + inline BoolRes& operator=(BoolRes&& 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 BoolRes& default_instance() + { + return *internal_default_instance(); + } + static inline const BoolRes* internal_default_instance() + { + return reinterpret_cast( + &_BoolRes_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(BoolRes& a, BoolRes& b) + { + a.Swap(&b); + } + inline void Swap(BoolRes* 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(BoolRes* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BoolRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BoolRes& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const BoolRes& from) + { + BoolRes::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(BoolRes* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.BoolRes"; + } + + protected: + explicit BoolRes(::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 + { + kActSuccessFieldNumber = 1, + }; + // bool act_success = 1; + void clear_act_success(); + bool act_success() const; + void set_act_success(bool value); + + private: + bool _internal_act_success() const; + void _internal_set_act_success(bool value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.BoolRes) + + private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + bool act_success_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union + { + Impl_ _impl_; + }; + 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 PROTOBUF_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( + &_MsgRes_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 18; + + 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(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MsgRes& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const MsgRes& from) + { + MsgRes::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(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); + + 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 + 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 + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_received_; + int64_t from_player_id_; + bool have_message_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union + { + Impl_ _impl_; + }; + friend struct ::TableStruct_Message2Clients_2eproto; + }; + // =================================================================== + + // =================================================================== + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ + // MessageOfStudent + + // int32 x = 1; + inline void MessageOfStudent::clear_x() + { + _impl_.x_ = 0; + } + inline int32_t MessageOfStudent::_internal_x() const + { + return _impl_.x_; + } + inline int32_t MessageOfStudent::x() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.x) + return _internal_x(); + } + inline void MessageOfStudent::_internal_set_x(int32_t value) + { + _impl_.x_ = value; + } + inline void MessageOfStudent::set_x(int32_t value) + { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.x) + } + + // int32 y = 2; + inline void MessageOfStudent::clear_y() + { + _impl_.y_ = 0; + } + inline int32_t MessageOfStudent::_internal_y() const + { + return _impl_.y_; + } + inline int32_t MessageOfStudent::y() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.y) + return _internal_y(); + } + inline void MessageOfStudent::_internal_set_y(int32_t value) + { + _impl_.y_ = value; + } + inline void MessageOfStudent::set_y(int32_t value) + { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.y) + } + + // int32 speed = 3; + inline void MessageOfStudent::clear_speed() + { + _impl_.speed_ = 0; + } + inline int32_t MessageOfStudent::_internal_speed() const + { + return _impl_.speed_; + } + inline int32_t MessageOfStudent::speed() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.speed) + return _internal_speed(); + } + inline void MessageOfStudent::_internal_set_speed(int32_t value) + { + _impl_.speed_ = value; + } + inline void MessageOfStudent::set_speed(int32_t value) + { + _internal_set_speed(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.speed) + } + + // int32 determination = 4; + inline void MessageOfStudent::clear_determination() + { + _impl_.determination_ = 0; + } + inline int32_t MessageOfStudent::_internal_determination() const + { + return _impl_.determination_; + } + inline int32_t MessageOfStudent::determination() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.determination) + return _internal_determination(); + } + inline void MessageOfStudent::_internal_set_determination(int32_t value) + { + _impl_.determination_ = value; + } + inline void MessageOfStudent::set_determination(int32_t value) + { + _internal_set_determination(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.determination) + } + + // int32 fail_num = 5; + inline void MessageOfStudent::clear_fail_num() + { + _impl_.fail_num_ = 0; + } + inline int32_t MessageOfStudent::_internal_fail_num() const + { + return _impl_.fail_num_; + } + inline int32_t MessageOfStudent::fail_num() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.fail_num) + return _internal_fail_num(); + } + inline void MessageOfStudent::_internal_set_fail_num(int32_t value) + { + _impl_.fail_num_ = value; + } + inline void MessageOfStudent::set_fail_num(int32_t value) + { + _internal_set_fail_num(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.fail_num) + } + + // double time_until_skill_available = 6; + inline void MessageOfStudent::clear_time_until_skill_available() + { + _impl_.time_until_skill_available_ = 0; + } + inline double MessageOfStudent::_internal_time_until_skill_available() const + { + return _impl_.time_until_skill_available_; + } + inline double MessageOfStudent::time_until_skill_available() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.time_until_skill_available) + return _internal_time_until_skill_available(); + } + inline void MessageOfStudent::_internal_set_time_until_skill_available(double value) + { + _impl_.time_until_skill_available_ = value; + } + inline void MessageOfStudent::set_time_until_skill_available(double value) + { + _internal_set_time_until_skill_available(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.time_until_skill_available) + } + + // .protobuf.PlaceType place = 7; + inline void MessageOfStudent::clear_place() + { + _impl_.place_ = 0; + } + inline ::protobuf::PlaceType MessageOfStudent::_internal_place() const + { + return static_cast<::protobuf::PlaceType>(_impl_.place_); + } + inline ::protobuf::PlaceType MessageOfStudent::place() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.place) + return _internal_place(); + } + inline void MessageOfStudent::_internal_set_place(::protobuf::PlaceType value) + { + _impl_.place_ = value; + } + inline void MessageOfStudent::set_place(::protobuf::PlaceType value) + { + _internal_set_place(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.place) + } + + // repeated .protobuf.PropType prop = 8; + inline int MessageOfStudent::_internal_prop_size() const + { + return _impl_.prop_.size(); + } + inline int MessageOfStudent::prop_size() const + { + return _internal_prop_size(); + } + inline void MessageOfStudent::clear_prop() + { + _impl_.prop_.Clear(); + } + inline ::protobuf::PropType MessageOfStudent::_internal_prop(int index) const + { + return static_cast<::protobuf::PropType>(_impl_.prop_.Get(index)); + } + inline ::protobuf::PropType MessageOfStudent::prop(int index) const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.prop) + return _internal_prop(index); + } + inline void MessageOfStudent::set_prop(int index, ::protobuf::PropType value) + { + _impl_.prop_.Set(index, value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.prop) + } + inline void MessageOfStudent::_internal_add_prop(::protobuf::PropType value) + { + _impl_.prop_.Add(value); + } + inline void MessageOfStudent::add_prop(::protobuf::PropType value) + { + _internal_add_prop(value); + // @@protoc_insertion_point(field_add:protobuf.MessageOfStudent.prop) + } + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& + MessageOfStudent::prop() const + { + // @@protoc_insertion_point(field_list:protobuf.MessageOfStudent.prop) + return _impl_.prop_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfStudent::_internal_mutable_prop() + { + return &_impl_.prop_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfStudent::mutable_prop() + { + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfStudent.prop) + return _internal_mutable_prop(); + } + + // .protobuf.PlayerState player_state = 9; + inline void MessageOfStudent::clear_player_state() + { + _impl_.player_state_ = 0; + } + inline ::protobuf::PlayerState MessageOfStudent::_internal_player_state() const + { + return static_cast<::protobuf::PlayerState>(_impl_.player_state_); + } + inline ::protobuf::PlayerState MessageOfStudent::player_state() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.player_state) + return _internal_player_state(); + } + inline void MessageOfStudent::_internal_set_player_state(::protobuf::PlayerState value) + { + _impl_.player_state_ = value; + } + inline void MessageOfStudent::set_player_state(::protobuf::PlayerState value) + { + _internal_set_player_state(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.player_state) + } + + // int64 guid = 10; + inline void MessageOfStudent::clear_guid() + { + _impl_.guid_ = int64_t{0}; + } + inline int64_t MessageOfStudent::_internal_guid() const + { + return _impl_.guid_; + } + inline int64_t MessageOfStudent::guid() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.guid) + return _internal_guid(); + } + inline void MessageOfStudent::_internal_set_guid(int64_t value) + { + _impl_.guid_ = value; + } + inline void MessageOfStudent::set_guid(int64_t value) + { + _internal_set_guid(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.guid) + } + + // .protobuf.PlayerState state = 11; + inline void MessageOfStudent::clear_state() + { + _impl_.state_ = 0; + } + inline ::protobuf::PlayerState MessageOfStudent::_internal_state() const + { + return static_cast<::protobuf::PlayerState>(_impl_.state_); + } + inline ::protobuf::PlayerState MessageOfStudent::state() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.state) + return _internal_state(); + } + inline void MessageOfStudent::_internal_set_state(::protobuf::PlayerState value) + { + _impl_.state_ = value; + } + inline void MessageOfStudent::set_state(::protobuf::PlayerState value) + { + _internal_set_state(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.state) + } + + // double fail_time = 12; + inline void MessageOfStudent::clear_fail_time() + { + _impl_.fail_time_ = 0; + } + inline double MessageOfStudent::_internal_fail_time() const + { + return _impl_.fail_time_; + } + inline double MessageOfStudent::fail_time() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.fail_time) + return _internal_fail_time(); + } + inline void MessageOfStudent::_internal_set_fail_time(double value) + { + _impl_.fail_time_ = value; + } + inline void MessageOfStudent::set_fail_time(double value) + { + _internal_set_fail_time(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.fail_time) + } + + // double emo_time = 14; + inline void MessageOfStudent::clear_emo_time() + { + _impl_.emo_time_ = 0; + } + inline double MessageOfStudent::_internal_emo_time() const + { + return _impl_.emo_time_; + } + inline double MessageOfStudent::emo_time() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.emo_time) + return _internal_emo_time(); + } + inline void MessageOfStudent::_internal_set_emo_time(double value) + { + _impl_.emo_time_ = value; + } + inline void MessageOfStudent::set_emo_time(double value) + { + _internal_set_emo_time(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.emo_time) + } + + // int64 player_id = 15; + inline void MessageOfStudent::clear_player_id() + { + _impl_.player_id_ = int64_t{0}; + } + inline int64_t MessageOfStudent::_internal_player_id() const + { + return _impl_.player_id_; + } + inline int64_t MessageOfStudent::player_id() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.player_id) + return _internal_player_id(); + } + inline void MessageOfStudent::_internal_set_player_id(int64_t value) + { + _impl_.player_id_ = value; + } + inline void MessageOfStudent::set_player_id(int64_t value) + { + _internal_set_player_id(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.player_id) + } + + // int32 view_range = 16; + inline void MessageOfStudent::clear_view_range() + { + _impl_.view_range_ = 0; + } + inline int32_t MessageOfStudent::_internal_view_range() const + { + return _impl_.view_range_; + } + inline int32_t MessageOfStudent::view_range() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.view_range) + return _internal_view_range(); + } + inline void MessageOfStudent::_internal_set_view_range(int32_t value) + { + _impl_.view_range_ = value; + } + inline void MessageOfStudent::set_view_range(int32_t value) + { + _internal_set_view_range(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.view_range) + } + + // int32 radius = 17; + inline void MessageOfStudent::clear_radius() + { + _impl_.radius_ = 0; + } + inline int32_t MessageOfStudent::_internal_radius() const + { + return _impl_.radius_; + } + inline int32_t MessageOfStudent::radius() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.radius) + return _internal_radius(); + } + inline void MessageOfStudent::_internal_set_radius(int32_t value) + { + _impl_.radius_ = value; + } + inline void MessageOfStudent::set_radius(int32_t value) + { + _internal_set_radius(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.radius) + } + + // int32 damage = 18; + inline void MessageOfStudent::clear_damage() + { + _impl_.damage_ = 0; + } + inline int32_t MessageOfStudent::_internal_damage() const + { + return _impl_.damage_; + } + inline int32_t MessageOfStudent::damage() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.damage) + return _internal_damage(); + } + inline void MessageOfStudent::_internal_set_damage(int32_t value) + { + _impl_.damage_ = value; + } + inline void MessageOfStudent::set_damage(int32_t value) + { + _internal_set_damage(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.damage) + } + + // double danger_alert = 19; + inline void MessageOfStudent::clear_danger_alert() + { + _impl_.danger_alert_ = 0; + } + inline double MessageOfStudent::_internal_danger_alert() const + { + return _impl_.danger_alert_; + } + inline double MessageOfStudent::danger_alert() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.danger_alert) + return _internal_danger_alert(); + } + inline void MessageOfStudent::_internal_set_danger_alert(double value) + { + _impl_.danger_alert_ = value; + } + inline void MessageOfStudent::set_danger_alert(double value) + { + _internal_set_danger_alert(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.danger_alert) + } + + // int32 score = 20; + inline void MessageOfStudent::clear_score() + { + _impl_.score_ = 0; + } + inline int32_t MessageOfStudent::_internal_score() const + { + return _impl_.score_; + } + inline int32_t MessageOfStudent::score() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.score) + return _internal_score(); + } + inline void MessageOfStudent::_internal_set_score(int32_t value) + { + _impl_.score_ = value; + } + inline void MessageOfStudent::set_score(int32_t value) + { + _internal_set_score(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.score) + } + + // int32 treat_progress = 21; + inline void MessageOfStudent::clear_treat_progress() + { + _impl_.treat_progress_ = 0; + } + inline int32_t MessageOfStudent::_internal_treat_progress() const + { + return _impl_.treat_progress_; + } + inline int32_t MessageOfStudent::treat_progress() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.treat_progress) + return _internal_treat_progress(); + } + inline void MessageOfStudent::_internal_set_treat_progress(int32_t value) + { + _impl_.treat_progress_ = value; + } + inline void MessageOfStudent::set_treat_progress(int32_t value) + { + _internal_set_treat_progress(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.treat_progress) + } + + // int32 rescue_progress = 22; + inline void MessageOfStudent::clear_rescue_progress() + { + _impl_.rescue_progress_ = 0; + } + inline int32_t MessageOfStudent::_internal_rescue_progress() const + { + return _impl_.rescue_progress_; + } + inline int32_t MessageOfStudent::rescue_progress() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.rescue_progress) + return _internal_rescue_progress(); + } + inline void MessageOfStudent::_internal_set_rescue_progress(int32_t value) + { + _impl_.rescue_progress_ = value; + } + inline void MessageOfStudent::set_rescue_progress(int32_t value) + { + _internal_set_rescue_progress(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.rescue_progress) + } + + // .protobuf.StudentType student_type = 23; + inline void MessageOfStudent::clear_student_type() + { + _impl_.student_type_ = 0; + } + inline ::protobuf::StudentType MessageOfStudent::_internal_student_type() const + { + return static_cast<::protobuf::StudentType>(_impl_.student_type_); + } + inline ::protobuf::StudentType MessageOfStudent::student_type() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.student_type) + return _internal_student_type(); + } + inline void MessageOfStudent::_internal_set_student_type(::protobuf::StudentType value) + { + _impl_.student_type_ = value; + } + inline void MessageOfStudent::set_student_type(::protobuf::StudentType value) + { + _internal_set_student_type(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.student_type) + } + + // repeated .protobuf.StudentBuffType buff = 24; + inline int MessageOfStudent::_internal_buff_size() const + { + return _impl_.buff_.size(); + } + inline int MessageOfStudent::buff_size() const + { + return _internal_buff_size(); + } + inline void MessageOfStudent::clear_buff() + { + _impl_.buff_.Clear(); + } + inline ::protobuf::StudentBuffType MessageOfStudent::_internal_buff(int index) const + { + return static_cast<::protobuf::StudentBuffType>(_impl_.buff_.Get(index)); + } + inline ::protobuf::StudentBuffType MessageOfStudent::buff(int index) const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.buff) + return _internal_buff(index); + } + inline void MessageOfStudent::set_buff(int index, ::protobuf::StudentBuffType value) + { + _impl_.buff_.Set(index, value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.buff) + } + inline void MessageOfStudent::_internal_add_buff(::protobuf::StudentBuffType value) + { + _impl_.buff_.Add(value); + } + inline void MessageOfStudent::add_buff(::protobuf::StudentBuffType value) + { + _internal_add_buff(value); + // @@protoc_insertion_point(field_add:protobuf.MessageOfStudent.buff) + } + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& + MessageOfStudent::buff() const + { + // @@protoc_insertion_point(field_list:protobuf.MessageOfStudent.buff) + return _impl_.buff_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfStudent::_internal_mutable_buff() + { + return &_impl_.buff_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfStudent::mutable_buff() + { + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfStudent.buff) + return _internal_mutable_buff(); + } + + // ------------------------------------------------------------------- + + // MessageOfTricker + + // int32 x = 1; + inline void MessageOfTricker::clear_x() + { + _impl_.x_ = 0; + } + inline int32_t MessageOfTricker::_internal_x() const + { + return _impl_.x_; + } + inline int32_t MessageOfTricker::x() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.x) + return _internal_x(); + } + inline void MessageOfTricker::_internal_set_x(int32_t value) + { + _impl_.x_ = value; + } + inline void MessageOfTricker::set_x(int32_t value) + { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.x) + } + + // int32 y = 2; + inline void MessageOfTricker::clear_y() + { + _impl_.y_ = 0; + } + inline int32_t MessageOfTricker::_internal_y() const + { + return _impl_.y_; + } + inline int32_t MessageOfTricker::y() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.y) + return _internal_y(); + } + inline void MessageOfTricker::_internal_set_y(int32_t value) + { + _impl_.y_ = value; + } + inline void MessageOfTricker::set_y(int32_t value) + { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.y) + } + + // int32 speed = 3; + inline void MessageOfTricker::clear_speed() + { + _impl_.speed_ = 0; + } + inline int32_t MessageOfTricker::_internal_speed() const + { + return _impl_.speed_; + } + inline int32_t MessageOfTricker::speed() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.speed) + return _internal_speed(); + } + inline void MessageOfTricker::_internal_set_speed(int32_t value) + { + _impl_.speed_ = value; + } + inline void MessageOfTricker::set_speed(int32_t value) + { + _internal_set_speed(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.speed) + } + + // int32 damage = 4; + inline void MessageOfTricker::clear_damage() + { + _impl_.damage_ = 0; + } + inline int32_t MessageOfTricker::_internal_damage() const + { + return _impl_.damage_; + } + inline int32_t MessageOfTricker::damage() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.damage) + return _internal_damage(); + } + inline void MessageOfTricker::_internal_set_damage(int32_t value) + { + _impl_.damage_ = value; + } + inline void MessageOfTricker::set_damage(int32_t value) + { + _internal_set_damage(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.damage) + } + + // double time_until_skill_available = 5; + inline void MessageOfTricker::clear_time_until_skill_available() + { + _impl_.time_until_skill_available_ = 0; + } + inline double MessageOfTricker::_internal_time_until_skill_available() const + { + return _impl_.time_until_skill_available_; + } + inline double MessageOfTricker::time_until_skill_available() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.time_until_skill_available) + return _internal_time_until_skill_available(); + } + inline void MessageOfTricker::_internal_set_time_until_skill_available(double value) + { + _impl_.time_until_skill_available_ = value; + } + inline void MessageOfTricker::set_time_until_skill_available(double value) + { + _internal_set_time_until_skill_available(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.time_until_skill_available) + } + + // .protobuf.PlaceType place = 6; + inline void MessageOfTricker::clear_place() + { + _impl_.place_ = 0; + } + inline ::protobuf::PlaceType MessageOfTricker::_internal_place() const + { + return static_cast<::protobuf::PlaceType>(_impl_.place_); + } + inline ::protobuf::PlaceType MessageOfTricker::place() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.place) + return _internal_place(); + } + inline void MessageOfTricker::_internal_set_place(::protobuf::PlaceType value) + { + _impl_.place_ = value; + } + inline void MessageOfTricker::set_place(::protobuf::PlaceType value) + { + _internal_set_place(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.place) + } + + // repeated .protobuf.PropType prop = 7; + inline int MessageOfTricker::_internal_prop_size() const + { + return _impl_.prop_.size(); + } + inline int MessageOfTricker::prop_size() const + { + return _internal_prop_size(); + } + inline void MessageOfTricker::clear_prop() + { + _impl_.prop_.Clear(); + } + inline ::protobuf::PropType MessageOfTricker::_internal_prop(int index) const + { + return static_cast<::protobuf::PropType>(_impl_.prop_.Get(index)); + } + inline ::protobuf::PropType MessageOfTricker::prop(int index) const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.prop) + return _internal_prop(index); + } + inline void MessageOfTricker::set_prop(int index, ::protobuf::PropType value) + { + _impl_.prop_.Set(index, value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.prop) + } + inline void MessageOfTricker::_internal_add_prop(::protobuf::PropType value) + { + _impl_.prop_.Add(value); + } + inline void MessageOfTricker::add_prop(::protobuf::PropType value) + { + _internal_add_prop(value); + // @@protoc_insertion_point(field_add:protobuf.MessageOfTricker.prop) + } + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& + MessageOfTricker::prop() const + { + // @@protoc_insertion_point(field_list:protobuf.MessageOfTricker.prop) + return _impl_.prop_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfTricker::_internal_mutable_prop() + { + return &_impl_.prop_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfTricker::mutable_prop() + { + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfTricker.prop) + return _internal_mutable_prop(); + } + + // .protobuf.TrickerType tricker_type = 8; + inline void MessageOfTricker::clear_tricker_type() + { + _impl_.tricker_type_ = 0; + } + inline ::protobuf::TrickerType MessageOfTricker::_internal_tricker_type() const + { + return static_cast<::protobuf::TrickerType>(_impl_.tricker_type_); + } + inline ::protobuf::TrickerType MessageOfTricker::tricker_type() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.tricker_type) + return _internal_tricker_type(); + } + inline void MessageOfTricker::_internal_set_tricker_type(::protobuf::TrickerType value) + { + _impl_.tricker_type_ = value; + } + inline void MessageOfTricker::set_tricker_type(::protobuf::TrickerType value) + { + _internal_set_tricker_type(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.tricker_type) + } + + // int64 guid = 9; + inline void MessageOfTricker::clear_guid() + { + _impl_.guid_ = int64_t{0}; + } + inline int64_t MessageOfTricker::_internal_guid() const + { + return _impl_.guid_; + } + inline int64_t MessageOfTricker::guid() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.guid) + return _internal_guid(); + } + inline void MessageOfTricker::_internal_set_guid(int64_t value) + { + _impl_.guid_ = value; + } + inline void MessageOfTricker::set_guid(int64_t value) + { + _internal_set_guid(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.guid) + } + + // bool movable = 10; + inline void MessageOfTricker::clear_movable() + { + _impl_.movable_ = false; + } + inline bool MessageOfTricker::_internal_movable() const + { + return _impl_.movable_; + } + inline bool MessageOfTricker::movable() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.movable) + return _internal_movable(); + } + inline void MessageOfTricker::_internal_set_movable(bool value) + { + _impl_.movable_ = value; + } + inline void MessageOfTricker::set_movable(bool value) + { + _internal_set_movable(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.movable) + } + + // int64 player_id = 11; + inline void MessageOfTricker::clear_player_id() + { + _impl_.player_id_ = int64_t{0}; + } + inline int64_t MessageOfTricker::_internal_player_id() const + { + return _impl_.player_id_; + } + inline int64_t MessageOfTricker::player_id() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.player_id) + return _internal_player_id(); + } + inline void MessageOfTricker::_internal_set_player_id(int64_t value) + { + _impl_.player_id_ = value; + } + inline void MessageOfTricker::set_player_id(int64_t value) + { + _internal_set_player_id(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.player_id) + } + + // int32 view_range = 12; + inline void MessageOfTricker::clear_view_range() + { + _impl_.view_range_ = 0; + } + inline int32_t MessageOfTricker::_internal_view_range() const + { + return _impl_.view_range_; + } + inline int32_t MessageOfTricker::view_range() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.view_range) + return _internal_view_range(); + } + inline void MessageOfTricker::_internal_set_view_range(int32_t value) { - _impl_.determination_ = value; + _impl_.view_range_ = value; } - inline void MessageOfStudent::set_determination(int32_t value) + inline void MessageOfTricker::set_view_range(int32_t value) { - _internal_set_determination(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.determination) + _internal_set_view_range(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.view_range) } - // int32 fail_num = 5; - inline void MessageOfStudent::clear_fail_num() + // int32 radius = 13; + inline void MessageOfTricker::clear_radius() { - _impl_.fail_num_ = 0; + _impl_.radius_ = 0; } - inline int32_t MessageOfStudent::_internal_fail_num() const + inline int32_t MessageOfTricker::_internal_radius() const { - return _impl_.fail_num_; + return _impl_.radius_; } - inline int32_t MessageOfStudent::fail_num() const + inline int32_t MessageOfTricker::radius() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.fail_num) - return _internal_fail_num(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.radius) + return _internal_radius(); } - inline void MessageOfStudent::_internal_set_fail_num(int32_t value) + inline void MessageOfTricker::_internal_set_radius(int32_t value) { - _impl_.fail_num_ = value; + _impl_.radius_ = value; } - inline void MessageOfStudent::set_fail_num(int32_t value) + inline void MessageOfTricker::set_radius(int32_t value) { - _internal_set_fail_num(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.fail_num) + _internal_set_radius(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.radius) } - // double time_until_skill_available = 6; - inline void MessageOfStudent::clear_time_until_skill_available() + // .protobuf.PlayerState player_state = 14; + inline void MessageOfTricker::clear_player_state() { - _impl_.time_until_skill_available_ = 0; + _impl_.player_state_ = 0; } - inline double MessageOfStudent::_internal_time_until_skill_available() const + inline ::protobuf::PlayerState MessageOfTricker::_internal_player_state() const + { + return static_cast<::protobuf::PlayerState>(_impl_.player_state_); + } + inline ::protobuf::PlayerState MessageOfTricker::player_state() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.player_state) + return _internal_player_state(); + } + inline void MessageOfTricker::_internal_set_player_state(::protobuf::PlayerState value) + { + _impl_.player_state_ = value; + } + inline void MessageOfTricker::set_player_state(::protobuf::PlayerState value) + { + _internal_set_player_state(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.player_state) + } + + // double trick_desire = 15; + inline void MessageOfTricker::clear_trick_desire() + { + _impl_.trick_desire_ = 0; + } + inline double MessageOfTricker::_internal_trick_desire() const + { + return _impl_.trick_desire_; + } + inline double MessageOfTricker::trick_desire() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.trick_desire) + return _internal_trick_desire(); + } + inline void MessageOfTricker::_internal_set_trick_desire(double value) + { + _impl_.trick_desire_ = value; + } + inline void MessageOfTricker::set_trick_desire(double value) + { + _internal_set_trick_desire(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.trick_desire) + } + + // double class_volume = 16; + inline void MessageOfTricker::clear_class_volume() + { + _impl_.class_volume_ = 0; + } + inline double MessageOfTricker::_internal_class_volume() const + { + return _impl_.class_volume_; + } + inline double MessageOfTricker::class_volume() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.class_volume) + return _internal_class_volume(); + } + inline void MessageOfTricker::_internal_set_class_volume(double value) + { + _impl_.class_volume_ = value; + } + inline void MessageOfTricker::set_class_volume(double value) + { + _internal_set_class_volume(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.class_volume) + } + + // repeated .protobuf.TrickerBuffType buff = 17; + inline int MessageOfTricker::_internal_buff_size() const + { + return _impl_.buff_.size(); + } + inline int MessageOfTricker::buff_size() const + { + return _internal_buff_size(); + } + inline void MessageOfTricker::clear_buff() + { + _impl_.buff_.Clear(); + } + inline ::protobuf::TrickerBuffType MessageOfTricker::_internal_buff(int index) const + { + return static_cast<::protobuf::TrickerBuffType>(_impl_.buff_.Get(index)); + } + inline ::protobuf::TrickerBuffType MessageOfTricker::buff(int index) const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.buff) + return _internal_buff(index); + } + inline void MessageOfTricker::set_buff(int index, ::protobuf::TrickerBuffType value) + { + _impl_.buff_.Set(index, value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.buff) + } + inline void MessageOfTricker::_internal_add_buff(::protobuf::TrickerBuffType value) + { + _impl_.buff_.Add(value); + } + inline void MessageOfTricker::add_buff(::protobuf::TrickerBuffType value) + { + _internal_add_buff(value); + // @@protoc_insertion_point(field_add:protobuf.MessageOfTricker.buff) + } + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& + MessageOfTricker::buff() const + { + // @@protoc_insertion_point(field_list:protobuf.MessageOfTricker.buff) + return _impl_.buff_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfTricker::_internal_mutable_buff() + { + return &_impl_.buff_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfTricker::mutable_buff() + { + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfTricker.buff) + return _internal_mutable_buff(); + } + + // ------------------------------------------------------------------- + + // MessageOfBullet + + // .protobuf.BulletType type = 1; + inline void MessageOfBullet::clear_type() + { + _impl_.type_ = 0; + } + inline ::protobuf::BulletType MessageOfBullet::_internal_type() const + { + return static_cast<::protobuf::BulletType>(_impl_.type_); + } + inline ::protobuf::BulletType MessageOfBullet::type() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.type) + return _internal_type(); + } + inline void MessageOfBullet::_internal_set_type(::protobuf::BulletType value) + { + _impl_.type_ = value; + } + inline void MessageOfBullet::set_type(::protobuf::BulletType value) + { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.type) + } + + // int32 x = 2; + inline void MessageOfBullet::clear_x() + { + _impl_.x_ = 0; + } + inline int32_t MessageOfBullet::_internal_x() const + { + return _impl_.x_; + } + inline int32_t MessageOfBullet::x() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.x) + return _internal_x(); + } + inline void MessageOfBullet::_internal_set_x(int32_t value) + { + _impl_.x_ = value; + } + inline void MessageOfBullet::set_x(int32_t value) + { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.x) + } + + // int32 y = 3; + inline void MessageOfBullet::clear_y() + { + _impl_.y_ = 0; + } + inline int32_t MessageOfBullet::_internal_y() const + { + return _impl_.y_; + } + inline int32_t MessageOfBullet::y() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.y) + return _internal_y(); + } + inline void MessageOfBullet::_internal_set_y(int32_t value) + { + _impl_.y_ = value; + } + inline void MessageOfBullet::set_y(int32_t value) + { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.y) + } + + // double facing_direction = 4; + inline void MessageOfBullet::clear_facing_direction() + { + _impl_.facing_direction_ = 0; + } + inline double MessageOfBullet::_internal_facing_direction() const + { + return _impl_.facing_direction_; + } + inline double MessageOfBullet::facing_direction() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.facing_direction) + return _internal_facing_direction(); + } + inline void MessageOfBullet::_internal_set_facing_direction(double value) + { + _impl_.facing_direction_ = value; + } + inline void MessageOfBullet::set_facing_direction(double value) + { + _internal_set_facing_direction(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.facing_direction) + } + + // int64 guid = 5; + inline void MessageOfBullet::clear_guid() + { + _impl_.guid_ = int64_t{0}; + } + inline int64_t MessageOfBullet::_internal_guid() const + { + return _impl_.guid_; + } + inline int64_t MessageOfBullet::guid() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.guid) + return _internal_guid(); + } + inline void MessageOfBullet::_internal_set_guid(int64_t value) + { + _impl_.guid_ = value; + } + inline void MessageOfBullet::set_guid(int64_t value) + { + _internal_set_guid(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.guid) + } + + // .protobuf.PlayerType team = 6; + inline void MessageOfBullet::clear_team() + { + _impl_.team_ = 0; + } + inline ::protobuf::PlayerType MessageOfBullet::_internal_team() const { - return _impl_.time_until_skill_available_; + return static_cast<::protobuf::PlayerType>(_impl_.team_); } - inline double MessageOfStudent::time_until_skill_available() const + inline ::protobuf::PlayerType MessageOfBullet::team() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.time_until_skill_available) - return _internal_time_until_skill_available(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.team) + return _internal_team(); } - inline void MessageOfStudent::_internal_set_time_until_skill_available(double value) + inline void MessageOfBullet::_internal_set_team(::protobuf::PlayerType value) { - _impl_.time_until_skill_available_ = value; + _impl_.team_ = value; } - inline void MessageOfStudent::set_time_until_skill_available(double value) + inline void MessageOfBullet::set_team(::protobuf::PlayerType value) { - _internal_set_time_until_skill_available(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.time_until_skill_available) + _internal_set_team(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.team) } // .protobuf.PlaceType place = 7; - inline void MessageOfStudent::clear_place() + inline void MessageOfBullet::clear_place() { _impl_.place_ = 0; } - inline ::protobuf::PlaceType MessageOfStudent::_internal_place() const + inline ::protobuf::PlaceType MessageOfBullet::_internal_place() const { return static_cast<::protobuf::PlaceType>(_impl_.place_); } - inline ::protobuf::PlaceType MessageOfStudent::place() const + inline ::protobuf::PlaceType MessageOfBullet::place() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.place) + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.place) return _internal_place(); } - inline void MessageOfStudent::_internal_set_place(::protobuf::PlaceType value) + inline void MessageOfBullet::_internal_set_place(::protobuf::PlaceType value) { _impl_.place_ = value; } - inline void MessageOfStudent::set_place(::protobuf::PlaceType value) + inline void MessageOfBullet::set_place(::protobuf::PlaceType value) { _internal_set_place(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.place) + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.place) } - // .protobuf.PropType prop = 8; - inline void MessageOfStudent::clear_prop() + // double bomb_range = 8; + inline void MessageOfBullet::clear_bomb_range() { - _impl_.prop_ = 0; + _impl_.bomb_range_ = 0; } - inline ::protobuf::PropType MessageOfStudent::_internal_prop() const + inline double MessageOfBullet::_internal_bomb_range() const { - return static_cast<::protobuf::PropType>(_impl_.prop_); + return _impl_.bomb_range_; } - inline ::protobuf::PropType MessageOfStudent::prop() const + inline double MessageOfBullet::bomb_range() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.prop) - return _internal_prop(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.bomb_range) + return _internal_bomb_range(); } - inline void MessageOfStudent::_internal_set_prop(::protobuf::PropType value) + inline void MessageOfBullet::_internal_set_bomb_range(double value) { - _impl_.prop_ = value; + _impl_.bomb_range_ = value; } - inline void MessageOfStudent::set_prop(::protobuf::PropType value) + inline void MessageOfBullet::set_bomb_range(double value) { - _internal_set_prop(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.prop) + _internal_set_bomb_range(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.bomb_range) } - // .protobuf.StudentType student_type = 9; - inline void MessageOfStudent::clear_student_type() + // ------------------------------------------------------------------- + + // MessageOfBombedBullet + + // .protobuf.BulletType type = 1; + inline void MessageOfBombedBullet::clear_type() { - _impl_.student_type_ = 0; + _impl_.type_ = 0; } - inline ::protobuf::StudentType MessageOfStudent::_internal_student_type() const + inline ::protobuf::BulletType MessageOfBombedBullet::_internal_type() const { - return static_cast<::protobuf::StudentType>(_impl_.student_type_); + return static_cast<::protobuf::BulletType>(_impl_.type_); } - inline ::protobuf::StudentType MessageOfStudent::student_type() const + inline ::protobuf::BulletType MessageOfBombedBullet::type() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.student_type) - return _internal_student_type(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.type) + return _internal_type(); } - inline void MessageOfStudent::_internal_set_student_type(::protobuf::StudentType value) + inline void MessageOfBombedBullet::_internal_set_type(::protobuf::BulletType value) { - _impl_.student_type_ = value; + _impl_.type_ = value; } - inline void MessageOfStudent::set_student_type(::protobuf::StudentType value) + inline void MessageOfBombedBullet::set_type(::protobuf::BulletType value) { - _internal_set_student_type(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.student_type) + _internal_set_type(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.type) } - // int64 guid = 10; - inline void MessageOfStudent::clear_guid() + // int32 x = 2; + inline void MessageOfBombedBullet::clear_x() { - _impl_.guid_ = int64_t{0}; + _impl_.x_ = 0; } - inline int64_t MessageOfStudent::_internal_guid() const + inline int32_t MessageOfBombedBullet::_internal_x() const { - return _impl_.guid_; + return _impl_.x_; } - inline int64_t MessageOfStudent::guid() const + inline int32_t MessageOfBombedBullet::x() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.guid) - return _internal_guid(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.x) + return _internal_x(); } - inline void MessageOfStudent::_internal_set_guid(int64_t value) + inline void MessageOfBombedBullet::_internal_set_x(int32_t value) { - _impl_.guid_ = value; + _impl_.x_ = value; } - inline void MessageOfStudent::set_guid(int64_t value) + inline void MessageOfBombedBullet::set_x(int32_t value) { - _internal_set_guid(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.guid) + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.x) } - // .protobuf.StudentState state = 11; - inline void MessageOfStudent::clear_state() + // int32 y = 3; + inline void MessageOfBombedBullet::clear_y() { - _impl_.state_ = 0; + _impl_.y_ = 0; } - inline ::protobuf::StudentState MessageOfStudent::_internal_state() const + inline int32_t MessageOfBombedBullet::_internal_y() const { - return static_cast<::protobuf::StudentState>(_impl_.state_); + return _impl_.y_; } - inline ::protobuf::StudentState MessageOfStudent::state() const + inline int32_t MessageOfBombedBullet::y() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.state) - return _internal_state(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.y) + return _internal_y(); } - inline void MessageOfStudent::_internal_set_state(::protobuf::StudentState value) + inline void MessageOfBombedBullet::_internal_set_y(int32_t value) { - _impl_.state_ = value; + _impl_.y_ = value; } - inline void MessageOfStudent::set_state(::protobuf::StudentState value) + inline void MessageOfBombedBullet::set_y(int32_t value) { - _internal_set_state(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.state) + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.y) } - // double fail_time = 12; - inline void MessageOfStudent::clear_fail_time() + // double facing_direction = 4; + inline void MessageOfBombedBullet::clear_facing_direction() { - _impl_.fail_time_ = 0; + _impl_.facing_direction_ = 0; } - inline double MessageOfStudent::_internal_fail_time() const + inline double MessageOfBombedBullet::_internal_facing_direction() const { - return _impl_.fail_time_; + return _impl_.facing_direction_; } - inline double MessageOfStudent::fail_time() const + inline double MessageOfBombedBullet::facing_direction() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.fail_time) - return _internal_fail_time(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.facing_direction) + return _internal_facing_direction(); } - inline void MessageOfStudent::_internal_set_fail_time(double value) + inline void MessageOfBombedBullet::_internal_set_facing_direction(double value) { - _impl_.fail_time_ = value; + _impl_.facing_direction_ = value; } - inline void MessageOfStudent::set_fail_time(double value) + inline void MessageOfBombedBullet::set_facing_direction(double value) { - _internal_set_fail_time(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.fail_time) + _internal_set_facing_direction(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.facing_direction) } - // double emo_time = 14; - inline void MessageOfStudent::clear_emo_time() + // int64 mapping_id = 5; + inline void MessageOfBombedBullet::clear_mapping_id() { - _impl_.emo_time_ = 0; + _impl_.mapping_id_ = int64_t{0}; } - inline double MessageOfStudent::_internal_emo_time() const + inline int64_t MessageOfBombedBullet::_internal_mapping_id() const { - return _impl_.emo_time_; + return _impl_.mapping_id_; } - inline double MessageOfStudent::emo_time() const + inline int64_t MessageOfBombedBullet::mapping_id() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.emo_time) - return _internal_emo_time(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.mapping_id) + return _internal_mapping_id(); } - inline void MessageOfStudent::_internal_set_emo_time(double value) + inline void MessageOfBombedBullet::_internal_set_mapping_id(int64_t value) { - _impl_.emo_time_ = value; + _impl_.mapping_id_ = value; } - inline void MessageOfStudent::set_emo_time(double value) + inline void MessageOfBombedBullet::set_mapping_id(int64_t value) { - _internal_set_emo_time(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.emo_time) + _internal_set_mapping_id(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.mapping_id) } - // int64 player_id = 15; - inline void MessageOfStudent::clear_player_id() + // double bomb_range = 6; + inline void MessageOfBombedBullet::clear_bomb_range() { - _impl_.player_id_ = int64_t{0}; + _impl_.bomb_range_ = 0; } - inline int64_t MessageOfStudent::_internal_player_id() const + inline double MessageOfBombedBullet::_internal_bomb_range() const { - return _impl_.player_id_; + return _impl_.bomb_range_; } - inline int64_t MessageOfStudent::player_id() const + inline double MessageOfBombedBullet::bomb_range() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.player_id) - return _internal_player_id(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.bomb_range) + return _internal_bomb_range(); } - inline void MessageOfStudent::_internal_set_player_id(int64_t value) + inline void MessageOfBombedBullet::_internal_set_bomb_range(double value) { - _impl_.player_id_ = value; + _impl_.bomb_range_ = value; } - inline void MessageOfStudent::set_player_id(int64_t value) + inline void MessageOfBombedBullet::set_bomb_range(double value) { - _internal_set_player_id(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.player_id) + _internal_set_bomb_range(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.bomb_range) } - // int32 view_range = 16; - inline void MessageOfStudent::clear_view_range() + // ------------------------------------------------------------------- + + // MessageOfProp + + // .protobuf.PropType type = 1; + inline void MessageOfProp::clear_type() { - _impl_.view_range_ = 0; + _impl_.type_ = 0; } - inline int32_t MessageOfStudent::_internal_view_range() const + inline ::protobuf::PropType MessageOfProp::_internal_type() const { - return _impl_.view_range_; + return static_cast<::protobuf::PropType>(_impl_.type_); } - inline int32_t MessageOfStudent::view_range() const + inline ::protobuf::PropType MessageOfProp::type() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.view_range) - return _internal_view_range(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.type) + return _internal_type(); } - inline void MessageOfStudent::_internal_set_view_range(int32_t value) + inline void MessageOfProp::_internal_set_type(::protobuf::PropType value) { - _impl_.view_range_ = value; + _impl_.type_ = value; } - inline void MessageOfStudent::set_view_range(int32_t value) + inline void MessageOfProp::set_type(::protobuf::PropType value) { - _internal_set_view_range(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.view_range) + _internal_set_type(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.type) } - // int32 radius = 17; - inline void MessageOfStudent::clear_radius() + // int32 x = 2; + inline void MessageOfProp::clear_x() + { + _impl_.x_ = 0; + } + inline int32_t MessageOfProp::_internal_x() const + { + return _impl_.x_; + } + inline int32_t MessageOfProp::x() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.x) + return _internal_x(); + } + inline void MessageOfProp::_internal_set_x(int32_t value) + { + _impl_.x_ = value; + } + inline void MessageOfProp::set_x(int32_t value) + { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.x) + } + + // int32 y = 3; + inline void MessageOfProp::clear_y() { - _impl_.radius_ = 0; + _impl_.y_ = 0; } - inline int32_t MessageOfStudent::_internal_radius() const + inline int32_t MessageOfProp::_internal_y() const { - return _impl_.radius_; + return _impl_.y_; } - inline int32_t MessageOfStudent::radius() const + inline int32_t MessageOfProp::y() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.radius) - return _internal_radius(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.y) + return _internal_y(); } - inline void MessageOfStudent::_internal_set_radius(int32_t value) + inline void MessageOfProp::_internal_set_y(int32_t value) { - _impl_.radius_ = value; + _impl_.y_ = value; } - inline void MessageOfStudent::set_radius(int32_t value) + inline void MessageOfProp::set_y(int32_t value) { - _internal_set_radius(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.radius) + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.y) } - // int32 damage = 18; - inline void MessageOfStudent::clear_damage() + // double facing_direction = 4; + inline void MessageOfProp::clear_facing_direction() { - _impl_.damage_ = 0; + _impl_.facing_direction_ = 0; } - inline int32_t MessageOfStudent::_internal_damage() const + inline double MessageOfProp::_internal_facing_direction() const { - return _impl_.damage_; + return _impl_.facing_direction_; } - inline int32_t MessageOfStudent::damage() const + inline double MessageOfProp::facing_direction() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.damage) - return _internal_damage(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.facing_direction) + return _internal_facing_direction(); } - inline void MessageOfStudent::_internal_set_damage(int32_t value) + inline void MessageOfProp::_internal_set_facing_direction(double value) { - _impl_.damage_ = value; + _impl_.facing_direction_ = value; } - inline void MessageOfStudent::set_damage(int32_t value) + inline void MessageOfProp::set_facing_direction(double value) { - _internal_set_damage(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.damage) + _internal_set_facing_direction(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.facing_direction) } - // repeated .protobuf.StudentBuffType buff = 19; - inline int MessageOfStudent::_internal_buff_size() const - { - return _impl_.buff_.size(); - } - inline int MessageOfStudent::buff_size() const + // int64 guid = 5; + inline void MessageOfProp::clear_guid() { - return _internal_buff_size(); + _impl_.guid_ = int64_t{0}; } - inline void MessageOfStudent::clear_buff() + inline int64_t MessageOfProp::_internal_guid() const { - _impl_.buff_.Clear(); + return _impl_.guid_; } - inline ::protobuf::StudentBuffType MessageOfStudent::_internal_buff(int index) const + inline int64_t MessageOfProp::guid() const { - return static_cast<::protobuf::StudentBuffType>(_impl_.buff_.Get(index)); + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.guid) + return _internal_guid(); } - inline ::protobuf::StudentBuffType MessageOfStudent::buff(int index) const + inline void MessageOfProp::_internal_set_guid(int64_t value) { - // @@protoc_insertion_point(field_get:protobuf.MessageOfStudent.buff) - return _internal_buff(index); + _impl_.guid_ = value; } - inline void MessageOfStudent::set_buff(int index, ::protobuf::StudentBuffType value) + inline void MessageOfProp::set_guid(int64_t value) { - _impl_.buff_.Set(index, value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfStudent.buff) + _internal_set_guid(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.guid) } - inline void MessageOfStudent::_internal_add_buff(::protobuf::StudentBuffType value) + + // .protobuf.PlaceType place = 6; + inline void MessageOfProp::clear_place() { - _impl_.buff_.Add(value); + _impl_.place_ = 0; } - inline void MessageOfStudent::add_buff(::protobuf::StudentBuffType value) + inline ::protobuf::PlaceType MessageOfProp::_internal_place() const { - _internal_add_buff(value); - // @@protoc_insertion_point(field_add:protobuf.MessageOfStudent.buff) + return static_cast<::protobuf::PlaceType>(_impl_.place_); } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& - MessageOfStudent::buff() const + inline ::protobuf::PlaceType MessageOfProp::place() const { - // @@protoc_insertion_point(field_list:protobuf.MessageOfStudent.buff) - return _impl_.buff_; + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.place) + return _internal_place(); } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* - MessageOfStudent::_internal_mutable_buff() + inline void MessageOfProp::_internal_set_place(::protobuf::PlaceType value) { - return &_impl_.buff_; + _impl_.place_ = value; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* - MessageOfStudent::mutable_buff() + inline void MessageOfProp::set_place(::protobuf::PlaceType value) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfStudent.buff) - return _internal_mutable_buff(); + _internal_set_place(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.place) } - // ------------------------------------------------------------------- - - // MessageOfTricker - - // int32 x = 1; - inline void MessageOfTricker::clear_x() + // int32 size = 7; + inline void MessageOfProp::clear_size() { - _impl_.x_ = 0; + _impl_.size_ = 0; } - inline int32_t MessageOfTricker::_internal_x() const + inline int32_t MessageOfProp::_internal_size() const { - return _impl_.x_; + return _impl_.size_; } - inline int32_t MessageOfTricker::x() const + inline int32_t MessageOfProp::size() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.x) - return _internal_x(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.size) + return _internal_size(); } - inline void MessageOfTricker::_internal_set_x(int32_t value) + inline void MessageOfProp::_internal_set_size(int32_t value) { - _impl_.x_ = value; + _impl_.size_ = value; } - inline void MessageOfTricker::set_x(int32_t value) + inline void MessageOfProp::set_size(int32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.x) + _internal_set_size(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.size) } - // int32 y = 2; - inline void MessageOfTricker::clear_y() + // bool is_moving = 8; + inline void MessageOfProp::clear_is_moving() { - _impl_.y_ = 0; + _impl_.is_moving_ = false; } - inline int32_t MessageOfTricker::_internal_y() const + inline bool MessageOfProp::_internal_is_moving() const { - return _impl_.y_; + return _impl_.is_moving_; } - inline int32_t MessageOfTricker::y() const + inline bool MessageOfProp::is_moving() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.y) - return _internal_y(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.is_moving) + return _internal_is_moving(); } - inline void MessageOfTricker::_internal_set_y(int32_t value) + inline void MessageOfProp::_internal_set_is_moving(bool value) { - _impl_.y_ = value; + _impl_.is_moving_ = value; } - inline void MessageOfTricker::set_y(int32_t value) + inline void MessageOfProp::set_is_moving(bool value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.y) + _internal_set_is_moving(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.is_moving) } - // int32 speed = 3; - inline void MessageOfTricker::clear_speed() + // ------------------------------------------------------------------- + + // MessageOfPickedProp + + // .protobuf.PropType type = 1; + inline void MessageOfPickedProp::clear_type() { - _impl_.speed_ = 0; + _impl_.type_ = 0; } - inline int32_t MessageOfTricker::_internal_speed() const + inline ::protobuf::PropType MessageOfPickedProp::_internal_type() const { - return _impl_.speed_; + return static_cast<::protobuf::PropType>(_impl_.type_); } - inline int32_t MessageOfTricker::speed() const + inline ::protobuf::PropType MessageOfPickedProp::type() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.speed) - return _internal_speed(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.type) + return _internal_type(); } - inline void MessageOfTricker::_internal_set_speed(int32_t value) + inline void MessageOfPickedProp::_internal_set_type(::protobuf::PropType value) { - _impl_.speed_ = value; + _impl_.type_ = value; } - inline void MessageOfTricker::set_speed(int32_t value) + inline void MessageOfPickedProp::set_type(::protobuf::PropType value) { - _internal_set_speed(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.speed) + _internal_set_type(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.type) } - // int32 damage = 4; - inline void MessageOfTricker::clear_damage() + // int32 x = 2; + inline void MessageOfPickedProp::clear_x() { - _impl_.damage_ = 0; + _impl_.x_ = 0; } - inline int32_t MessageOfTricker::_internal_damage() const + inline int32_t MessageOfPickedProp::_internal_x() const { - return _impl_.damage_; + return _impl_.x_; } - inline int32_t MessageOfTricker::damage() const + inline int32_t MessageOfPickedProp::x() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.damage) - return _internal_damage(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.x) + return _internal_x(); } - inline void MessageOfTricker::_internal_set_damage(int32_t value) + inline void MessageOfPickedProp::_internal_set_x(int32_t value) { - _impl_.damage_ = value; + _impl_.x_ = value; } - inline void MessageOfTricker::set_damage(int32_t value) + inline void MessageOfPickedProp::set_x(int32_t value) { - _internal_set_damage(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.damage) + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.x) } - // double time_until_skill_available = 5; - inline void MessageOfTricker::clear_time_until_skill_available() + // int32 y = 3; + inline void MessageOfPickedProp::clear_y() { - _impl_.time_until_skill_available_ = 0; + _impl_.y_ = 0; } - inline double MessageOfTricker::_internal_time_until_skill_available() const + inline int32_t MessageOfPickedProp::_internal_y() const { - return _impl_.time_until_skill_available_; + return _impl_.y_; } - inline double MessageOfTricker::time_until_skill_available() const + inline int32_t MessageOfPickedProp::y() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.time_until_skill_available) - return _internal_time_until_skill_available(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.y) + return _internal_y(); } - inline void MessageOfTricker::_internal_set_time_until_skill_available(double value) + inline void MessageOfPickedProp::_internal_set_y(int32_t value) { - _impl_.time_until_skill_available_ = value; + _impl_.y_ = value; } - inline void MessageOfTricker::set_time_until_skill_available(double value) + inline void MessageOfPickedProp::set_y(int32_t value) { - _internal_set_time_until_skill_available(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.time_until_skill_available) + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.y) } - // .protobuf.PlaceType place = 6; - inline void MessageOfTricker::clear_place() + // double facing_direction = 4; + inline void MessageOfPickedProp::clear_facing_direction() { - _impl_.place_ = 0; + _impl_.facing_direction_ = 0; } - inline ::protobuf::PlaceType MessageOfTricker::_internal_place() const + inline double MessageOfPickedProp::_internal_facing_direction() const { - return static_cast<::protobuf::PlaceType>(_impl_.place_); + return _impl_.facing_direction_; } - inline ::protobuf::PlaceType MessageOfTricker::place() const + inline double MessageOfPickedProp::facing_direction() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.place) - return _internal_place(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.facing_direction) + return _internal_facing_direction(); } - inline void MessageOfTricker::_internal_set_place(::protobuf::PlaceType value) + inline void MessageOfPickedProp::_internal_set_facing_direction(double value) { - _impl_.place_ = value; + _impl_.facing_direction_ = value; } - inline void MessageOfTricker::set_place(::protobuf::PlaceType value) + inline void MessageOfPickedProp::set_facing_direction(double value) { - _internal_set_place(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.place) + _internal_set_facing_direction(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.facing_direction) } - // .protobuf.PropType prop = 7; - inline void MessageOfTricker::clear_prop() + // int64 mapping_id = 5; + inline void MessageOfPickedProp::clear_mapping_id() { - _impl_.prop_ = 0; + _impl_.mapping_id_ = int64_t{0}; } - inline ::protobuf::PropType MessageOfTricker::_internal_prop() const + inline int64_t MessageOfPickedProp::_internal_mapping_id() const { - return static_cast<::protobuf::PropType>(_impl_.prop_); + return _impl_.mapping_id_; } - inline ::protobuf::PropType MessageOfTricker::prop() const + inline int64_t MessageOfPickedProp::mapping_id() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.prop) - return _internal_prop(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.mapping_id) + return _internal_mapping_id(); } - inline void MessageOfTricker::_internal_set_prop(::protobuf::PropType value) + inline void MessageOfPickedProp::_internal_set_mapping_id(int64_t value) { - _impl_.prop_ = value; + _impl_.mapping_id_ = value; } - inline void MessageOfTricker::set_prop(::protobuf::PropType value) + inline void MessageOfPickedProp::set_mapping_id(int64_t value) { - _internal_set_prop(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.prop) + _internal_set_mapping_id(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.mapping_id) } - // .protobuf.TrickerType tricker_type = 8; - inline void MessageOfTricker::clear_tricker_type() + // ------------------------------------------------------------------- + + // MessageOfClassroom + + // int32 x = 1; + inline void MessageOfClassroom::clear_x() { - _impl_.tricker_type_ = 0; + _impl_.x_ = 0; } - inline ::protobuf::TrickerType MessageOfTricker::_internal_tricker_type() const + inline int32_t MessageOfClassroom::_internal_x() const { - return static_cast<::protobuf::TrickerType>(_impl_.tricker_type_); + return _impl_.x_; } - inline ::protobuf::TrickerType MessageOfTricker::tricker_type() const + inline int32_t MessageOfClassroom::x() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.tricker_type) - return _internal_tricker_type(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfClassroom.x) + return _internal_x(); } - inline void MessageOfTricker::_internal_set_tricker_type(::protobuf::TrickerType value) + inline void MessageOfClassroom::_internal_set_x(int32_t value) { - _impl_.tricker_type_ = value; + _impl_.x_ = value; } - inline void MessageOfTricker::set_tricker_type(::protobuf::TrickerType value) + inline void MessageOfClassroom::set_x(int32_t value) { - _internal_set_tricker_type(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.tricker_type) + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfClassroom.x) } - // int64 guid = 9; - inline void MessageOfTricker::clear_guid() + // int32 y = 2; + inline void MessageOfClassroom::clear_y() { - _impl_.guid_ = int64_t{0}; + _impl_.y_ = 0; } - inline int64_t MessageOfTricker::_internal_guid() const + inline int32_t MessageOfClassroom::_internal_y() const { - return _impl_.guid_; + return _impl_.y_; } - inline int64_t MessageOfTricker::guid() const + inline int32_t MessageOfClassroom::y() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.guid) - return _internal_guid(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfClassroom.y) + return _internal_y(); } - inline void MessageOfTricker::_internal_set_guid(int64_t value) + inline void MessageOfClassroom::_internal_set_y(int32_t value) { - _impl_.guid_ = value; + _impl_.y_ = value; } - inline void MessageOfTricker::set_guid(int64_t value) + inline void MessageOfClassroom::set_y(int32_t value) { - _internal_set_guid(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.guid) + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfClassroom.y) } - // bool movable = 10; - inline void MessageOfTricker::clear_movable() + // int32 progress = 3; + inline void MessageOfClassroom::clear_progress() { - _impl_.movable_ = false; + _impl_.progress_ = 0; } - inline bool MessageOfTricker::_internal_movable() const + inline int32_t MessageOfClassroom::_internal_progress() const { - return _impl_.movable_; + return _impl_.progress_; } - inline bool MessageOfTricker::movable() const + inline int32_t MessageOfClassroom::progress() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.movable) - return _internal_movable(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfClassroom.progress) + return _internal_progress(); } - inline void MessageOfTricker::_internal_set_movable(bool value) + inline void MessageOfClassroom::_internal_set_progress(int32_t value) { - _impl_.movable_ = value; + _impl_.progress_ = value; } - inline void MessageOfTricker::set_movable(bool value) + inline void MessageOfClassroom::set_progress(int32_t value) { - _internal_set_movable(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.movable) + _internal_set_progress(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfClassroom.progress) } - // int64 player_id = 11; - inline void MessageOfTricker::clear_player_id() + // ------------------------------------------------------------------- + + // MessageOfGate + + // int32 x = 1; + inline void MessageOfGate::clear_x() { - _impl_.player_id_ = int64_t{0}; + _impl_.x_ = 0; } - inline int64_t MessageOfTricker::_internal_player_id() const + inline int32_t MessageOfGate::_internal_x() const { - return _impl_.player_id_; + return _impl_.x_; } - inline int64_t MessageOfTricker::player_id() const + inline int32_t MessageOfGate::x() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.player_id) - return _internal_player_id(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfGate.x) + return _internal_x(); } - inline void MessageOfTricker::_internal_set_player_id(int64_t value) + inline void MessageOfGate::_internal_set_x(int32_t value) { - _impl_.player_id_ = value; + _impl_.x_ = value; } - inline void MessageOfTricker::set_player_id(int64_t value) + inline void MessageOfGate::set_x(int32_t value) { - _internal_set_player_id(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.player_id) + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfGate.x) } - // int32 view_range = 12; - inline void MessageOfTricker::clear_view_range() + // int32 y = 2; + inline void MessageOfGate::clear_y() { - _impl_.view_range_ = 0; + _impl_.y_ = 0; } - inline int32_t MessageOfTricker::_internal_view_range() const + inline int32_t MessageOfGate::_internal_y() const { - return _impl_.view_range_; + return _impl_.y_; } - inline int32_t MessageOfTricker::view_range() const + inline int32_t MessageOfGate::y() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.view_range) - return _internal_view_range(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfGate.y) + return _internal_y(); } - inline void MessageOfTricker::_internal_set_view_range(int32_t value) + inline void MessageOfGate::_internal_set_y(int32_t value) { - _impl_.view_range_ = value; + _impl_.y_ = value; } - inline void MessageOfTricker::set_view_range(int32_t value) + inline void MessageOfGate::set_y(int32_t value) { - _internal_set_view_range(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.view_range) + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfGate.y) } - // int32 radius = 13; - inline void MessageOfTricker::clear_radius() + // int32 progress = 3; + inline void MessageOfGate::clear_progress() { - _impl_.radius_ = 0; + _impl_.progress_ = 0; } - inline int32_t MessageOfTricker::_internal_radius() const + inline int32_t MessageOfGate::_internal_progress() const { - return _impl_.radius_; + return _impl_.progress_; } - inline int32_t MessageOfTricker::radius() const + inline int32_t MessageOfGate::progress() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.radius) - return _internal_radius(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfGate.progress) + return _internal_progress(); } - inline void MessageOfTricker::_internal_set_radius(int32_t value) + inline void MessageOfGate::_internal_set_progress(int32_t value) { - _impl_.radius_ = value; + _impl_.progress_ = value; } - inline void MessageOfTricker::set_radius(int32_t value) + inline void MessageOfGate::set_progress(int32_t value) { - _internal_set_radius(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.radius) + _internal_set_progress(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfGate.progress) } - // repeated .protobuf.TrickerBuffType buff = 14; - inline int MessageOfTricker::_internal_buff_size() const - { - return _impl_.buff_.size(); - } - inline int MessageOfTricker::buff_size() const + // ------------------------------------------------------------------- + + // MessageOfDoor + + // int32 x = 1; + inline void MessageOfDoor::clear_x() { - return _internal_buff_size(); + _impl_.x_ = 0; } - inline void MessageOfTricker::clear_buff() + inline int32_t MessageOfDoor::_internal_x() const { - _impl_.buff_.Clear(); + return _impl_.x_; } - inline ::protobuf::TrickerBuffType MessageOfTricker::_internal_buff(int index) const + inline int32_t MessageOfDoor::x() const { - return static_cast<::protobuf::TrickerBuffType>(_impl_.buff_.Get(index)); + // @@protoc_insertion_point(field_get:protobuf.MessageOfDoor.x) + return _internal_x(); } - inline ::protobuf::TrickerBuffType MessageOfTricker::buff(int index) const + inline void MessageOfDoor::_internal_set_x(int32_t value) { - // @@protoc_insertion_point(field_get:protobuf.MessageOfTricker.buff) - return _internal_buff(index); + _impl_.x_ = value; } - inline void MessageOfTricker::set_buff(int index, ::protobuf::TrickerBuffType value) + inline void MessageOfDoor::set_x(int32_t value) { - _impl_.buff_.Set(index, value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfTricker.buff) + _internal_set_x(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfDoor.x) } - inline void MessageOfTricker::_internal_add_buff(::protobuf::TrickerBuffType value) + + // int32 y = 2; + inline void MessageOfDoor::clear_y() { - _impl_.buff_.Add(value); + _impl_.y_ = 0; } - inline void MessageOfTricker::add_buff(::protobuf::TrickerBuffType value) + inline int32_t MessageOfDoor::_internal_y() const { - _internal_add_buff(value); - // @@protoc_insertion_point(field_add:protobuf.MessageOfTricker.buff) + return _impl_.y_; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& - MessageOfTricker::buff() const + inline int32_t MessageOfDoor::y() const { - // @@protoc_insertion_point(field_list:protobuf.MessageOfTricker.buff) - return _impl_.buff_; + // @@protoc_insertion_point(field_get:protobuf.MessageOfDoor.y) + return _internal_y(); } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* - MessageOfTricker::_internal_mutable_buff() + inline void MessageOfDoor::_internal_set_y(int32_t value) { - return &_impl_.buff_; + _impl_.y_ = value; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* - MessageOfTricker::mutable_buff() + inline void MessageOfDoor::set_y(int32_t value) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfTricker.buff) - return _internal_mutable_buff(); + _internal_set_y(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfDoor.y) } - // ------------------------------------------------------------------- - - // MessageOfBullet - - // .protobuf.BulletType type = 1; - inline void MessageOfBullet::clear_type() + // bool is_open = 3; + inline void MessageOfDoor::clear_is_open() { - _impl_.type_ = 0; + _impl_.is_open_ = false; } - inline ::protobuf::BulletType MessageOfBullet::_internal_type() const + inline bool MessageOfDoor::_internal_is_open() const { - return static_cast<::protobuf::BulletType>(_impl_.type_); + return _impl_.is_open_; } - inline ::protobuf::BulletType MessageOfBullet::type() const + inline bool MessageOfDoor::is_open() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.type) - return _internal_type(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfDoor.is_open) + return _internal_is_open(); } - inline void MessageOfBullet::_internal_set_type(::protobuf::BulletType value) + inline void MessageOfDoor::_internal_set_is_open(bool value) { - _impl_.type_ = value; + _impl_.is_open_ = value; } - inline void MessageOfBullet::set_type(::protobuf::BulletType value) + inline void MessageOfDoor::set_is_open(bool value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.type) + _internal_set_is_open(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfDoor.is_open) } - // int32 x = 2; - inline void MessageOfBullet::clear_x() + // ------------------------------------------------------------------- + + // MessageOfChest + + // int32 x = 1; + inline void MessageOfChest::clear_x() { _impl_.x_ = 0; } - inline int32_t MessageOfBullet::_internal_x() const + inline int32_t MessageOfChest::_internal_x() const { return _impl_.x_; } - inline int32_t MessageOfBullet::x() const + inline int32_t MessageOfChest::x() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.x) + // @@protoc_insertion_point(field_get:protobuf.MessageOfChest.x) return _internal_x(); } - inline void MessageOfBullet::_internal_set_x(int32_t value) + inline void MessageOfChest::_internal_set_x(int32_t value) { _impl_.x_ = value; } - inline void MessageOfBullet::set_x(int32_t value) + inline void MessageOfChest::set_x(int32_t value) { _internal_set_x(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.x) + // @@protoc_insertion_point(field_set:protobuf.MessageOfChest.x) } - // int32 y = 3; - inline void MessageOfBullet::clear_y() + // int32 y = 2; + inline void MessageOfChest::clear_y() { _impl_.y_ = 0; } - inline int32_t MessageOfBullet::_internal_y() const + inline int32_t MessageOfChest::_internal_y() const { return _impl_.y_; } - inline int32_t MessageOfBullet::y() const + inline int32_t MessageOfChest::y() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.y) + // @@protoc_insertion_point(field_get:protobuf.MessageOfChest.y) return _internal_y(); } - inline void MessageOfBullet::_internal_set_y(int32_t value) + inline void MessageOfChest::_internal_set_y(int32_t value) { _impl_.y_ = value; } - inline void MessageOfBullet::set_y(int32_t value) + inline void MessageOfChest::set_y(int32_t value) { _internal_set_y(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.y) + // @@protoc_insertion_point(field_set:protobuf.MessageOfChest.y) } - // double facing_direction = 4; - inline void MessageOfBullet::clear_facing_direction() + // int32 progress = 3; + inline void MessageOfChest::clear_progress() { - _impl_.facing_direction_ = 0; + _impl_.progress_ = 0; } - inline double MessageOfBullet::_internal_facing_direction() const + inline int32_t MessageOfChest::_internal_progress() const { - return _impl_.facing_direction_; + return _impl_.progress_; } - inline double MessageOfBullet::facing_direction() const + inline int32_t MessageOfChest::progress() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.facing_direction) - return _internal_facing_direction(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfChest.progress) + return _internal_progress(); + } + inline void MessageOfChest::_internal_set_progress(int32_t value) + { + _impl_.progress_ = value; + } + inline void MessageOfChest::set_progress(int32_t value) + { + _internal_set_progress(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfChest.progress) + } + + // ------------------------------------------------------------------- + + // MessageOfMapObj + + // .protobuf.MessageOfClassroom classroom_message = 1; + inline bool MessageOfMapObj::_internal_has_classroom_message() const + { + return message_of_map_obj_case() == kClassroomMessage; + } + inline bool MessageOfMapObj::has_classroom_message() const + { + return _internal_has_classroom_message(); + } + inline void MessageOfMapObj::set_has_classroom_message() + { + _impl_._oneof_case_[0] = kClassroomMessage; + } + inline void MessageOfMapObj::clear_classroom_message() + { + if (_internal_has_classroom_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.classroom_message_; + } + clear_has_message_of_map_obj(); + } } - inline void MessageOfBullet::_internal_set_facing_direction(double value) + inline ::protobuf::MessageOfClassroom* MessageOfMapObj::release_classroom_message() { - _impl_.facing_direction_ = value; + // @@protoc_insertion_point(field_release:protobuf.MessageOfMapObj.classroom_message) + if (_internal_has_classroom_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfClassroom* temp = _impl_.message_of_map_obj_.classroom_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_map_obj_.classroom_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfBullet::set_facing_direction(double value) + inline const ::protobuf::MessageOfClassroom& MessageOfMapObj::_internal_classroom_message() const { - _internal_set_facing_direction(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.facing_direction) + return _internal_has_classroom_message() ? *_impl_.message_of_map_obj_.classroom_message_ : reinterpret_cast<::protobuf::MessageOfClassroom&>(::protobuf::_MessageOfClassroom_default_instance_); } - - // int64 guid = 5; - inline void MessageOfBullet::clear_guid() + inline const ::protobuf::MessageOfClassroom& MessageOfMapObj::classroom_message() const { - _impl_.guid_ = int64_t{0}; + // @@protoc_insertion_point(field_get:protobuf.MessageOfMapObj.classroom_message) + return _internal_classroom_message(); } - inline int64_t MessageOfBullet::_internal_guid() const + inline ::protobuf::MessageOfClassroom* MessageOfMapObj::unsafe_arena_release_classroom_message() { - return _impl_.guid_; + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfMapObj.classroom_message) + if (_internal_has_classroom_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfClassroom* temp = _impl_.message_of_map_obj_.classroom_message_; + _impl_.message_of_map_obj_.classroom_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline int64_t MessageOfBullet::guid() const + inline void MessageOfMapObj::unsafe_arena_set_allocated_classroom_message(::protobuf::MessageOfClassroom* classroom_message) { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.guid) - return _internal_guid(); + clear_message_of_map_obj(); + if (classroom_message) + { + set_has_classroom_message(); + _impl_.message_of_map_obj_.classroom_message_ = classroom_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfMapObj.classroom_message) } - inline void MessageOfBullet::_internal_set_guid(int64_t value) + inline ::protobuf::MessageOfClassroom* MessageOfMapObj::_internal_mutable_classroom_message() { - _impl_.guid_ = value; + if (!_internal_has_classroom_message()) + { + clear_message_of_map_obj(); + set_has_classroom_message(); + _impl_.message_of_map_obj_.classroom_message_ = CreateMaybeMessage<::protobuf::MessageOfClassroom>(GetArenaForAllocation()); + } + return _impl_.message_of_map_obj_.classroom_message_; } - inline void MessageOfBullet::set_guid(int64_t value) + inline ::protobuf::MessageOfClassroom* MessageOfMapObj::mutable_classroom_message() { - _internal_set_guid(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.guid) + ::protobuf::MessageOfClassroom* _msg = _internal_mutable_classroom_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMapObj.classroom_message) + return _msg; } - // .protobuf.PlayerType team = 6; - inline void MessageOfBullet::clear_team() + // .protobuf.MessageOfDoor door_message = 2; + inline bool MessageOfMapObj::_internal_has_door_message() const { - _impl_.team_ = 0; + return message_of_map_obj_case() == kDoorMessage; } - inline ::protobuf::PlayerType MessageOfBullet::_internal_team() const + inline bool MessageOfMapObj::has_door_message() const { - return static_cast<::protobuf::PlayerType>(_impl_.team_); + return _internal_has_door_message(); } - inline ::protobuf::PlayerType MessageOfBullet::team() const + inline void MessageOfMapObj::set_has_door_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.team) - return _internal_team(); + _impl_._oneof_case_[0] = kDoorMessage; } - inline void MessageOfBullet::_internal_set_team(::protobuf::PlayerType value) + inline void MessageOfMapObj::clear_door_message() { - _impl_.team_ = value; + if (_internal_has_door_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.door_message_; + } + clear_has_message_of_map_obj(); + } } - inline void MessageOfBullet::set_team(::protobuf::PlayerType value) + inline ::protobuf::MessageOfDoor* MessageOfMapObj::release_door_message() { - _internal_set_team(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.team) + // @@protoc_insertion_point(field_release:protobuf.MessageOfMapObj.door_message) + if (_internal_has_door_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfDoor* temp = _impl_.message_of_map_obj_.door_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_map_obj_.door_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - - // .protobuf.PlaceType place = 7; - inline void MessageOfBullet::clear_place() + inline const ::protobuf::MessageOfDoor& MessageOfMapObj::_internal_door_message() const { - _impl_.place_ = 0; + return _internal_has_door_message() ? *_impl_.message_of_map_obj_.door_message_ : reinterpret_cast<::protobuf::MessageOfDoor&>(::protobuf::_MessageOfDoor_default_instance_); } - inline ::protobuf::PlaceType MessageOfBullet::_internal_place() const + inline const ::protobuf::MessageOfDoor& MessageOfMapObj::door_message() const { - return static_cast<::protobuf::PlaceType>(_impl_.place_); + // @@protoc_insertion_point(field_get:protobuf.MessageOfMapObj.door_message) + return _internal_door_message(); } - inline ::protobuf::PlaceType MessageOfBullet::place() const + inline ::protobuf::MessageOfDoor* MessageOfMapObj::unsafe_arena_release_door_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.place) - return _internal_place(); + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfMapObj.door_message) + if (_internal_has_door_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfDoor* temp = _impl_.message_of_map_obj_.door_message_; + _impl_.message_of_map_obj_.door_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfBullet::_internal_set_place(::protobuf::PlaceType value) + inline void MessageOfMapObj::unsafe_arena_set_allocated_door_message(::protobuf::MessageOfDoor* door_message) { - _impl_.place_ = value; + clear_message_of_map_obj(); + if (door_message) + { + set_has_door_message(); + _impl_.message_of_map_obj_.door_message_ = door_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfMapObj.door_message) } - inline void MessageOfBullet::set_place(::protobuf::PlaceType value) + inline ::protobuf::MessageOfDoor* MessageOfMapObj::_internal_mutable_door_message() { - _internal_set_place(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.place) + if (!_internal_has_door_message()) + { + clear_message_of_map_obj(); + set_has_door_message(); + _impl_.message_of_map_obj_.door_message_ = CreateMaybeMessage<::protobuf::MessageOfDoor>(GetArenaForAllocation()); + } + return _impl_.message_of_map_obj_.door_message_; + } + inline ::protobuf::MessageOfDoor* MessageOfMapObj::mutable_door_message() + { + ::protobuf::MessageOfDoor* _msg = _internal_mutable_door_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMapObj.door_message) + return _msg; } - // double bomb_range = 8; - inline void MessageOfBullet::clear_bomb_range() + // .protobuf.MessageOfGate gate_message = 3; + inline bool MessageOfMapObj::_internal_has_gate_message() const { - _impl_.bomb_range_ = 0; + return message_of_map_obj_case() == kGateMessage; } - inline double MessageOfBullet::_internal_bomb_range() const + inline bool MessageOfMapObj::has_gate_message() const { - return _impl_.bomb_range_; + return _internal_has_gate_message(); } - inline double MessageOfBullet::bomb_range() const + inline void MessageOfMapObj::set_has_gate_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBullet.bomb_range) - return _internal_bomb_range(); + _impl_._oneof_case_[0] = kGateMessage; } - inline void MessageOfBullet::_internal_set_bomb_range(double value) + inline void MessageOfMapObj::clear_gate_message() { - _impl_.bomb_range_ = value; + if (_internal_has_gate_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.gate_message_; + } + clear_has_message_of_map_obj(); + } } - inline void MessageOfBullet::set_bomb_range(double value) + inline ::protobuf::MessageOfGate* MessageOfMapObj::release_gate_message() { - _internal_set_bomb_range(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBullet.bomb_range) + // @@protoc_insertion_point(field_release:protobuf.MessageOfMapObj.gate_message) + if (_internal_has_gate_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfGate* temp = _impl_.message_of_map_obj_.gate_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_map_obj_.gate_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - - // ------------------------------------------------------------------- - - // MessageOfBombedBullet - - // .protobuf.BulletType type = 1; - inline void MessageOfBombedBullet::clear_type() + inline const ::protobuf::MessageOfGate& MessageOfMapObj::_internal_gate_message() const { - _impl_.type_ = 0; + return _internal_has_gate_message() ? *_impl_.message_of_map_obj_.gate_message_ : reinterpret_cast<::protobuf::MessageOfGate&>(::protobuf::_MessageOfGate_default_instance_); } - inline ::protobuf::BulletType MessageOfBombedBullet::_internal_type() const + inline const ::protobuf::MessageOfGate& MessageOfMapObj::gate_message() const { - return static_cast<::protobuf::BulletType>(_impl_.type_); + // @@protoc_insertion_point(field_get:protobuf.MessageOfMapObj.gate_message) + return _internal_gate_message(); } - inline ::protobuf::BulletType MessageOfBombedBullet::type() const + inline ::protobuf::MessageOfGate* MessageOfMapObj::unsafe_arena_release_gate_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.type) - return _internal_type(); + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfMapObj.gate_message) + if (_internal_has_gate_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfGate* temp = _impl_.message_of_map_obj_.gate_message_; + _impl_.message_of_map_obj_.gate_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfBombedBullet::_internal_set_type(::protobuf::BulletType value) + inline void MessageOfMapObj::unsafe_arena_set_allocated_gate_message(::protobuf::MessageOfGate* gate_message) { - _impl_.type_ = value; + clear_message_of_map_obj(); + if (gate_message) + { + set_has_gate_message(); + _impl_.message_of_map_obj_.gate_message_ = gate_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfMapObj.gate_message) } - inline void MessageOfBombedBullet::set_type(::protobuf::BulletType value) + inline ::protobuf::MessageOfGate* MessageOfMapObj::_internal_mutable_gate_message() { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.type) + if (!_internal_has_gate_message()) + { + clear_message_of_map_obj(); + set_has_gate_message(); + _impl_.message_of_map_obj_.gate_message_ = CreateMaybeMessage<::protobuf::MessageOfGate>(GetArenaForAllocation()); + } + return _impl_.message_of_map_obj_.gate_message_; } - - // int32 x = 2; - inline void MessageOfBombedBullet::clear_x() + inline ::protobuf::MessageOfGate* MessageOfMapObj::mutable_gate_message() { - _impl_.x_ = 0; + ::protobuf::MessageOfGate* _msg = _internal_mutable_gate_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMapObj.gate_message) + return _msg; } - inline int32_t MessageOfBombedBullet::_internal_x() const + + // .protobuf.MessageOfChest chest_message = 4; + inline bool MessageOfMapObj::_internal_has_chest_message() const { - return _impl_.x_; + return message_of_map_obj_case() == kChestMessage; } - inline int32_t MessageOfBombedBullet::x() const + inline bool MessageOfMapObj::has_chest_message() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.x) - return _internal_x(); + return _internal_has_chest_message(); } - inline void MessageOfBombedBullet::_internal_set_x(int32_t value) + inline void MessageOfMapObj::set_has_chest_message() { - _impl_.x_ = value; + _impl_._oneof_case_[0] = kChestMessage; } - inline void MessageOfBombedBullet::set_x(int32_t value) + inline void MessageOfMapObj::clear_chest_message() { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.x) + if (_internal_has_chest_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_map_obj_.chest_message_; + } + clear_has_message_of_map_obj(); + } } - - // int32 y = 3; - inline void MessageOfBombedBullet::clear_y() + inline ::protobuf::MessageOfChest* MessageOfMapObj::release_chest_message() { - _impl_.y_ = 0; + // @@protoc_insertion_point(field_release:protobuf.MessageOfMapObj.chest_message) + if (_internal_has_chest_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfChest* temp = _impl_.message_of_map_obj_.chest_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_map_obj_.chest_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline int32_t MessageOfBombedBullet::_internal_y() const + inline const ::protobuf::MessageOfChest& MessageOfMapObj::_internal_chest_message() const { - return _impl_.y_; + return _internal_has_chest_message() ? *_impl_.message_of_map_obj_.chest_message_ : reinterpret_cast<::protobuf::MessageOfChest&>(::protobuf::_MessageOfChest_default_instance_); } - inline int32_t MessageOfBombedBullet::y() const + inline const ::protobuf::MessageOfChest& MessageOfMapObj::chest_message() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.y) - return _internal_y(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfMapObj.chest_message) + return _internal_chest_message(); } - inline void MessageOfBombedBullet::_internal_set_y(int32_t value) + inline ::protobuf::MessageOfChest* MessageOfMapObj::unsafe_arena_release_chest_message() { - _impl_.y_ = value; + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfMapObj.chest_message) + if (_internal_has_chest_message()) + { + clear_has_message_of_map_obj(); + ::protobuf::MessageOfChest* temp = _impl_.message_of_map_obj_.chest_message_; + _impl_.message_of_map_obj_.chest_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfBombedBullet::set_y(int32_t value) + inline void MessageOfMapObj::unsafe_arena_set_allocated_chest_message(::protobuf::MessageOfChest* chest_message) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.y) + clear_message_of_map_obj(); + if (chest_message) + { + set_has_chest_message(); + _impl_.message_of_map_obj_.chest_message_ = chest_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfMapObj.chest_message) } - - // double facing_direction = 4; - inline void MessageOfBombedBullet::clear_facing_direction() + inline ::protobuf::MessageOfChest* MessageOfMapObj::_internal_mutable_chest_message() { - _impl_.facing_direction_ = 0; + if (!_internal_has_chest_message()) + { + clear_message_of_map_obj(); + set_has_chest_message(); + _impl_.message_of_map_obj_.chest_message_ = CreateMaybeMessage<::protobuf::MessageOfChest>(GetArenaForAllocation()); + } + return _impl_.message_of_map_obj_.chest_message_; } - inline double MessageOfBombedBullet::_internal_facing_direction() const + inline ::protobuf::MessageOfChest* MessageOfMapObj::mutable_chest_message() { - return _impl_.facing_direction_; + ::protobuf::MessageOfChest* _msg = _internal_mutable_chest_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMapObj.chest_message) + return _msg; } - inline double MessageOfBombedBullet::facing_direction() const + + inline bool MessageOfMapObj::has_message_of_map_obj() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.facing_direction) - return _internal_facing_direction(); + return message_of_map_obj_case() != MESSAGE_OF_MAP_OBJ_NOT_SET; } - inline void MessageOfBombedBullet::_internal_set_facing_direction(double value) + inline void MessageOfMapObj::clear_has_message_of_map_obj() { - _impl_.facing_direction_ = value; + _impl_._oneof_case_[0] = MESSAGE_OF_MAP_OBJ_NOT_SET; } - inline void MessageOfBombedBullet::set_facing_direction(double value) + inline MessageOfMapObj::MessageOfMapObjCase MessageOfMapObj::message_of_map_obj_case() const { - _internal_set_facing_direction(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.facing_direction) + return MessageOfMapObj::MessageOfMapObjCase(_impl_._oneof_case_[0]); } + // ------------------------------------------------------------------- - // int64 mapping_id = 5; - inline void MessageOfBombedBullet::clear_mapping_id() + // MessageOfMap_Row + + // repeated .protobuf.PlaceType col = 1; + inline int MessageOfMap_Row::_internal_col_size() const { - _impl_.mapping_id_ = int64_t{0}; + return _impl_.col_.size(); } - inline int64_t MessageOfBombedBullet::_internal_mapping_id() const + inline int MessageOfMap_Row::col_size() const { - return _impl_.mapping_id_; + return _internal_col_size(); } - inline int64_t MessageOfBombedBullet::mapping_id() const + inline void MessageOfMap_Row::clear_col() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.mapping_id) - return _internal_mapping_id(); + _impl_.col_.Clear(); } - inline void MessageOfBombedBullet::_internal_set_mapping_id(int64_t value) + inline ::protobuf::PlaceType MessageOfMap_Row::_internal_col(int index) const { - _impl_.mapping_id_ = value; + return static_cast<::protobuf::PlaceType>(_impl_.col_.Get(index)); } - inline void MessageOfBombedBullet::set_mapping_id(int64_t value) + inline ::protobuf::PlaceType MessageOfMap_Row::col(int index) const { - _internal_set_mapping_id(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.mapping_id) + // @@protoc_insertion_point(field_get:protobuf.MessageOfMap.Row.col) + return _internal_col(index); } - - // double bomb_range = 6; - inline void MessageOfBombedBullet::clear_bomb_range() + inline void MessageOfMap_Row::set_col(int index, ::protobuf::PlaceType value) { - _impl_.bomb_range_ = 0; + _impl_.col_.Set(index, value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfMap.Row.col) } - inline double MessageOfBombedBullet::_internal_bomb_range() const + inline void MessageOfMap_Row::_internal_add_col(::protobuf::PlaceType value) { - return _impl_.bomb_range_; + _impl_.col_.Add(value); } - inline double MessageOfBombedBullet::bomb_range() const + inline void MessageOfMap_Row::add_col(::protobuf::PlaceType value) { - // @@protoc_insertion_point(field_get:protobuf.MessageOfBombedBullet.bomb_range) - return _internal_bomb_range(); + _internal_add_col(value); + // @@protoc_insertion_point(field_add:protobuf.MessageOfMap.Row.col) } - inline void MessageOfBombedBullet::_internal_set_bomb_range(double value) + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& + MessageOfMap_Row::col() const + { + // @@protoc_insertion_point(field_list:protobuf.MessageOfMap.Row.col) + return _impl_.col_; + } + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfMap_Row::_internal_mutable_col() { - _impl_.bomb_range_ = value; + return &_impl_.col_; } - inline void MessageOfBombedBullet::set_bomb_range(double value) + inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* + MessageOfMap_Row::mutable_col() { - _internal_set_bomb_range(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfBombedBullet.bomb_range) + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfMap.Row.col) + return _internal_mutable_col(); } // ------------------------------------------------------------------- - // MessageOfProp + // MessageOfMap - // .protobuf.PropType type = 1; - inline void MessageOfProp::clear_type() + // repeated .protobuf.MessageOfMap.Row row = 2; + inline int MessageOfMap::_internal_row_size() const { - _impl_.type_ = 0; + return _impl_.row_.size(); } - inline ::protobuf::PropType MessageOfProp::_internal_type() const + inline int MessageOfMap::row_size() const { - return static_cast<::protobuf::PropType>(_impl_.type_); + return _internal_row_size(); } - inline ::protobuf::PropType MessageOfProp::type() const + inline void MessageOfMap::clear_row() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.type) - return _internal_type(); + _impl_.row_.Clear(); } - inline void MessageOfProp::_internal_set_type(::protobuf::PropType value) + inline ::protobuf::MessageOfMap_Row* MessageOfMap::mutable_row(int index) { - _impl_.type_ = value; + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMap.row) + return _impl_.row_.Mutable(index); } - inline void MessageOfProp::set_type(::protobuf::PropType value) + inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>* + MessageOfMap::mutable_row() { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.type) + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfMap.row) + return &_impl_.row_; } - - // int32 x = 2; - inline void MessageOfProp::clear_x() + inline const ::protobuf::MessageOfMap_Row& MessageOfMap::_internal_row(int index) const { - _impl_.x_ = 0; + return _impl_.row_.Get(index); } - inline int32_t MessageOfProp::_internal_x() const + inline const ::protobuf::MessageOfMap_Row& MessageOfMap::row(int index) const { - return _impl_.x_; + // @@protoc_insertion_point(field_get:protobuf.MessageOfMap.row) + return _internal_row(index); } - inline int32_t MessageOfProp::x() const + inline ::protobuf::MessageOfMap_Row* MessageOfMap::_internal_add_row() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.x) - return _internal_x(); + return _impl_.row_.Add(); } - inline void MessageOfProp::_internal_set_x(int32_t value) + inline ::protobuf::MessageOfMap_Row* MessageOfMap::add_row() { - _impl_.x_ = value; + ::protobuf::MessageOfMap_Row* _add = _internal_add_row(); + // @@protoc_insertion_point(field_add:protobuf.MessageOfMap.row) + return _add; } - inline void MessageOfProp::set_x(int32_t value) + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>& + MessageOfMap::row() const { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.x) + // @@protoc_insertion_point(field_list:protobuf.MessageOfMap.row) + return _impl_.row_; } - // int32 y = 3; - inline void MessageOfProp::clear_y() + // repeated .protobuf.MessageOfMapObj map_obj_message = 3; + inline int MessageOfMap::_internal_map_obj_message_size() const { - _impl_.y_ = 0; + return _impl_.map_obj_message_.size(); } - inline int32_t MessageOfProp::_internal_y() const + inline int MessageOfMap::map_obj_message_size() const { - return _impl_.y_; + return _internal_map_obj_message_size(); } - inline int32_t MessageOfProp::y() const + inline void MessageOfMap::clear_map_obj_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.y) - return _internal_y(); + _impl_.map_obj_message_.Clear(); } - inline void MessageOfProp::_internal_set_y(int32_t value) + inline ::protobuf::MessageOfMapObj* MessageOfMap::mutable_map_obj_message(int index) { - _impl_.y_ = value; + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMap.map_obj_message) + return _impl_.map_obj_message_.Mutable(index); } - inline void MessageOfProp::set_y(int32_t value) + inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMapObj>* + MessageOfMap::mutable_map_obj_message() { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.y) + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfMap.map_obj_message) + return &_impl_.map_obj_message_; } - - // double facing_direction = 4; - inline void MessageOfProp::clear_facing_direction() + inline const ::protobuf::MessageOfMapObj& MessageOfMap::_internal_map_obj_message(int index) const { - _impl_.facing_direction_ = 0; + return _impl_.map_obj_message_.Get(index); } - inline double MessageOfProp::_internal_facing_direction() const + inline const ::protobuf::MessageOfMapObj& MessageOfMap::map_obj_message(int index) const { - return _impl_.facing_direction_; + // @@protoc_insertion_point(field_get:protobuf.MessageOfMap.map_obj_message) + return _internal_map_obj_message(index); } - inline double MessageOfProp::facing_direction() const + inline ::protobuf::MessageOfMapObj* MessageOfMap::_internal_add_map_obj_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.facing_direction) - return _internal_facing_direction(); + return _impl_.map_obj_message_.Add(); } - inline void MessageOfProp::_internal_set_facing_direction(double value) + inline ::protobuf::MessageOfMapObj* MessageOfMap::add_map_obj_message() { - _impl_.facing_direction_ = value; + ::protobuf::MessageOfMapObj* _add = _internal_add_map_obj_message(); + // @@protoc_insertion_point(field_add:protobuf.MessageOfMap.map_obj_message) + return _add; } - inline void MessageOfProp::set_facing_direction(double value) + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMapObj>& + MessageOfMap::map_obj_message() const { - _internal_set_facing_direction(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.facing_direction) + // @@protoc_insertion_point(field_list:protobuf.MessageOfMap.map_obj_message) + return _impl_.map_obj_message_; } - // int64 guid = 5; - inline void MessageOfProp::clear_guid() - { - _impl_.guid_ = int64_t{0}; - } - inline int64_t MessageOfProp::_internal_guid() const - { - return _impl_.guid_; - } - inline int64_t MessageOfProp::guid() const + // ------------------------------------------------------------------- + + // MessageOfObj + + // .protobuf.MessageOfStudent student_message = 1; + inline bool MessageOfObj::_internal_has_student_message() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.guid) - return _internal_guid(); + return message_of_obj_case() == kStudentMessage; } - inline void MessageOfProp::_internal_set_guid(int64_t value) + inline bool MessageOfObj::has_student_message() const { - _impl_.guid_ = value; + return _internal_has_student_message(); } - inline void MessageOfProp::set_guid(int64_t value) + inline void MessageOfObj::set_has_student_message() { - _internal_set_guid(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.guid) + _impl_._oneof_case_[0] = kStudentMessage; } - - // .protobuf.PlaceType place = 6; - inline void MessageOfProp::clear_place() + inline void MessageOfObj::clear_student_message() { - _impl_.place_ = 0; + if (_internal_has_student_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.student_message_; + } + clear_has_message_of_obj(); + } } - inline ::protobuf::PlaceType MessageOfProp::_internal_place() const + inline ::protobuf::MessageOfStudent* MessageOfObj::release_student_message() { - return static_cast<::protobuf::PlaceType>(_impl_.place_); + // @@protoc_insertion_point(field_release:protobuf.MessageOfObj.student_message) + if (_internal_has_student_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfStudent* temp = _impl_.message_of_obj_.student_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_obj_.student_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline ::protobuf::PlaceType MessageOfProp::place() const + inline const ::protobuf::MessageOfStudent& MessageOfObj::_internal_student_message() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.place) - return _internal_place(); + return _internal_has_student_message() ? *_impl_.message_of_obj_.student_message_ : reinterpret_cast<::protobuf::MessageOfStudent&>(::protobuf::_MessageOfStudent_default_instance_); } - inline void MessageOfProp::_internal_set_place(::protobuf::PlaceType value) + inline const ::protobuf::MessageOfStudent& MessageOfObj::student_message() const { - _impl_.place_ = value; + // @@protoc_insertion_point(field_get:protobuf.MessageOfObj.student_message) + return _internal_student_message(); } - inline void MessageOfProp::set_place(::protobuf::PlaceType value) + inline ::protobuf::MessageOfStudent* MessageOfObj::unsafe_arena_release_student_message() { - _internal_set_place(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.place) + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfObj.student_message) + if (_internal_has_student_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfStudent* temp = _impl_.message_of_obj_.student_message_; + _impl_.message_of_obj_.student_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - - // int32 size = 7; - inline void MessageOfProp::clear_size() + inline void MessageOfObj::unsafe_arena_set_allocated_student_message(::protobuf::MessageOfStudent* student_message) { - _impl_.size_ = 0; + clear_message_of_obj(); + if (student_message) + { + set_has_student_message(); + _impl_.message_of_obj_.student_message_ = student_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfObj.student_message) } - inline int32_t MessageOfProp::_internal_size() const + inline ::protobuf::MessageOfStudent* MessageOfObj::_internal_mutable_student_message() { - return _impl_.size_; + if (!_internal_has_student_message()) + { + clear_message_of_obj(); + set_has_student_message(); + _impl_.message_of_obj_.student_message_ = CreateMaybeMessage<::protobuf::MessageOfStudent>(GetArenaForAllocation()); + } + return _impl_.message_of_obj_.student_message_; } - inline int32_t MessageOfProp::size() const + inline ::protobuf::MessageOfStudent* MessageOfObj::mutable_student_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.size) - return _internal_size(); + ::protobuf::MessageOfStudent* _msg = _internal_mutable_student_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfObj.student_message) + return _msg; } - inline void MessageOfProp::_internal_set_size(int32_t value) + + // .protobuf.MessageOfTricker tricker_message = 2; + inline bool MessageOfObj::_internal_has_tricker_message() const { - _impl_.size_ = value; + return message_of_obj_case() == kTrickerMessage; } - inline void MessageOfProp::set_size(int32_t value) + inline bool MessageOfObj::has_tricker_message() const { - _internal_set_size(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.size) + return _internal_has_tricker_message(); } - - // bool is_moving = 8; - inline void MessageOfProp::clear_is_moving() + inline void MessageOfObj::set_has_tricker_message() { - _impl_.is_moving_ = false; + _impl_._oneof_case_[0] = kTrickerMessage; } - inline bool MessageOfProp::_internal_is_moving() const + inline void MessageOfObj::clear_tricker_message() { - return _impl_.is_moving_; + if (_internal_has_tricker_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.tricker_message_; + } + clear_has_message_of_obj(); + } } - inline bool MessageOfProp::is_moving() const + inline ::protobuf::MessageOfTricker* MessageOfObj::release_tricker_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfProp.is_moving) - return _internal_is_moving(); + // @@protoc_insertion_point(field_release:protobuf.MessageOfObj.tricker_message) + if (_internal_has_tricker_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfTricker* temp = _impl_.message_of_obj_.tricker_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_obj_.tricker_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfProp::_internal_set_is_moving(bool value) + inline const ::protobuf::MessageOfTricker& MessageOfObj::_internal_tricker_message() const { - _impl_.is_moving_ = value; + return _internal_has_tricker_message() ? *_impl_.message_of_obj_.tricker_message_ : reinterpret_cast<::protobuf::MessageOfTricker&>(::protobuf::_MessageOfTricker_default_instance_); } - inline void MessageOfProp::set_is_moving(bool value) + inline const ::protobuf::MessageOfTricker& MessageOfObj::tricker_message() const { - _internal_set_is_moving(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfProp.is_moving) + // @@protoc_insertion_point(field_get:protobuf.MessageOfObj.tricker_message) + return _internal_tricker_message(); } - - // ------------------------------------------------------------------- - - // MessageOfPickedProp - - // .protobuf.PropType type = 1; - inline void MessageOfPickedProp::clear_type() + inline ::protobuf::MessageOfTricker* MessageOfObj::unsafe_arena_release_tricker_message() { - _impl_.type_ = 0; + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfObj.tricker_message) + if (_internal_has_tricker_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfTricker* temp = _impl_.message_of_obj_.tricker_message_; + _impl_.message_of_obj_.tricker_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline ::protobuf::PropType MessageOfPickedProp::_internal_type() const + inline void MessageOfObj::unsafe_arena_set_allocated_tricker_message(::protobuf::MessageOfTricker* tricker_message) { - return static_cast<::protobuf::PropType>(_impl_.type_); + clear_message_of_obj(); + if (tricker_message) + { + set_has_tricker_message(); + _impl_.message_of_obj_.tricker_message_ = tricker_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfObj.tricker_message) } - inline ::protobuf::PropType MessageOfPickedProp::type() const + inline ::protobuf::MessageOfTricker* MessageOfObj::_internal_mutable_tricker_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.type) - return _internal_type(); + if (!_internal_has_tricker_message()) + { + clear_message_of_obj(); + set_has_tricker_message(); + _impl_.message_of_obj_.tricker_message_ = CreateMaybeMessage<::protobuf::MessageOfTricker>(GetArenaForAllocation()); + } + return _impl_.message_of_obj_.tricker_message_; } - inline void MessageOfPickedProp::_internal_set_type(::protobuf::PropType value) + inline ::protobuf::MessageOfTricker* MessageOfObj::mutable_tricker_message() { - _impl_.type_ = value; + ::protobuf::MessageOfTricker* _msg = _internal_mutable_tricker_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfObj.tricker_message) + return _msg; } - inline void MessageOfPickedProp::set_type(::protobuf::PropType value) + + // .protobuf.MessageOfProp prop_message = 3; + inline bool MessageOfObj::_internal_has_prop_message() const { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.type) + return message_of_obj_case() == kPropMessage; } - - // int32 x = 2; - inline void MessageOfPickedProp::clear_x() + inline bool MessageOfObj::has_prop_message() const { - _impl_.x_ = 0; + return _internal_has_prop_message(); } - inline int32_t MessageOfPickedProp::_internal_x() const + inline void MessageOfObj::set_has_prop_message() { - return _impl_.x_; + _impl_._oneof_case_[0] = kPropMessage; } - inline int32_t MessageOfPickedProp::x() const + inline void MessageOfObj::clear_prop_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.x) - return _internal_x(); + if (_internal_has_prop_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.prop_message_; + } + clear_has_message_of_obj(); + } } - inline void MessageOfPickedProp::_internal_set_x(int32_t value) + inline ::protobuf::MessageOfProp* MessageOfObj::release_prop_message() { - _impl_.x_ = value; + // @@protoc_insertion_point(field_release:protobuf.MessageOfObj.prop_message) + if (_internal_has_prop_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfProp* temp = _impl_.message_of_obj_.prop_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_obj_.prop_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfPickedProp::set_x(int32_t value) + inline const ::protobuf::MessageOfProp& MessageOfObj::_internal_prop_message() const { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.x) + return _internal_has_prop_message() ? *_impl_.message_of_obj_.prop_message_ : reinterpret_cast<::protobuf::MessageOfProp&>(::protobuf::_MessageOfProp_default_instance_); } - - // int32 y = 3; - inline void MessageOfPickedProp::clear_y() + inline const ::protobuf::MessageOfProp& MessageOfObj::prop_message() const { - _impl_.y_ = 0; + // @@protoc_insertion_point(field_get:protobuf.MessageOfObj.prop_message) + return _internal_prop_message(); } - inline int32_t MessageOfPickedProp::_internal_y() const + inline ::protobuf::MessageOfProp* MessageOfObj::unsafe_arena_release_prop_message() { - return _impl_.y_; + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfObj.prop_message) + if (_internal_has_prop_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfProp* temp = _impl_.message_of_obj_.prop_message_; + _impl_.message_of_obj_.prop_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline int32_t MessageOfPickedProp::y() const + inline void MessageOfObj::unsafe_arena_set_allocated_prop_message(::protobuf::MessageOfProp* prop_message) { - // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.y) - return _internal_y(); + clear_message_of_obj(); + if (prop_message) + { + set_has_prop_message(); + _impl_.message_of_obj_.prop_message_ = prop_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfObj.prop_message) } - inline void MessageOfPickedProp::_internal_set_y(int32_t value) + inline ::protobuf::MessageOfProp* MessageOfObj::_internal_mutable_prop_message() { - _impl_.y_ = value; + if (!_internal_has_prop_message()) + { + clear_message_of_obj(); + set_has_prop_message(); + _impl_.message_of_obj_.prop_message_ = CreateMaybeMessage<::protobuf::MessageOfProp>(GetArenaForAllocation()); + } + return _impl_.message_of_obj_.prop_message_; } - inline void MessageOfPickedProp::set_y(int32_t value) + inline ::protobuf::MessageOfProp* MessageOfObj::mutable_prop_message() { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.y) + ::protobuf::MessageOfProp* _msg = _internal_mutable_prop_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfObj.prop_message) + return _msg; } - // double facing_direction = 4; - inline void MessageOfPickedProp::clear_facing_direction() - { - _impl_.facing_direction_ = 0; - } - inline double MessageOfPickedProp::_internal_facing_direction() const + // .protobuf.MessageOfBullet bullet_message = 4; + inline bool MessageOfObj::_internal_has_bullet_message() const { - return _impl_.facing_direction_; + return message_of_obj_case() == kBulletMessage; } - inline double MessageOfPickedProp::facing_direction() const + inline bool MessageOfObj::has_bullet_message() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.facing_direction) - return _internal_facing_direction(); + return _internal_has_bullet_message(); } - inline void MessageOfPickedProp::_internal_set_facing_direction(double value) + inline void MessageOfObj::set_has_bullet_message() { - _impl_.facing_direction_ = value; + _impl_._oneof_case_[0] = kBulletMessage; } - inline void MessageOfPickedProp::set_facing_direction(double value) + inline void MessageOfObj::clear_bullet_message() { - _internal_set_facing_direction(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.facing_direction) + if (_internal_has_bullet_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.bullet_message_; + } + clear_has_message_of_obj(); + } } - - // int64 mapping_id = 5; - inline void MessageOfPickedProp::clear_mapping_id() + inline ::protobuf::MessageOfBullet* MessageOfObj::release_bullet_message() { - _impl_.mapping_id_ = int64_t{0}; + // @@protoc_insertion_point(field_release:protobuf.MessageOfObj.bullet_message) + if (_internal_has_bullet_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfBullet* temp = _impl_.message_of_obj_.bullet_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_obj_.bullet_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline int64_t MessageOfPickedProp::_internal_mapping_id() const + inline const ::protobuf::MessageOfBullet& MessageOfObj::_internal_bullet_message() const { - return _impl_.mapping_id_; + return _internal_has_bullet_message() ? *_impl_.message_of_obj_.bullet_message_ : reinterpret_cast<::protobuf::MessageOfBullet&>(::protobuf::_MessageOfBullet_default_instance_); } - inline int64_t MessageOfPickedProp::mapping_id() const + inline const ::protobuf::MessageOfBullet& MessageOfObj::bullet_message() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfPickedProp.mapping_id) - return _internal_mapping_id(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfObj.bullet_message) + return _internal_bullet_message(); } - inline void MessageOfPickedProp::_internal_set_mapping_id(int64_t value) + inline ::protobuf::MessageOfBullet* MessageOfObj::unsafe_arena_release_bullet_message() { - _impl_.mapping_id_ = value; + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfObj.bullet_message) + if (_internal_has_bullet_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfBullet* temp = _impl_.message_of_obj_.bullet_message_; + _impl_.message_of_obj_.bullet_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfPickedProp::set_mapping_id(int64_t value) + inline void MessageOfObj::unsafe_arena_set_allocated_bullet_message(::protobuf::MessageOfBullet* bullet_message) { - _internal_set_mapping_id(value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfPickedProp.mapping_id) + clear_message_of_obj(); + if (bullet_message) + { + set_has_bullet_message(); + _impl_.message_of_obj_.bullet_message_ = bullet_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfObj.bullet_message) } - - // ------------------------------------------------------------------- - - // MessageOfMap_Row - - // repeated .protobuf.PlaceType col = 1; - inline int MessageOfMap_Row::_internal_col_size() const + inline ::protobuf::MessageOfBullet* MessageOfObj::_internal_mutable_bullet_message() { - return _impl_.col_.size(); + if (!_internal_has_bullet_message()) + { + clear_message_of_obj(); + set_has_bullet_message(); + _impl_.message_of_obj_.bullet_message_ = CreateMaybeMessage<::protobuf::MessageOfBullet>(GetArenaForAllocation()); + } + return _impl_.message_of_obj_.bullet_message_; } - inline int MessageOfMap_Row::col_size() const + inline ::protobuf::MessageOfBullet* MessageOfObj::mutable_bullet_message() { - return _internal_col_size(); + ::protobuf::MessageOfBullet* _msg = _internal_mutable_bullet_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfObj.bullet_message) + return _msg; } - inline void MessageOfMap_Row::clear_col() + + // .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; + inline bool MessageOfObj::_internal_has_bombed_bullet_message() const { - _impl_.col_.Clear(); + return message_of_obj_case() == kBombedBulletMessage; } - inline ::protobuf::PlaceType MessageOfMap_Row::_internal_col(int index) const + inline bool MessageOfObj::has_bombed_bullet_message() const { - return static_cast<::protobuf::PlaceType>(_impl_.col_.Get(index)); + return _internal_has_bombed_bullet_message(); } - inline ::protobuf::PlaceType MessageOfMap_Row::col(int index) const + inline void MessageOfObj::set_has_bombed_bullet_message() { - // @@protoc_insertion_point(field_get:protobuf.MessageOfMap.Row.col) - return _internal_col(index); + _impl_._oneof_case_[0] = kBombedBulletMessage; } - inline void MessageOfMap_Row::set_col(int index, ::protobuf::PlaceType value) + inline void MessageOfObj::clear_bombed_bullet_message() { - _impl_.col_.Set(index, value); - // @@protoc_insertion_point(field_set:protobuf.MessageOfMap.Row.col) + if (_internal_has_bombed_bullet_message()) + { + if (GetArenaForAllocation() == nullptr) + { + delete _impl_.message_of_obj_.bombed_bullet_message_; + } + clear_has_message_of_obj(); + } } - inline void MessageOfMap_Row::_internal_add_col(::protobuf::PlaceType value) + inline ::protobuf::MessageOfBombedBullet* MessageOfObj::release_bombed_bullet_message() { - _impl_.col_.Add(value); + // @@protoc_insertion_point(field_release:protobuf.MessageOfObj.bombed_bullet_message) + if (_internal_has_bombed_bullet_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfBombedBullet* temp = _impl_.message_of_obj_.bombed_bullet_message_; + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.message_of_obj_.bombed_bullet_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline void MessageOfMap_Row::add_col(::protobuf::PlaceType value) + inline const ::protobuf::MessageOfBombedBullet& MessageOfObj::_internal_bombed_bullet_message() const { - _internal_add_col(value); - // @@protoc_insertion_point(field_add:protobuf.MessageOfMap.Row.col) + return _internal_has_bombed_bullet_message() ? *_impl_.message_of_obj_.bombed_bullet_message_ : reinterpret_cast<::protobuf::MessageOfBombedBullet&>(::protobuf::_MessageOfBombedBullet_default_instance_); } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& - MessageOfMap_Row::col() const + inline const ::protobuf::MessageOfBombedBullet& MessageOfObj::bombed_bullet_message() const { - // @@protoc_insertion_point(field_list:protobuf.MessageOfMap.Row.col) - return _impl_.col_; + // @@protoc_insertion_point(field_get:protobuf.MessageOfObj.bombed_bullet_message) + return _internal_bombed_bullet_message(); } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* - MessageOfMap_Row::_internal_mutable_col() + inline ::protobuf::MessageOfBombedBullet* MessageOfObj::unsafe_arena_release_bombed_bullet_message() { - return &_impl_.col_; + // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.MessageOfObj.bombed_bullet_message) + if (_internal_has_bombed_bullet_message()) + { + clear_has_message_of_obj(); + ::protobuf::MessageOfBombedBullet* temp = _impl_.message_of_obj_.bombed_bullet_message_; + _impl_.message_of_obj_.bombed_bullet_message_ = nullptr; + return temp; + } + else + { + return nullptr; + } } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* - MessageOfMap_Row::mutable_col() + inline void MessageOfObj::unsafe_arena_set_allocated_bombed_bullet_message(::protobuf::MessageOfBombedBullet* bombed_bullet_message) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfMap.Row.col) - return _internal_mutable_col(); + clear_message_of_obj(); + if (bombed_bullet_message) + { + set_has_bombed_bullet_message(); + _impl_.message_of_obj_.bombed_bullet_message_ = bombed_bullet_message; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageOfObj.bombed_bullet_message) } - - // ------------------------------------------------------------------- - - // MessageOfMap - - // repeated .protobuf.MessageOfMap.Row row = 2; - inline int MessageOfMap::_internal_row_size() const + inline ::protobuf::MessageOfBombedBullet* MessageOfObj::_internal_mutable_bombed_bullet_message() { - return _impl_.row_.size(); + if (!_internal_has_bombed_bullet_message()) + { + clear_message_of_obj(); + set_has_bombed_bullet_message(); + _impl_.message_of_obj_.bombed_bullet_message_ = CreateMaybeMessage<::protobuf::MessageOfBombedBullet>(GetArenaForAllocation()); + } + return _impl_.message_of_obj_.bombed_bullet_message_; } - inline int MessageOfMap::row_size() const + inline ::protobuf::MessageOfBombedBullet* MessageOfObj::mutable_bombed_bullet_message() { - return _internal_row_size(); + ::protobuf::MessageOfBombedBullet* _msg = _internal_mutable_bombed_bullet_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageOfObj.bombed_bullet_message) + return _msg; } - inline void MessageOfMap::clear_row() + + inline bool MessageOfObj::has_message_of_obj() const { - _impl_.row_.Clear(); + return message_of_obj_case() != MESSAGE_OF_OBJ_NOT_SET; } - inline ::protobuf::MessageOfMap_Row* MessageOfMap::mutable_row(int index) + inline void MessageOfObj::clear_has_message_of_obj() { - // @@protoc_insertion_point(field_mutable:protobuf.MessageOfMap.row) - return _impl_.row_.Mutable(index); + _impl_._oneof_case_[0] = MESSAGE_OF_OBJ_NOT_SET; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>* - MessageOfMap::mutable_row() + inline MessageOfObj::MessageOfObjCase MessageOfObj::message_of_obj_case() const { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageOfMap.row) - return &_impl_.row_; + return MessageOfObj::MessageOfObjCase(_impl_._oneof_case_[0]); } - inline const ::protobuf::MessageOfMap_Row& MessageOfMap::_internal_row(int index) const + // ------------------------------------------------------------------- + + // MessageOfAll + + // int32 game_time = 1; + inline void MessageOfAll::clear_game_time() { - return _impl_.row_.Get(index); + _impl_.game_time_ = 0; } - inline const ::protobuf::MessageOfMap_Row& MessageOfMap::row(int index) const + inline int32_t MessageOfAll::_internal_game_time() const { - // @@protoc_insertion_point(field_get:protobuf.MessageOfMap.row) - return _internal_row(index); + return _impl_.game_time_; } - inline ::protobuf::MessageOfMap_Row* MessageOfMap::_internal_add_row() + inline int32_t MessageOfAll::game_time() const { - return _impl_.row_.Add(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.game_time) + return _internal_game_time(); } - inline ::protobuf::MessageOfMap_Row* MessageOfMap::add_row() + inline void MessageOfAll::_internal_set_game_time(int32_t value) { - ::protobuf::MessageOfMap_Row* _add = _internal_add_row(); - // @@protoc_insertion_point(field_add:protobuf.MessageOfMap.row) - return _add; + _impl_.game_time_ = value; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfMap_Row>& - MessageOfMap::row() const + inline void MessageOfAll::set_game_time(int32_t value) { - // @@protoc_insertion_point(field_list:protobuf.MessageOfMap.row) - return _impl_.row_; + _internal_set_game_time(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.game_time) } - // ------------------------------------------------------------------- - - // MessageToClient - - // repeated .protobuf.MessageOfStudent student_message = 1; - inline int MessageToClient::_internal_student_message_size() const + // int32 subject_left = 2; + inline void MessageOfAll::clear_subject_left() { - return _impl_.student_message_.size(); + _impl_.subject_left_ = 0; } - inline int MessageToClient::student_message_size() const + inline int32_t MessageOfAll::_internal_subject_left() const { - return _internal_student_message_size(); + return _impl_.subject_left_; } - inline void MessageToClient::clear_student_message() + inline int32_t MessageOfAll::subject_left() const { - _impl_.student_message_.Clear(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.subject_left) + return _internal_subject_left(); } - inline ::protobuf::MessageOfStudent* MessageToClient::mutable_student_message(int index) + inline void MessageOfAll::_internal_set_subject_left(int32_t value) { - // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.student_message) - return _impl_.student_message_.Mutable(index); + _impl_.subject_left_ = value; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfStudent>* - MessageToClient::mutable_student_message() + inline void MessageOfAll::set_subject_left(int32_t value) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageToClient.student_message) - return &_impl_.student_message_; + _internal_set_subject_left(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.subject_left) } - inline const ::protobuf::MessageOfStudent& MessageToClient::_internal_student_message(int index) const + + // int32 student_graduated = 3; + inline void MessageOfAll::clear_student_graduated() { - return _impl_.student_message_.Get(index); + _impl_.student_graduated_ = 0; } - inline const ::protobuf::MessageOfStudent& MessageToClient::student_message(int index) const + inline int32_t MessageOfAll::_internal_student_graduated() const { - // @@protoc_insertion_point(field_get:protobuf.MessageToClient.student_message) - return _internal_student_message(index); + return _impl_.student_graduated_; } - inline ::protobuf::MessageOfStudent* MessageToClient::_internal_add_student_message() + inline int32_t MessageOfAll::student_graduated() const { - return _impl_.student_message_.Add(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.student_graduated) + return _internal_student_graduated(); } - inline ::protobuf::MessageOfStudent* MessageToClient::add_student_message() + inline void MessageOfAll::_internal_set_student_graduated(int32_t value) { - ::protobuf::MessageOfStudent* _add = _internal_add_student_message(); - // @@protoc_insertion_point(field_add:protobuf.MessageToClient.student_message) - return _add; + _impl_.student_graduated_ = value; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfStudent>& - MessageToClient::student_message() const + inline void MessageOfAll::set_student_graduated(int32_t value) { - // @@protoc_insertion_point(field_list:protobuf.MessageToClient.student_message) - return _impl_.student_message_; + _internal_set_student_graduated(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.student_graduated) } - // repeated .protobuf.MessageOfTricker tricker_message = 2; - inline int MessageToClient::_internal_tricker_message_size() const + // int32 student_quited = 4; + inline void MessageOfAll::clear_student_quited() { - return _impl_.tricker_message_.size(); + _impl_.student_quited_ = 0; } - inline int MessageToClient::tricker_message_size() const + inline int32_t MessageOfAll::_internal_student_quited() const { - return _internal_tricker_message_size(); + return _impl_.student_quited_; } - inline void MessageToClient::clear_tricker_message() + inline int32_t MessageOfAll::student_quited() const { - _impl_.tricker_message_.Clear(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.student_quited) + return _internal_student_quited(); } - inline ::protobuf::MessageOfTricker* MessageToClient::mutable_tricker_message(int index) + inline void MessageOfAll::_internal_set_student_quited(int32_t value) { - // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.tricker_message) - return _impl_.tricker_message_.Mutable(index); + _impl_.student_quited_ = value; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfTricker>* - MessageToClient::mutable_tricker_message() + inline void MessageOfAll::set_student_quited(int32_t value) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageToClient.tricker_message) - return &_impl_.tricker_message_; + _internal_set_student_quited(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.student_quited) } - inline const ::protobuf::MessageOfTricker& MessageToClient::_internal_tricker_message(int index) const + + // int32 student_score = 5; + inline void MessageOfAll::clear_student_score() { - return _impl_.tricker_message_.Get(index); + _impl_.student_score_ = 0; } - inline const ::protobuf::MessageOfTricker& MessageToClient::tricker_message(int index) const + inline int32_t MessageOfAll::_internal_student_score() const { - // @@protoc_insertion_point(field_get:protobuf.MessageToClient.tricker_message) - return _internal_tricker_message(index); + return _impl_.student_score_; } - inline ::protobuf::MessageOfTricker* MessageToClient::_internal_add_tricker_message() + inline int32_t MessageOfAll::student_score() const { - return _impl_.tricker_message_.Add(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.student_score) + return _internal_student_score(); } - inline ::protobuf::MessageOfTricker* MessageToClient::add_tricker_message() + inline void MessageOfAll::_internal_set_student_score(int32_t value) { - ::protobuf::MessageOfTricker* _add = _internal_add_tricker_message(); - // @@protoc_insertion_point(field_add:protobuf.MessageToClient.tricker_message) - return _add; + _impl_.student_score_ = value; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfTricker>& - MessageToClient::tricker_message() const + inline void MessageOfAll::set_student_score(int32_t value) { - // @@protoc_insertion_point(field_list:protobuf.MessageToClient.tricker_message) - return _impl_.tricker_message_; + _internal_set_student_score(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.student_score) } - // repeated .protobuf.MessageOfProp prop_message = 3; - inline int MessageToClient::_internal_prop_message_size() const + // int32 tricker_score = 6; + inline void MessageOfAll::clear_tricker_score() { - return _impl_.prop_message_.size(); + _impl_.tricker_score_ = 0; } - inline int MessageToClient::prop_message_size() const + inline int32_t MessageOfAll::_internal_tricker_score() const { - return _internal_prop_message_size(); + return _impl_.tricker_score_; } - inline void MessageToClient::clear_prop_message() + inline int32_t MessageOfAll::tricker_score() const { - _impl_.prop_message_.Clear(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.tricker_score) + return _internal_tricker_score(); } - inline ::protobuf::MessageOfProp* MessageToClient::mutable_prop_message(int index) + inline void MessageOfAll::_internal_set_tricker_score(int32_t value) { - // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.prop_message) - return _impl_.prop_message_.Mutable(index); + _impl_.tricker_score_ = value; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfProp>* - MessageToClient::mutable_prop_message() + inline void MessageOfAll::set_tricker_score(int32_t value) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageToClient.prop_message) - return &_impl_.prop_message_; + _internal_set_tricker_score(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.tricker_score) } - inline const ::protobuf::MessageOfProp& MessageToClient::_internal_prop_message(int index) const + + // bool gate_opened = 7; + inline void MessageOfAll::clear_gate_opened() { - return _impl_.prop_message_.Get(index); + _impl_.gate_opened_ = false; } - inline const ::protobuf::MessageOfProp& MessageToClient::prop_message(int index) const + inline bool MessageOfAll::_internal_gate_opened() const { - // @@protoc_insertion_point(field_get:protobuf.MessageToClient.prop_message) - return _internal_prop_message(index); + return _impl_.gate_opened_; } - inline ::protobuf::MessageOfProp* MessageToClient::_internal_add_prop_message() + inline bool MessageOfAll::gate_opened() const { - return _impl_.prop_message_.Add(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.gate_opened) + return _internal_gate_opened(); } - inline ::protobuf::MessageOfProp* MessageToClient::add_prop_message() + inline void MessageOfAll::_internal_set_gate_opened(bool value) { - ::protobuf::MessageOfProp* _add = _internal_add_prop_message(); - // @@protoc_insertion_point(field_add:protobuf.MessageToClient.prop_message) - return _add; + _impl_.gate_opened_ = value; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfProp>& - MessageToClient::prop_message() const + inline void MessageOfAll::set_gate_opened(bool value) { - // @@protoc_insertion_point(field_list:protobuf.MessageToClient.prop_message) - return _impl_.prop_message_; + _internal_set_gate_opened(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.gate_opened) } - // repeated .protobuf.MessageOfBullet bullet_message = 4; - inline int MessageToClient::_internal_bullet_message_size() const + // bool hidden_gate_refreshed = 8; + inline void MessageOfAll::clear_hidden_gate_refreshed() { - return _impl_.bullet_message_.size(); + _impl_.hidden_gate_refreshed_ = false; } - inline int MessageToClient::bullet_message_size() const + inline bool MessageOfAll::_internal_hidden_gate_refreshed() const { - return _internal_bullet_message_size(); + return _impl_.hidden_gate_refreshed_; } - inline void MessageToClient::clear_bullet_message() + inline bool MessageOfAll::hidden_gate_refreshed() const { - _impl_.bullet_message_.Clear(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.hidden_gate_refreshed) + return _internal_hidden_gate_refreshed(); } - inline ::protobuf::MessageOfBullet* MessageToClient::mutable_bullet_message(int index) + inline void MessageOfAll::_internal_set_hidden_gate_refreshed(bool value) { - // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.bullet_message) - return _impl_.bullet_message_.Mutable(index); + _impl_.hidden_gate_refreshed_ = value; } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBullet>* - MessageToClient::mutable_bullet_message() + inline void MessageOfAll::set_hidden_gate_refreshed(bool value) { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageToClient.bullet_message) - return &_impl_.bullet_message_; + _internal_set_hidden_gate_refreshed(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.hidden_gate_refreshed) } - inline const ::protobuf::MessageOfBullet& MessageToClient::_internal_bullet_message(int index) const + + // bool hidden_gate_opened = 9; + inline void MessageOfAll::clear_hidden_gate_opened() { - return _impl_.bullet_message_.Get(index); + _impl_.hidden_gate_opened_ = false; } - inline const ::protobuf::MessageOfBullet& MessageToClient::bullet_message(int index) const + inline bool MessageOfAll::_internal_hidden_gate_opened() const { - // @@protoc_insertion_point(field_get:protobuf.MessageToClient.bullet_message) - return _internal_bullet_message(index); + return _impl_.hidden_gate_opened_; } - inline ::protobuf::MessageOfBullet* MessageToClient::_internal_add_bullet_message() + inline bool MessageOfAll::hidden_gate_opened() const { - return _impl_.bullet_message_.Add(); + // @@protoc_insertion_point(field_get:protobuf.MessageOfAll.hidden_gate_opened) + return _internal_hidden_gate_opened(); } - inline ::protobuf::MessageOfBullet* MessageToClient::add_bullet_message() + inline void MessageOfAll::_internal_set_hidden_gate_opened(bool value) { - ::protobuf::MessageOfBullet* _add = _internal_add_bullet_message(); - // @@protoc_insertion_point(field_add:protobuf.MessageToClient.bullet_message) - return _add; + _impl_.hidden_gate_opened_ = value; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBullet>& - MessageToClient::bullet_message() const + inline void MessageOfAll::set_hidden_gate_opened(bool value) { - // @@protoc_insertion_point(field_list:protobuf.MessageToClient.bullet_message) - return _impl_.bullet_message_; + _internal_set_hidden_gate_opened(value); + // @@protoc_insertion_point(field_set:protobuf.MessageOfAll.hidden_gate_opened) } - // repeated .protobuf.MessageOfBombedBullet bombed_bullet_message = 5; - inline int MessageToClient::_internal_bombed_bullet_message_size() const + // ------------------------------------------------------------------- + + // MessageToClient + + // repeated .protobuf.MessageOfObj obj_message = 1; + inline int MessageToClient::_internal_obj_message_size() const { - return _impl_.bombed_bullet_message_.size(); + return _impl_.obj_message_.size(); } - inline int MessageToClient::bombed_bullet_message_size() const + inline int MessageToClient::obj_message_size() const { - return _internal_bombed_bullet_message_size(); + return _internal_obj_message_size(); } - inline void MessageToClient::clear_bombed_bullet_message() + inline void MessageToClient::clear_obj_message() { - _impl_.bombed_bullet_message_.Clear(); + _impl_.obj_message_.Clear(); } - inline ::protobuf::MessageOfBombedBullet* MessageToClient::mutable_bombed_bullet_message(int index) + inline ::protobuf::MessageOfObj* MessageToClient::mutable_obj_message(int index) { - // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.bombed_bullet_message) - return _impl_.bombed_bullet_message_.Mutable(index); + // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.obj_message) + return _impl_.obj_message_.Mutable(index); } - inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBombedBullet>* - MessageToClient::mutable_bombed_bullet_message() + inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfObj>* + MessageToClient::mutable_obj_message() { - // @@protoc_insertion_point(field_mutable_list:protobuf.MessageToClient.bombed_bullet_message) - return &_impl_.bombed_bullet_message_; + // @@protoc_insertion_point(field_mutable_list:protobuf.MessageToClient.obj_message) + return &_impl_.obj_message_; } - inline const ::protobuf::MessageOfBombedBullet& MessageToClient::_internal_bombed_bullet_message(int index) const + inline const ::protobuf::MessageOfObj& MessageToClient::_internal_obj_message(int index) const { - return _impl_.bombed_bullet_message_.Get(index); + return _impl_.obj_message_.Get(index); } - inline const ::protobuf::MessageOfBombedBullet& MessageToClient::bombed_bullet_message(int index) const + inline const ::protobuf::MessageOfObj& MessageToClient::obj_message(int index) const { - // @@protoc_insertion_point(field_get:protobuf.MessageToClient.bombed_bullet_message) - return _internal_bombed_bullet_message(index); + // @@protoc_insertion_point(field_get:protobuf.MessageToClient.obj_message) + return _internal_obj_message(index); } - inline ::protobuf::MessageOfBombedBullet* MessageToClient::_internal_add_bombed_bullet_message() + inline ::protobuf::MessageOfObj* MessageToClient::_internal_add_obj_message() { - return _impl_.bombed_bullet_message_.Add(); + return _impl_.obj_message_.Add(); } - inline ::protobuf::MessageOfBombedBullet* MessageToClient::add_bombed_bullet_message() + inline ::protobuf::MessageOfObj* MessageToClient::add_obj_message() { - ::protobuf::MessageOfBombedBullet* _add = _internal_add_bombed_bullet_message(); - // @@protoc_insertion_point(field_add:protobuf.MessageToClient.bombed_bullet_message) + ::protobuf::MessageOfObj* _add = _internal_add_obj_message(); + // @@protoc_insertion_point(field_add:protobuf.MessageToClient.obj_message) return _add; } - inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfBombedBullet>& - MessageToClient::bombed_bullet_message() const + inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::protobuf::MessageOfObj>& + MessageToClient::obj_message() const { - // @@protoc_insertion_point(field_list:protobuf.MessageToClient.bombed_bullet_message) - return _impl_.bombed_bullet_message_; + // @@protoc_insertion_point(field_list:protobuf.MessageToClient.obj_message) + return _impl_.obj_message_; } - // .protobuf.MessageOfMap map_message = 6; + // .protobuf.MessageOfMap map_message = 2; inline bool MessageToClient::_internal_has_map_message() const { return this != internal_default_instance() && _impl_.map_message_ != nullptr; @@ -5286,7 +8691,7 @@ namespace protobuf // @@protoc_insertion_point(field_set_allocated:protobuf.MessageToClient.map_message) } - // .protobuf.GameState game_state = 7; + // .protobuf.GameState game_state = 3; inline void MessageToClient::clear_game_state() { _impl_.game_state_ = 0; @@ -5310,6 +8715,117 @@ namespace protobuf // @@protoc_insertion_point(field_set:protobuf.MessageToClient.game_state) } + // .protobuf.MessageOfAll all_message = 4; + inline bool MessageToClient::_internal_has_all_message() const + { + return this != internal_default_instance() && _impl_.all_message_ != nullptr; + } + inline bool MessageToClient::has_all_message() const + { + return _internal_has_all_message(); + } + inline void MessageToClient::clear_all_message() + { + if (GetArenaForAllocation() == nullptr && _impl_.all_message_ != nullptr) + { + delete _impl_.all_message_; + } + _impl_.all_message_ = nullptr; + } + inline const ::protobuf::MessageOfAll& MessageToClient::_internal_all_message() const + { + const ::protobuf::MessageOfAll* p = _impl_.all_message_; + return p != nullptr ? *p : reinterpret_cast(::protobuf::_MessageOfAll_default_instance_); + } + inline const ::protobuf::MessageOfAll& MessageToClient::all_message() const + { + // @@protoc_insertion_point(field_get:protobuf.MessageToClient.all_message) + return _internal_all_message(); + } + inline void MessageToClient::unsafe_arena_set_allocated_all_message( + ::protobuf::MessageOfAll* all_message + ) + { + if (GetArenaForAllocation() == nullptr) + { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.all_message_); + } + _impl_.all_message_ = all_message; + if (all_message) + { + } + else + { + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.MessageToClient.all_message) + } + inline ::protobuf::MessageOfAll* MessageToClient::release_all_message() + { + ::protobuf::MessageOfAll* temp = _impl_.all_message_; + _impl_.all_message_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) + { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) + { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; + } + inline ::protobuf::MessageOfAll* MessageToClient::unsafe_arena_release_all_message() + { + // @@protoc_insertion_point(field_release:protobuf.MessageToClient.all_message) + + ::protobuf::MessageOfAll* temp = _impl_.all_message_; + _impl_.all_message_ = nullptr; + return temp; + } + inline ::protobuf::MessageOfAll* MessageToClient::_internal_mutable_all_message() + { + if (_impl_.all_message_ == nullptr) + { + auto* p = CreateMaybeMessage<::protobuf::MessageOfAll>(GetArenaForAllocation()); + _impl_.all_message_ = p; + } + return _impl_.all_message_; + } + inline ::protobuf::MessageOfAll* MessageToClient::mutable_all_message() + { + ::protobuf::MessageOfAll* _msg = _internal_mutable_all_message(); + // @@protoc_insertion_point(field_mutable:protobuf.MessageToClient.all_message) + return _msg; + } + inline void MessageToClient::set_allocated_all_message(::protobuf::MessageOfAll* all_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) + { + delete _impl_.all_message_; + } + if (all_message) + { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(all_message); + if (message_arena != submessage_arena) + { + all_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, all_message, submessage_arena + ); + } + } + else + { + } + _impl_.all_message_ = all_message; + // @@protoc_insertion_point(field_set_allocated:protobuf.MessageToClient.all_message) + } + // ------------------------------------------------------------------- // MoveRes @@ -5548,6 +9064,20 @@ namespace protobuf // ------------------------------------------------------------------- + // ------------------------------------------------------------------- + + // ------------------------------------------------------------------- + + // ------------------------------------------------------------------- + + // ------------------------------------------------------------------- + + // ------------------------------------------------------------------- + + // ------------------------------------------------------------------- + + // ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) } // namespace protobuf diff --git a/CAPI/proto/Message2Server.pb.cc b/CAPI/cpp/proto/Message2Server.pb.cc similarity index 68% rename from CAPI/proto/Message2Server.pb.cc rename to CAPI/cpp/proto/Message2Server.pb.cc index c88d71e..8d59963 100644 --- a/CAPI/proto/Message2Server.pb.cc +++ b/CAPI/cpp/proto/Message2Server.pb.cc @@ -48,7 +48,7 @@ namespace protobuf ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.angle_)*/ 0, /*decltype(_impl_.time_in_milliseconds_)*/ int64_t{0}, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.angle_)*/ 0, /*decltype(_impl_.time_in_milliseconds_)*/ int64_t{0}, /*decltype(_impl_.player_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } struct MoveMsgDefaultTypeInternal @@ -66,33 +66,33 @@ namespace protobuf }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MoveMsgDefaultTypeInternal _MoveMsg_default_instance_; - PROTOBUF_CONSTEXPR PickMsg::PickMsg( + PROTOBUF_CONSTEXPR PropMsg::PropMsg( ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.prop_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.player_type_)*/ 0, /*decltype(_impl_.prop_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } - struct PickMsgDefaultTypeInternal + struct PropMsgDefaultTypeInternal { - PROTOBUF_CONSTEXPR PickMsgDefaultTypeInternal() : + PROTOBUF_CONSTEXPR PropMsgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) { } - ~PickMsgDefaultTypeInternal() + ~PropMsgDefaultTypeInternal() { } union { - PickMsg _instance; + PropMsg _instance; }; }; - PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PickMsgDefaultTypeInternal _PickMsg_default_instance_; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PropMsgDefaultTypeInternal _PropMsg_default_instance_; PROTOBUF_CONSTEXPR SendMsg::SendMsg( ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.message_)*/ {&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}, /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.to_player_id_)*/ int64_t{0}, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.message_)*/ {&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}, /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.to_player_id_)*/ int64_t{0}, /*decltype(_impl_.player_type_)*/ 0, /*decltype(_impl_.to_player_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } struct SendMsgDefaultTypeInternal @@ -110,33 +110,33 @@ namespace protobuf }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SendMsgDefaultTypeInternal _SendMsg_default_instance_; - PROTOBUF_CONSTEXPR TrickMsg::TrickMsg( + PROTOBUF_CONSTEXPR AttackMsg::AttackMsg( ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.angle_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.angle_)*/ 0, /*decltype(_impl_.player_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } - struct TrickMsgDefaultTypeInternal + struct AttackMsgDefaultTypeInternal { - PROTOBUF_CONSTEXPR TrickMsgDefaultTypeInternal() : + PROTOBUF_CONSTEXPR AttackMsgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) { } - ~TrickMsgDefaultTypeInternal() + ~AttackMsgDefaultTypeInternal() { } union { - TrickMsg _instance; + AttackMsg _instance; }; }; - PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrickMsgDefaultTypeInternal _TrickMsg_default_instance_; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttackMsgDefaultTypeInternal _AttackMsg_default_instance_; PROTOBUF_CONSTEXPR IDMsg::IDMsg( ::_pbi::ConstantInitialized ) : _impl_{ - /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_._cached_size_)*/ {}} + /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.player_type_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} { } struct IDMsgDefaultTypeInternal @@ -154,8 +154,30 @@ namespace protobuf }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IDMsgDefaultTypeInternal _IDMsg_default_instance_; + PROTOBUF_CONSTEXPR SkillMsg::SkillMsg( + ::_pbi::ConstantInitialized + ) : + _impl_{ + /*decltype(_impl_.player_id_)*/ int64_t{0}, /*decltype(_impl_.player_type_)*/ 0, /*decltype(_impl_.skill_id_)*/ 0, /*decltype(_impl_._cached_size_)*/ {}} + { + } + struct SkillMsgDefaultTypeInternal + { + PROTOBUF_CONSTEXPR SkillMsgDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) + { + } + ~SkillMsgDefaultTypeInternal() + { + } + union + { + SkillMsg _instance; + }; + }; + PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkillMsgDefaultTypeInternal _SkillMsg_default_instance_; } // namespace protobuf -static ::_pb::Metadata file_level_metadata_Message2Server_2eproto[6]; +static ::_pb::Metadata file_level_metadata_Message2Server_2eproto[7]; static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_Message2Server_2eproto = nullptr; static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_Message2Server_2eproto = nullptr; @@ -178,16 +200,18 @@ const uint32_t TableStruct_Message2Server_2eproto::offsets[] PROTOBUF_SECTION_VA ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::protobuf::MoveMsg, _impl_.player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::MoveMsg, _impl_.player_type_), PROTOBUF_FIELD_OFFSET(::protobuf::MoveMsg, _impl_.angle_), PROTOBUF_FIELD_OFFSET(::protobuf::MoveMsg, _impl_.time_in_milliseconds_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::protobuf::PickMsg, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::protobuf::PropMsg, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::protobuf::PickMsg, _impl_.player_id_), - PROTOBUF_FIELD_OFFSET(::protobuf::PickMsg, _impl_.prop_type_), + PROTOBUF_FIELD_OFFSET(::protobuf::PropMsg, _impl_.player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::PropMsg, _impl_.player_type_), + PROTOBUF_FIELD_OFFSET(::protobuf::PropMsg, _impl_.prop_type_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _internal_metadata_), ~0u, // no _extensions_ @@ -195,16 +219,19 @@ const uint32_t TableStruct_Message2Server_2eproto::offsets[] PROTOBUF_SECTION_VA ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.player_type_), PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.to_player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.to_player_type_), PROTOBUF_FIELD_OFFSET(::protobuf::SendMsg, _impl_.message_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::protobuf::TrickMsg, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::protobuf::TrickMsg, _impl_.player_id_), - PROTOBUF_FIELD_OFFSET(::protobuf::TrickMsg, _impl_.angle_), + PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _impl_.player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _impl_.player_type_), + PROTOBUF_FIELD_OFFSET(::protobuf::AttackMsg, _impl_.angle_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::protobuf::IDMsg, _internal_metadata_), ~0u, // no _extensions_ @@ -212,23 +239,35 @@ const uint32_t TableStruct_Message2Server_2eproto::offsets[] PROTOBUF_SECTION_VA ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::protobuf::IDMsg, _impl_.player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::IDMsg, _impl_.player_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::protobuf::SkillMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::protobuf::SkillMsg, _impl_.player_id_), + PROTOBUF_FIELD_OFFSET(::protobuf::SkillMsg, _impl_.player_type_), + PROTOBUF_FIELD_OFFSET(::protobuf::SkillMsg, _impl_.skill_id_), }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { {0, -1, -1, sizeof(::protobuf::PlayerMsg)}, {11, -1, -1, sizeof(::protobuf::MoveMsg)}, - {20, -1, -1, sizeof(::protobuf::PickMsg)}, - {28, -1, -1, sizeof(::protobuf::SendMsg)}, - {37, -1, -1, sizeof(::protobuf::TrickMsg)}, - {45, -1, -1, sizeof(::protobuf::IDMsg)}, + {21, -1, -1, sizeof(::protobuf::PropMsg)}, + {30, -1, -1, sizeof(::protobuf::SendMsg)}, + {41, -1, -1, sizeof(::protobuf::AttackMsg)}, + {50, -1, -1, sizeof(::protobuf::IDMsg)}, + {58, -1, -1, sizeof(::protobuf::SkillMsg)}, }; static const ::_pb::Message* const file_default_instances[] = { &::protobuf::_PlayerMsg_default_instance_._instance, &::protobuf::_MoveMsg_default_instance_._instance, - &::protobuf::_PickMsg_default_instance_._instance, + &::protobuf::_PropMsg_default_instance_._instance, &::protobuf::_SendMsg_default_instance_._instance, - &::protobuf::_TrickMsg_default_instance_._instance, + &::protobuf::_AttackMsg_default_instance_._instance, &::protobuf::_IDMsg_default_instance_._instance, + &::protobuf::_SkillMsg_default_instance_._instance, }; const char descriptor_table_protodef_Message2Server_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = @@ -237,15 +276,24 @@ const char descriptor_table_protodef_Message2Server_2eproto[] PROTOBUF_SECTION_V " \001(\003\022)\n\013player_type\030\002 \001(\0162\024.protobuf.Pla" "yerType\022-\n\014student_type\030\003 \001(\0162\025.protobuf" ".StudentTypeH\000\022-\n\014tricker_type\030\004 \001(\0162\025.p" - "rotobuf.TrickerTypeH\000B\n\n\010job_type\"I\n\007Mov" - "eMsg\022\021\n\tplayer_id\030\001 \001(\003\022\r\n\005angle\030\002 \001(\001\022\034" - "\n\024time_in_milliseconds\030\003 \001(\003\"C\n\007PickMsg\022" - "\021\n\tplayer_id\030\001 \001(\003\022%\n\tprop_type\030\002 \001(\0162\022." - "protobuf.PropType\"C\n\007SendMsg\022\021\n\tplayer_i" - "d\030\001 \001(\003\022\024\n\014to_player_id\030\002 \001(\003\022\017\n\007message" - "\030\003 \001(\t\",\n\010TrickMsg\022\021\n\tplayer_id\030\001 \001(\003\022\r\n" - "\005angle\030\002 \001(\001\"\032\n\005IDMsg\022\021\n\tplayer_id\030\001 \001(\003" - "b\006proto3"; + "rotobuf.TrickerTypeH\000B\n\n\010job_type\"t\n\007Mov" + "eMsg\022\021\n\tplayer_id\030\001 \001(\003\022)\n\013player_type\030\002" + " \001(\0162\024.protobuf.PlayerType\022\r\n\005angle\030\003 \001(" + "\001\022\034\n\024time_in_milliseconds\030\004 \001(\003\"n\n\007PropM" + "sg\022\021\n\tplayer_id\030\001 \001(\003\022)\n\013player_type\030\002 \001" + "(\0162\024.protobuf.PlayerType\022%\n\tprop_type\030\003 " + "\001(\0162\022.protobuf.PropType\"\234\001\n\007SendMsg\022\021\n\tp" + "layer_id\030\001 \001(\003\022)\n\013player_type\030\002 \001(\0162\024.pr" + "otobuf.PlayerType\022\024\n\014to_player_id\030\003 \001(\003\022" + ",\n\016to_player_type\030\004 \001(\0162\024.protobuf.Playe" + "rType\022\017\n\007message\030\005 \001(\t\"X\n\tAttackMsg\022\021\n\tp" + "layer_id\030\001 \001(\003\022)\n\013player_type\030\002 \001(\0162\024.pr" + "otobuf.PlayerType\022\r\n\005angle\030\003 \001(\001\"E\n\005IDMs" + "g\022\021\n\tplayer_id\030\001 \001(\003\022)\n\013player_type\030\002 \001(" + "\0162\024.protobuf.PlayerType\"Z\n\010SkillMsg\022\021\n\tp" + "layer_id\030\001 \001(\003\022)\n\013player_type\030\002 \001(\0162\024.pr" + "otobuf.PlayerType\022\020\n\010skill_id\030\003 \001(\005b\006pro" + "to3"; static const ::_pbi::DescriptorTable* const descriptor_table_Message2Server_2eproto_deps[1] = { &::descriptor_table_MessageType_2eproto, }; @@ -253,13 +301,13 @@ static ::_pbi::once_flag descriptor_table_Message2Server_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_Message2Server_2eproto = { false, false, - 528, + 883, descriptor_table_protodef_Message2Server_2eproto, "Message2Server.proto", &descriptor_table_Message2Server_2eproto_once, descriptor_table_Message2Server_2eproto_deps, 1, - 6, + 7, schemas, file_default_instances, TableStruct_Message2Server_2eproto::offsets, @@ -668,10 +716,10 @@ namespace protobuf MoveMsg* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.player_id_){}, decltype(_impl_.angle_){}, decltype(_impl_.time_in_milliseconds_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){}, decltype(_impl_.angle_){}, decltype(_impl_.time_in_milliseconds_){}, decltype(_impl_.player_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.time_in_milliseconds_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.time_in_milliseconds_)); + ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.player_type_)); // @@protoc_insertion_point(copy_constructor:protobuf.MoveMsg) } @@ -682,7 +730,7 @@ namespace protobuf (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.angle_){0}, decltype(_impl_.time_in_milliseconds_){int64_t{0}}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.angle_){0}, decltype(_impl_.time_in_milliseconds_){int64_t{0}}, decltype(_impl_.player_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } MoveMsg::~MoveMsg() @@ -713,7 +761,7 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - ::memset(&_impl_.player_id_, 0, static_cast(reinterpret_cast(&_impl_.time_in_milliseconds_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.time_in_milliseconds_)); + ::memset(&_impl_.player_id_, 0, static_cast(reinterpret_cast(&_impl_.player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.player_type_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -738,9 +786,20 @@ namespace protobuf else goto handle_unusual; continue; - // double angle = 2; + // .protobuf.PlayerType player_type = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_player_type(static_cast<::protobuf::PlayerType>(val)); + } + else + goto handle_unusual; + continue; + // double angle = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 25)) { _impl_.angle_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(double); @@ -748,9 +807,9 @@ namespace protobuf else goto handle_unusual; continue; - // int64 time_in_milliseconds = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + // int64 time_in_milliseconds = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _impl_.time_in_milliseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); @@ -799,7 +858,16 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_player_id(), target); } - // double angle = 2; + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_player_type(), target + ); + } + + // double angle = 3; static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_angle = this->_internal_angle(); uint64_t raw_angle; @@ -807,14 +875,14 @@ namespace protobuf if (raw_angle != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_angle(), target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_angle(), target); } - // int64 time_in_milliseconds = 3; + // int64 time_in_milliseconds = 4; if (this->_internal_time_in_milliseconds() != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_time_in_milliseconds(), target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_time_in_milliseconds(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) @@ -842,7 +910,7 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } - // double angle = 2; + // double angle = 3; static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_angle = this->_internal_angle(); uint64_t raw_angle; @@ -852,12 +920,19 @@ namespace protobuf total_size += 1 + 8; } - // int64 time_in_milliseconds = 3; + // int64 time_in_milliseconds = 4; if (this->_internal_time_in_milliseconds() != 0) { total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_time_in_milliseconds()); } + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_type()); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -894,6 +969,10 @@ namespace protobuf { _this->_internal_set_time_in_milliseconds(from._internal_time_in_milliseconds()); } + if (from._internal_player_type() != 0) + { + _this->_internal_set_player_type(from._internal_player_type()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } @@ -916,7 +995,7 @@ namespace protobuf using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MoveMsg, _impl_.time_in_milliseconds_) + sizeof(MoveMsg::_impl_.time_in_milliseconds_) - PROTOBUF_FIELD_OFFSET(MoveMsg, _impl_.player_id_)>( + PROTOBUF_FIELD_OFFSET(MoveMsg, _impl_.player_type_) + sizeof(MoveMsg::_impl_.player_type_) - PROTOBUF_FIELD_OFFSET(MoveMsg, _impl_.player_id_)>( reinterpret_cast(&_impl_.player_id_), reinterpret_cast(&other->_impl_.player_id_) ); @@ -931,43 +1010,43 @@ namespace protobuf // =================================================================== - class PickMsg::_Internal + class PropMsg::_Internal { public: }; - PickMsg::PickMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : + PropMsg::PropMsg(::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.PickMsg) + // @@protoc_insertion_point(arena_constructor:protobuf.PropMsg) } - PickMsg::PickMsg(const PickMsg& from) : + PropMsg::PropMsg(const PropMsg& from) : ::PROTOBUF_NAMESPACE_ID::Message() { - PickMsg* const _this = this; + PropMsg* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.player_id_){}, decltype(_impl_.prop_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){}, decltype(_impl_.player_type_){}, decltype(_impl_.prop_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.prop_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.prop_type_)); - // @@protoc_insertion_point(copy_constructor:protobuf.PickMsg) + // @@protoc_insertion_point(copy_constructor:protobuf.PropMsg) } - inline void PickMsg::SharedCtor( + inline void PropMsg::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_.prop_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.player_type_){0}, decltype(_impl_.prop_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } - PickMsg::~PickMsg() + PropMsg::~PropMsg() { - // @@protoc_insertion_point(destructor:protobuf.PickMsg) + // @@protoc_insertion_point(destructor:protobuf.PropMsg) if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { (void)arena; @@ -976,19 +1055,19 @@ namespace protobuf SharedDtor(); } - inline void PickMsg::SharedDtor() + inline void PropMsg::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } - void PickMsg::SetCachedSize(int size) const + void PropMsg::SetCachedSize(int size) const { _impl_._cached_size_.Set(size); } - void PickMsg::Clear() + void PropMsg::Clear() { - // @@protoc_insertion_point(message_clear_start:protobuf.PickMsg) + // @@protoc_insertion_point(message_clear_start:protobuf.PropMsg) uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; @@ -997,7 +1076,7 @@ namespace protobuf _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } - const char* PickMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) + const char* PropMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) \ if (PROTOBUF_PREDICT_FALSE(!(x))) \ @@ -1018,9 +1097,20 @@ namespace protobuf else goto handle_unusual; continue; - // .protobuf.PropType prop_type = 2; + // .protobuf.PlayerType player_type = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_player_type(static_cast<::protobuf::PlayerType>(val)); + } + else + goto handle_unusual; + continue; + // .protobuf.PropType prop_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); @@ -1055,11 +1145,11 @@ namespace protobuf #undef CHK_ } - uint8_t* PickMsg::_InternalSerialize( + uint8_t* PropMsg::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream ) const { - // @@protoc_insertion_point(serialize_to_array_start:protobuf.PickMsg) + // @@protoc_insertion_point(serialize_to_array_start:protobuf.PropMsg) uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -1070,12 +1160,21 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_player_id(), target); } - // .protobuf.PropType prop_type = 2; + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_player_type(), target + ); + } + + // .protobuf.PropType prop_type = 3; if (this->_internal_prop_type() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_prop_type(), target + 3, this->_internal_prop_type(), target ); } @@ -1085,13 +1184,13 @@ namespace protobuf _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream ); } - // @@protoc_insertion_point(serialize_to_array_end:protobuf.PickMsg) + // @@protoc_insertion_point(serialize_to_array_end:protobuf.PropMsg) return target; } - size_t PickMsg::ByteSizeLong() const + size_t PropMsg::ByteSizeLong() const { - // @@protoc_insertion_point(message_byte_size_start:protobuf.PickMsg) + // @@protoc_insertion_point(message_byte_size_start:protobuf.PropMsg) size_t total_size = 0; uint32_t cached_has_bits = 0; @@ -1104,7 +1203,14 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } - // .protobuf.PropType prop_type = 2; + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_type()); + } + + // .protobuf.PropType prop_type = 3; if (this->_internal_prop_type() != 0) { total_size += 1 + @@ -1114,19 +1220,19 @@ namespace protobuf return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PickMsg::_class_data_ = { + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PropMsg::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PickMsg::MergeImpl}; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* PickMsg::GetClassData() const + PropMsg::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* PropMsg::GetClassData() const { return &_class_data_; } - void PickMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + void PropMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.PickMsg) + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.PropMsg) GOOGLE_DCHECK_NE(&from, _this); uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -1135,6 +1241,10 @@ namespace protobuf { _this->_internal_set_player_id(from._internal_player_id()); } + if (from._internal_player_type() != 0) + { + _this->_internal_set_player_type(from._internal_player_type()); + } if (from._internal_prop_type() != 0) { _this->_internal_set_prop_type(from._internal_prop_type()); @@ -1142,32 +1252,32 @@ namespace protobuf _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } - void PickMsg::CopyFrom(const PickMsg& from) + void PropMsg::CopyFrom(const PropMsg& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.PickMsg) + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.PropMsg) if (&from == this) return; Clear(); MergeFrom(from); } - bool PickMsg::IsInitialized() const + bool PropMsg::IsInitialized() const { return true; } - void PickMsg::InternalSwap(PickMsg* other) + void PropMsg::InternalSwap(PropMsg* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PickMsg, _impl_.prop_type_) + sizeof(PickMsg::_impl_.prop_type_) - PROTOBUF_FIELD_OFFSET(PickMsg, _impl_.player_id_)>( + PROTOBUF_FIELD_OFFSET(PropMsg, _impl_.prop_type_) + sizeof(PropMsg::_impl_.prop_type_) - PROTOBUF_FIELD_OFFSET(PropMsg, _impl_.player_id_)>( reinterpret_cast(&_impl_.player_id_), reinterpret_cast(&other->_impl_.player_id_) ); } - ::PROTOBUF_NAMESPACE_ID::Metadata PickMsg::GetMetadata() const + ::PROTOBUF_NAMESPACE_ID::Metadata PropMsg::GetMetadata() const { return ::_pbi::AssignDescriptors( &descriptor_table_Message2Server_2eproto_getter, &descriptor_table_Message2Server_2eproto_once, file_level_metadata_Message2Server_2eproto[2] @@ -1193,7 +1303,7 @@ namespace protobuf SendMsg* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.message_){}, decltype(_impl_.player_id_){}, decltype(_impl_.to_player_id_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.message_){}, decltype(_impl_.player_id_){}, decltype(_impl_.to_player_id_){}, decltype(_impl_.player_type_){}, decltype(_impl_.to_player_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); _impl_.message_.InitDefault(); @@ -1204,7 +1314,7 @@ namespace protobuf { _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation()); } - ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.to_player_id_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.to_player_id_)); + ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.to_player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.to_player_type_)); // @@protoc_insertion_point(copy_constructor:protobuf.SendMsg) } @@ -1215,7 +1325,7 @@ namespace protobuf (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.message_){}, decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.to_player_id_){int64_t{0}}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.message_){}, decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.to_player_id_){int64_t{0}}, decltype(_impl_.player_type_){0}, decltype(_impl_.to_player_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; _impl_.message_.InitDefault(); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING _impl_.message_.Set("", GetArenaForAllocation()); @@ -1252,7 +1362,7 @@ namespace protobuf (void)cached_has_bits; _impl_.message_.ClearToEmpty(); - ::memset(&_impl_.player_id_, 0, static_cast(reinterpret_cast(&_impl_.to_player_id_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.to_player_id_)); + ::memset(&_impl_.player_id_, 0, static_cast(reinterpret_cast(&_impl_.to_player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.to_player_type_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1277,19 +1387,41 @@ namespace protobuf else goto handle_unusual; continue; - // int64 to_player_id = 2; + // .protobuf.PlayerType player_type = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _impl_.to_player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); + _internal_set_player_type(static_cast<::protobuf::PlayerType>(val)); } else goto handle_unusual; continue; - // string message = 3; + // int64 to_player_id = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.to_player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.PlayerType to_player_type = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_to_player_type(static_cast<::protobuf::PlayerType>(val)); + } + else + goto handle_unusual; + continue; + // string message = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { auto str = _internal_mutable_message(); ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); @@ -1340,21 +1472,39 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_player_id(), target); } - // int64 to_player_id = 2; + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_player_type(), target + ); + } + + // int64 to_player_id = 3; if (this->_internal_to_player_id() != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_to_player_id(), target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_to_player_id(), target); + } + + // .protobuf.PlayerType to_player_type = 4; + if (this->_internal_to_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_to_player_type(), target + ); } - // string message = 3; + // string message = 5; if (!this->_internal_message().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_message().data(), static_cast(this->_internal_message().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "protobuf.SendMsg.message" ); target = stream->WriteStringMaybeAliased( - 3, this->_internal_message(), target + 5, this->_internal_message(), target ); } @@ -1377,7 +1527,7 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - // string message = 3; + // string message = 5; if (!this->_internal_message().empty()) { total_size += 1 + @@ -1392,12 +1542,26 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } - // int64 to_player_id = 2; + // int64 to_player_id = 3; if (this->_internal_to_player_id() != 0) { total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_to_player_id()); } + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_type()); + } + + // .protobuf.PlayerType to_player_type = 4; + if (this->_internal_to_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_to_player_type()); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -1430,6 +1594,14 @@ namespace protobuf { _this->_internal_set_to_player_id(from._internal_to_player_id()); } + if (from._internal_player_type() != 0) + { + _this->_internal_set_player_type(from._internal_player_type()); + } + if (from._internal_to_player_type() != 0) + { + _this->_internal_set_to_player_type(from._internal_to_player_type()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } @@ -1457,7 +1629,7 @@ namespace protobuf &_impl_.message_, lhs_arena, &other->_impl_.message_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SendMsg, _impl_.to_player_id_) + sizeof(SendMsg::_impl_.to_player_id_) - PROTOBUF_FIELD_OFFSET(SendMsg, _impl_.player_id_)>( + PROTOBUF_FIELD_OFFSET(SendMsg, _impl_.to_player_type_) + sizeof(SendMsg::_impl_.to_player_type_) - PROTOBUF_FIELD_OFFSET(SendMsg, _impl_.player_id_)>( reinterpret_cast(&_impl_.player_id_), reinterpret_cast(&other->_impl_.player_id_) ); @@ -1472,43 +1644,43 @@ namespace protobuf // =================================================================== - class TrickMsg::_Internal + class AttackMsg::_Internal { public: }; - TrickMsg::TrickMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : + AttackMsg::AttackMsg(::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.TrickMsg) + // @@protoc_insertion_point(arena_constructor:protobuf.AttackMsg) } - TrickMsg::TrickMsg(const TrickMsg& from) : + AttackMsg::AttackMsg(const AttackMsg& from) : ::PROTOBUF_NAMESPACE_ID::Message() { - TrickMsg* const _this = this; + AttackMsg* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.player_id_){}, decltype(_impl_.angle_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){}, decltype(_impl_.angle_){}, decltype(_impl_.player_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.angle_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.angle_)); - // @@protoc_insertion_point(copy_constructor:protobuf.TrickMsg) + ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.player_type_)); + // @@protoc_insertion_point(copy_constructor:protobuf.AttackMsg) } - inline void TrickMsg::SharedCtor( + inline void AttackMsg::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_.angle_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.angle_){0}, decltype(_impl_.player_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } - TrickMsg::~TrickMsg() + AttackMsg::~AttackMsg() { - // @@protoc_insertion_point(destructor:protobuf.TrickMsg) + // @@protoc_insertion_point(destructor:protobuf.AttackMsg) if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { (void)arena; @@ -1517,28 +1689,28 @@ namespace protobuf SharedDtor(); } - inline void TrickMsg::SharedDtor() + inline void AttackMsg::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } - void TrickMsg::SetCachedSize(int size) const + void AttackMsg::SetCachedSize(int size) const { _impl_._cached_size_.Set(size); } - void TrickMsg::Clear() + void AttackMsg::Clear() { - // @@protoc_insertion_point(message_clear_start:protobuf.TrickMsg) + // @@protoc_insertion_point(message_clear_start:protobuf.AttackMsg) 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(reinterpret_cast(&_impl_.angle_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.angle_)); + ::memset(&_impl_.player_id_, 0, static_cast(reinterpret_cast(&_impl_.player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.player_type_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } - const char* TrickMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) + const char* AttackMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { #define CHK_(x) \ if (PROTOBUF_PREDICT_FALSE(!(x))) \ @@ -1559,9 +1731,20 @@ namespace protobuf else goto handle_unusual; continue; - // double angle = 2; + // .protobuf.PlayerType player_type = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_player_type(static_cast<::protobuf::PlayerType>(val)); + } + else + goto handle_unusual; + continue; + // double angle = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 25)) { _impl_.angle_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(double); @@ -1595,11 +1778,11 @@ namespace protobuf #undef CHK_ } - uint8_t* TrickMsg::_InternalSerialize( + uint8_t* AttackMsg::_InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream ) const { - // @@protoc_insertion_point(serialize_to_array_start:protobuf.TrickMsg) + // @@protoc_insertion_point(serialize_to_array_start:protobuf.AttackMsg) uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -1610,7 +1793,16 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_player_id(), target); } - // double angle = 2; + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_player_type(), target + ); + } + + // double angle = 3; static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_angle = this->_internal_angle(); uint64_t raw_angle; @@ -1618,7 +1810,7 @@ namespace protobuf if (raw_angle != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_angle(), target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_angle(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) @@ -1627,13 +1819,13 @@ namespace protobuf _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream ); } - // @@protoc_insertion_point(serialize_to_array_end:protobuf.TrickMsg) + // @@protoc_insertion_point(serialize_to_array_end:protobuf.AttackMsg) return target; } - size_t TrickMsg::ByteSizeLong() const + size_t AttackMsg::ByteSizeLong() const { - // @@protoc_insertion_point(message_byte_size_start:protobuf.TrickMsg) + // @@protoc_insertion_point(message_byte_size_start:protobuf.AttackMsg) size_t total_size = 0; uint32_t cached_has_bits = 0; @@ -1646,7 +1838,7 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } - // double angle = 2; + // double angle = 3; static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); double tmp_angle = this->_internal_angle(); uint64_t raw_angle; @@ -1656,22 +1848,29 @@ namespace protobuf total_size += 1 + 8; } + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_type()); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TrickMsg::_class_data_ = { + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AttackMsg::_class_data_ = { ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - TrickMsg::MergeImpl}; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* TrickMsg::GetClassData() const + AttackMsg::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* AttackMsg::GetClassData() const { return &_class_data_; } - void TrickMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + void AttackMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.TrickMsg) + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.AttackMsg) GOOGLE_DCHECK_NE(&from, _this); uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -1688,35 +1887,39 @@ namespace protobuf { _this->_internal_set_angle(from._internal_angle()); } + if (from._internal_player_type() != 0) + { + _this->_internal_set_player_type(from._internal_player_type()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } - void TrickMsg::CopyFrom(const TrickMsg& from) + void AttackMsg::CopyFrom(const AttackMsg& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.TrickMsg) + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.AttackMsg) if (&from == this) return; Clear(); MergeFrom(from); } - bool TrickMsg::IsInitialized() const + bool AttackMsg::IsInitialized() const { return true; } - void TrickMsg::InternalSwap(TrickMsg* other) + void AttackMsg::InternalSwap(AttackMsg* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(TrickMsg, _impl_.angle_) + sizeof(TrickMsg::_impl_.angle_) - PROTOBUF_FIELD_OFFSET(TrickMsg, _impl_.player_id_)>( + PROTOBUF_FIELD_OFFSET(AttackMsg, _impl_.player_type_) + sizeof(AttackMsg::_impl_.player_type_) - PROTOBUF_FIELD_OFFSET(AttackMsg, _impl_.player_id_)>( reinterpret_cast(&_impl_.player_id_), reinterpret_cast(&other->_impl_.player_id_) ); } - ::PROTOBUF_NAMESPACE_ID::Metadata TrickMsg::GetMetadata() const + ::PROTOBUF_NAMESPACE_ID::Metadata AttackMsg::GetMetadata() const { return ::_pbi::AssignDescriptors( &descriptor_table_Message2Server_2eproto_getter, &descriptor_table_Message2Server_2eproto_once, file_level_metadata_Message2Server_2eproto[4] @@ -1742,10 +1945,10 @@ namespace protobuf IDMsg* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.player_id_){}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){}, decltype(_impl_.player_type_){}, /*decltype(_impl_._cached_size_)*/ {}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.player_id_ = from._impl_.player_id_; + ::memcpy(&_impl_.player_id_, &from._impl_.player_id_, static_cast(reinterpret_cast(&_impl_.player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.player_type_)); // @@protoc_insertion_point(copy_constructor:protobuf.IDMsg) } @@ -1756,7 +1959,7 @@ namespace protobuf (void)arena; (void)is_message_owned; new (&_impl_) Impl_{ - decltype(_impl_.player_id_){int64_t{0}}, /*decltype(_impl_._cached_size_)*/ {}}; + decltype(_impl_.player_id_){int64_t{0}}, decltype(_impl_.player_type_){0}, /*decltype(_impl_._cached_size_)*/ {}}; } IDMsg::~IDMsg() @@ -1787,7 +1990,7 @@ namespace protobuf // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - _impl_.player_id_ = int64_t{0}; + ::memset(&_impl_.player_id_, 0, static_cast(reinterpret_cast(&_impl_.player_type_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.player_type_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1812,6 +2015,17 @@ namespace protobuf else goto handle_unusual; continue; + // .protobuf.PlayerType player_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_player_type(static_cast<::protobuf::PlayerType>(val)); + } + else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -1853,6 +2067,15 @@ namespace protobuf target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_player_id(), target); } + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_player_type(), target + ); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -1878,6 +2101,13 @@ namespace protobuf total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_player_id()); } + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_type()); + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -1902,6 +2132,10 @@ namespace protobuf { _this->_internal_set_player_id(from._internal_player_id()); } + if (from._internal_player_type() != 0) + { + _this->_internal_set_player_type(from._internal_player_type()); + } _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } @@ -1923,7 +2157,11 @@ namespace protobuf { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.player_id_, other->_impl_.player_id_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(IDMsg, _impl_.player_type_) + sizeof(IDMsg::_impl_.player_type_) - PROTOBUF_FIELD_OFFSET(IDMsg, _impl_.player_id_)>( + reinterpret_cast(&_impl_.player_id_), + reinterpret_cast(&other->_impl_.player_id_) + ); } ::PROTOBUF_NAMESPACE_ID::Metadata IDMsg::GetMetadata() const @@ -1933,6 +2171,278 @@ namespace protobuf ); } + // =================================================================== + + class SkillMsg::_Internal + { + public: + }; + + SkillMsg::SkillMsg(::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.SkillMsg) + } + SkillMsg::SkillMsg(const SkillMsg& from) : + ::PROTOBUF_NAMESPACE_ID::Message() + { + SkillMsg* const _this = this; + (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.player_id_){}, decltype(_impl_.player_type_){}, decltype(_impl_.skill_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(reinterpret_cast(&_impl_.skill_id_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.skill_id_)); + // @@protoc_insertion_point(copy_constructor:protobuf.SkillMsg) + } + + inline void SkillMsg::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_.player_type_){0}, decltype(_impl_.skill_id_){0}, /*decltype(_impl_._cached_size_)*/ {}}; + } + + SkillMsg::~SkillMsg() + { + // @@protoc_insertion_point(destructor:protobuf.SkillMsg) + if (auto* arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) + { + (void)arena; + return; + } + SharedDtor(); + } + + inline void SkillMsg::SharedDtor() + { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + } + + void SkillMsg::SetCachedSize(int size) const + { + _impl_._cached_size_.Set(size); + } + + void SkillMsg::Clear() + { + // @@protoc_insertion_point(message_clear_start:protobuf.SkillMsg) + 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(reinterpret_cast(&_impl_.skill_id_) - reinterpret_cast(&_impl_.player_id_)) + sizeof(_impl_.skill_id_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + const char* SkillMsg::_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(tag) == 8)) + { + _impl_.player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // .protobuf.PlayerType player_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_player_type(static_cast<::protobuf::PlayerType>(val)); + } + else + goto handle_unusual; + continue; + // int32 skill_id = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) + { + _impl_.skill_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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* SkillMsg::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream + ) const + { + // @@protoc_insertion_point(serialize_to_array_start:protobuf.SkillMsg) + 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); + } + + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_player_type(), target + ); + } + + // int32 skill_id = 3; + if (this->_internal_skill_id() != 0) + { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_skill_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.SkillMsg) + return target; + } + + size_t SkillMsg::ByteSizeLong() const + { + // @@protoc_insertion_point(message_byte_size_start:protobuf.SkillMsg) + 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()); + } + + // .protobuf.PlayerType player_type = 2; + if (this->_internal_player_type() != 0) + { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_player_type()); + } + + // int32 skill_id = 3; + if (this->_internal_skill_id() != 0) + { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_skill_id()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); + } + + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SkillMsg::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SkillMsg::MergeImpl}; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* SkillMsg::GetClassData() const + { + return &_class_data_; + } + + void SkillMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) + { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:protobuf.SkillMsg) + 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_player_type() != 0) + { + _this->_internal_set_player_type(from._internal_player_type()); + } + if (from._internal_skill_id() != 0) + { + _this->_internal_set_skill_id(from._internal_skill_id()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + } + + void SkillMsg::CopyFrom(const SkillMsg& from) + { + // @@protoc_insertion_point(class_specific_copy_from_start:protobuf.SkillMsg) + if (&from == this) + return; + Clear(); + MergeFrom(from); + } + + bool SkillMsg::IsInitialized() const + { + return true; + } + + void SkillMsg::InternalSwap(SkillMsg* other) + { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SkillMsg, _impl_.skill_id_) + sizeof(SkillMsg::_impl_.skill_id_) - PROTOBUF_FIELD_OFFSET(SkillMsg, _impl_.player_id_)>( + reinterpret_cast(&_impl_.player_id_), + reinterpret_cast(&other->_impl_.player_id_) + ); + } + + ::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] + ); + } + // @@protoc_insertion_point(namespace_scope) } // namespace protobuf PROTOBUF_NAMESPACE_OPEN @@ -1949,10 +2459,10 @@ PROTOBUF_NOINLINE ::protobuf::MoveMsg* return Arena::CreateMessageInternal<::protobuf::MoveMsg>(arena); } template<> -PROTOBUF_NOINLINE ::protobuf::PickMsg* - Arena::CreateMaybeMessage<::protobuf::PickMsg>(Arena* arena) +PROTOBUF_NOINLINE ::protobuf::PropMsg* + Arena::CreateMaybeMessage<::protobuf::PropMsg>(Arena* arena) { - return Arena::CreateMessageInternal<::protobuf::PickMsg>(arena); + return Arena::CreateMessageInternal<::protobuf::PropMsg>(arena); } template<> PROTOBUF_NOINLINE ::protobuf::SendMsg* @@ -1961,10 +2471,10 @@ PROTOBUF_NOINLINE ::protobuf::SendMsg* return Arena::CreateMessageInternal<::protobuf::SendMsg>(arena); } template<> -PROTOBUF_NOINLINE ::protobuf::TrickMsg* - Arena::CreateMaybeMessage<::protobuf::TrickMsg>(Arena* arena) +PROTOBUF_NOINLINE ::protobuf::AttackMsg* + Arena::CreateMaybeMessage<::protobuf::AttackMsg>(Arena* arena) { - return Arena::CreateMessageInternal<::protobuf::TrickMsg>(arena); + return Arena::CreateMessageInternal<::protobuf::AttackMsg>(arena); } template<> PROTOBUF_NOINLINE ::protobuf::IDMsg* @@ -1972,6 +2482,12 @@ PROTOBUF_NOINLINE ::protobuf::IDMsg* { return Arena::CreateMessageInternal<::protobuf::IDMsg>(arena); } +template<> +PROTOBUF_NOINLINE ::protobuf::SkillMsg* + Arena::CreateMaybeMessage<::protobuf::SkillMsg>(Arena* arena) +{ + return Arena::CreateMessageInternal<::protobuf::SkillMsg>(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/CAPI/proto/Message2Server.pb.h b/CAPI/cpp/proto/Message2Server.pb.h similarity index 71% rename from CAPI/proto/Message2Server.pb.h rename to CAPI/cpp/proto/Message2Server.pb.h index c9618d9..1ad4a82 100644 --- a/CAPI/proto/Message2Server.pb.h +++ b/CAPI/cpp/proto/Message2Server.pb.h @@ -49,38 +49,43 @@ struct TableStruct_Message2Server_2eproto extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Message2Server_2eproto; namespace protobuf { + class AttackMsg; + struct AttackMsgDefaultTypeInternal; + extern AttackMsgDefaultTypeInternal _AttackMsg_default_instance_; class IDMsg; struct IDMsgDefaultTypeInternal; extern IDMsgDefaultTypeInternal _IDMsg_default_instance_; class MoveMsg; struct MoveMsgDefaultTypeInternal; extern MoveMsgDefaultTypeInternal _MoveMsg_default_instance_; - class PickMsg; - struct PickMsgDefaultTypeInternal; - extern PickMsgDefaultTypeInternal _PickMsg_default_instance_; class PlayerMsg; struct PlayerMsgDefaultTypeInternal; extern PlayerMsgDefaultTypeInternal _PlayerMsg_default_instance_; + class PropMsg; + struct PropMsgDefaultTypeInternal; + extern PropMsgDefaultTypeInternal _PropMsg_default_instance_; class SendMsg; struct SendMsgDefaultTypeInternal; extern SendMsgDefaultTypeInternal _SendMsg_default_instance_; - class TrickMsg; - struct TrickMsgDefaultTypeInternal; - extern TrickMsgDefaultTypeInternal _TrickMsg_default_instance_; + class SkillMsg; + struct SkillMsgDefaultTypeInternal; + extern SkillMsgDefaultTypeInternal _SkillMsg_default_instance_; } // namespace protobuf PROTOBUF_NAMESPACE_OPEN template<> +::protobuf::AttackMsg* Arena::CreateMaybeMessage<::protobuf::AttackMsg>(Arena*); +template<> ::protobuf::IDMsg* Arena::CreateMaybeMessage<::protobuf::IDMsg>(Arena*); template<> ::protobuf::MoveMsg* Arena::CreateMaybeMessage<::protobuf::MoveMsg>(Arena*); template<> -::protobuf::PickMsg* Arena::CreateMaybeMessage<::protobuf::PickMsg>(Arena*); -template<> ::protobuf::PlayerMsg* Arena::CreateMaybeMessage<::protobuf::PlayerMsg>(Arena*); template<> +::protobuf::PropMsg* Arena::CreateMaybeMessage<::protobuf::PropMsg>(Arena*); +template<> ::protobuf::SendMsg* Arena::CreateMaybeMessage<::protobuf::SendMsg>(Arena*); template<> -::protobuf::TrickMsg* Arena::CreateMaybeMessage<::protobuf::TrickMsg>(Arena*); +::protobuf::SkillMsg* Arena::CreateMaybeMessage<::protobuf::SkillMsg>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace protobuf { @@ -509,8 +514,9 @@ namespace protobuf enum : int { kPlayerIdFieldNumber = 1, - kAngleFieldNumber = 2, - kTimeInMillisecondsFieldNumber = 3, + kAngleFieldNumber = 3, + kTimeInMillisecondsFieldNumber = 4, + kPlayerTypeFieldNumber = 2, }; // int64 player_id = 1; void clear_player_id(); @@ -522,7 +528,7 @@ namespace protobuf void _internal_set_player_id(int64_t value); public: - // double angle = 2; + // double angle = 3; void clear_angle(); double angle() const; void set_angle(double value); @@ -532,7 +538,7 @@ namespace protobuf void _internal_set_angle(double value); public: - // int64 time_in_milliseconds = 3; + // int64 time_in_milliseconds = 4; void clear_time_in_milliseconds(); int64_t time_in_milliseconds() const; void set_time_in_milliseconds(int64_t value); @@ -541,6 +547,16 @@ namespace protobuf int64_t _internal_time_in_milliseconds() const; void _internal_set_time_in_milliseconds(int64_t value); + public: + // .protobuf.PlayerType player_type = 2; + void clear_player_type(); + ::protobuf::PlayerType player_type() const; + void set_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_player_type() const; + void _internal_set_player_type(::protobuf::PlayerType value); + public: // @@protoc_insertion_point(class_scope:protobuf.MoveMsg) @@ -556,6 +572,7 @@ namespace protobuf int64_t player_id_; double angle_; int64_t time_in_milliseconds_; + int player_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -566,31 +583,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class PickMsg final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.PickMsg) */ + class PropMsg final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.PropMsg) */ { public: - inline PickMsg() : - PickMsg(nullptr) + inline PropMsg() : + PropMsg(nullptr) { } - ~PickMsg() override; - explicit PROTOBUF_CONSTEXPR PickMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~PropMsg() override; + explicit PROTOBUF_CONSTEXPR PropMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - PickMsg(const PickMsg& from); - PickMsg(PickMsg&& from) noexcept + PropMsg(const PropMsg& from); + PropMsg(PropMsg&& from) noexcept : - PickMsg() + PropMsg() { *this = ::std::move(from); } - inline PickMsg& operator=(const PickMsg& from) + inline PropMsg& operator=(const PropMsg& from) { CopyFrom(from); return *this; } - inline PickMsg& operator=(PickMsg&& from) noexcept + inline PropMsg& operator=(PropMsg&& from) noexcept { if (this == &from) return *this; @@ -621,24 +638,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const PickMsg& default_instance() + static const PropMsg& default_instance() { return *internal_default_instance(); } - static inline const PickMsg* internal_default_instance() + static inline const PropMsg* internal_default_instance() { - return reinterpret_cast( - &_PickMsg_default_instance_ + return reinterpret_cast( + &_PropMsg_default_instance_ ); } static constexpr int kIndexInFileMessages = 2; - friend void swap(PickMsg& a, PickMsg& b) + friend void swap(PropMsg& a, PropMsg& b) { a.Swap(&b); } - inline void Swap(PickMsg* other) + inline void Swap(PropMsg* other) { if (other == this) return; @@ -657,7 +674,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PickMsg* other) + void UnsafeArenaSwap(PropMsg* other) { if (other == this) return; @@ -667,16 +684,16 @@ namespace protobuf // implements Message ---------------------------------------------- - PickMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + PropMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PickMsg& from); + void CopyFrom(const PropMsg& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const PickMsg& from) + void MergeFrom(const PropMsg& from) { - PickMsg::MergeImpl(*this, from); + PropMsg::MergeImpl(*this, from); } private: @@ -700,17 +717,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(PickMsg* other); + void InternalSwap(PropMsg* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.PickMsg"; + return "protobuf.PropMsg"; } protected: - explicit PickMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit PropMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -725,7 +742,8 @@ namespace protobuf enum : int { kPlayerIdFieldNumber = 1, - kPropTypeFieldNumber = 2, + kPlayerTypeFieldNumber = 2, + kPropTypeFieldNumber = 3, }; // int64 player_id = 1; void clear_player_id(); @@ -737,7 +755,17 @@ namespace protobuf void _internal_set_player_id(int64_t value); public: - // .protobuf.PropType prop_type = 2; + // .protobuf.PlayerType player_type = 2; + void clear_player_type(); + ::protobuf::PlayerType player_type() const; + void set_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_player_type() const; + void _internal_set_player_type(::protobuf::PlayerType value); + + public: + // .protobuf.PropType prop_type = 3; void clear_prop_type(); ::protobuf::PropType prop_type() const; void set_prop_type(::protobuf::PropType value); @@ -747,7 +775,7 @@ namespace protobuf void _internal_set_prop_type(::protobuf::PropType value); public: - // @@protoc_insertion_point(class_scope:protobuf.PickMsg) + // @@protoc_insertion_point(class_scope:protobuf.PropMsg) private: class _Internal; @@ -759,6 +787,7 @@ namespace protobuf struct Impl_ { int64_t player_id_; + int player_type_; int prop_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; @@ -928,11 +957,13 @@ namespace protobuf enum : int { - kMessageFieldNumber = 3, + kMessageFieldNumber = 5, kPlayerIdFieldNumber = 1, - kToPlayerIdFieldNumber = 2, + kToPlayerIdFieldNumber = 3, + kPlayerTypeFieldNumber = 2, + kToPlayerTypeFieldNumber = 4, }; - // string message = 3; + // string message = 5; void clear_message(); const std::string& message() const; template @@ -957,7 +988,7 @@ namespace protobuf void _internal_set_player_id(int64_t value); public: - // int64 to_player_id = 2; + // int64 to_player_id = 3; void clear_to_player_id(); int64_t to_player_id() const; void set_to_player_id(int64_t value); @@ -966,6 +997,26 @@ namespace protobuf int64_t _internal_to_player_id() const; void _internal_set_to_player_id(int64_t value); + public: + // .protobuf.PlayerType player_type = 2; + void clear_player_type(); + ::protobuf::PlayerType player_type() const; + void set_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_player_type() const; + void _internal_set_player_type(::protobuf::PlayerType value); + + public: + // .protobuf.PlayerType to_player_type = 4; + void clear_to_player_type(); + ::protobuf::PlayerType to_player_type() const; + void set_to_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_to_player_type() const; + void _internal_set_to_player_type(::protobuf::PlayerType value); + public: // @@protoc_insertion_point(class_scope:protobuf.SendMsg) @@ -981,6 +1032,8 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; int64_t player_id_; int64_t to_player_id_; + int player_type_; + int to_player_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -991,31 +1044,31 @@ namespace protobuf }; // ------------------------------------------------------------------- - class TrickMsg final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.TrickMsg) */ + class AttackMsg final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.AttackMsg) */ { public: - inline TrickMsg() : - TrickMsg(nullptr) + inline AttackMsg() : + AttackMsg(nullptr) { } - ~TrickMsg() override; - explicit PROTOBUF_CONSTEXPR TrickMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + ~AttackMsg() override; + explicit PROTOBUF_CONSTEXPR AttackMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - TrickMsg(const TrickMsg& from); - TrickMsg(TrickMsg&& from) noexcept + AttackMsg(const AttackMsg& from); + AttackMsg(AttackMsg&& from) noexcept : - TrickMsg() + AttackMsg() { *this = ::std::move(from); } - inline TrickMsg& operator=(const TrickMsg& from) + inline AttackMsg& operator=(const AttackMsg& from) { CopyFrom(from); return *this; } - inline TrickMsg& operator=(TrickMsg&& from) noexcept + inline AttackMsg& operator=(AttackMsg&& from) noexcept { if (this == &from) return *this; @@ -1046,24 +1099,24 @@ namespace protobuf { return default_instance().GetMetadata().reflection; } - static const TrickMsg& default_instance() + static const AttackMsg& default_instance() { return *internal_default_instance(); } - static inline const TrickMsg* internal_default_instance() + static inline const AttackMsg* internal_default_instance() { - return reinterpret_cast( - &_TrickMsg_default_instance_ + return reinterpret_cast( + &_AttackMsg_default_instance_ ); } static constexpr int kIndexInFileMessages = 4; - friend void swap(TrickMsg& a, TrickMsg& b) + friend void swap(AttackMsg& a, AttackMsg& b) { a.Swap(&b); } - inline void Swap(TrickMsg* other) + inline void Swap(AttackMsg* other) { if (other == this) return; @@ -1082,7 +1135,7 @@ namespace protobuf ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(TrickMsg* other) + void UnsafeArenaSwap(AttackMsg* other) { if (other == this) return; @@ -1092,16 +1145,16 @@ namespace protobuf // implements Message ---------------------------------------------- - TrickMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + AttackMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); + return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const TrickMsg& from); + void CopyFrom(const AttackMsg& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const TrickMsg& from) + void MergeFrom(const AttackMsg& from) { - TrickMsg::MergeImpl(*this, from); + AttackMsg::MergeImpl(*this, from); } private: @@ -1125,17 +1178,17 @@ namespace protobuf void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TrickMsg* other); + void InternalSwap(AttackMsg* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "protobuf.TrickMsg"; + return "protobuf.AttackMsg"; } protected: - explicit TrickMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); + explicit AttackMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; @@ -1150,7 +1203,8 @@ namespace protobuf enum : int { kPlayerIdFieldNumber = 1, - kAngleFieldNumber = 2, + kAngleFieldNumber = 3, + kPlayerTypeFieldNumber = 2, }; // int64 player_id = 1; void clear_player_id(); @@ -1162,7 +1216,7 @@ namespace protobuf void _internal_set_player_id(int64_t value); public: - // double angle = 2; + // double angle = 3; void clear_angle(); double angle() const; void set_angle(double value); @@ -1172,7 +1226,17 @@ namespace protobuf void _internal_set_angle(double value); public: - // @@protoc_insertion_point(class_scope:protobuf.TrickMsg) + // .protobuf.PlayerType player_type = 2; + void clear_player_type(); + ::protobuf::PlayerType player_type() const; + void set_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_player_type() const; + void _internal_set_player_type(::protobuf::PlayerType value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.AttackMsg) private: class _Internal; @@ -1185,6 +1249,7 @@ namespace protobuf { int64_t player_id_; double angle_; + int player_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -1354,6 +1419,7 @@ namespace protobuf enum : int { kPlayerIdFieldNumber = 1, + kPlayerTypeFieldNumber = 2, }; // int64 player_id = 1; void clear_player_id(); @@ -1364,6 +1430,16 @@ namespace protobuf int64_t _internal_player_id() const; void _internal_set_player_id(int64_t value); + public: + // .protobuf.PlayerType player_type = 2; + void clear_player_type(); + ::protobuf::PlayerType player_type() const; + void set_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_player_type() const; + void _internal_set_player_type(::protobuf::PlayerType value); + public: // @@protoc_insertion_point(class_scope:protobuf.IDMsg) @@ -1377,6 +1453,223 @@ namespace protobuf struct Impl_ { int64_t player_id_; + int player_type_; + 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) */ + { + public: + inline SkillMsg() : + SkillMsg(nullptr) + { + } + ~SkillMsg() override; + explicit PROTOBUF_CONSTEXPR SkillMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SkillMsg(const SkillMsg& from); + SkillMsg(SkillMsg&& from) noexcept + : + SkillMsg() + { + *this = ::std::move(from); + } + + inline SkillMsg& operator=(const SkillMsg& from) + { + CopyFrom(from); + return *this; + } + inline SkillMsg& operator=(SkillMsg&& 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 SkillMsg& default_instance() + { + return *internal_default_instance(); + } + static inline const SkillMsg* internal_default_instance() + { + return reinterpret_cast( + &_SkillMsg_default_instance_ + ); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(SkillMsg& a, SkillMsg& b) + { + a.Swap(&b); + } + inline void Swap(SkillMsg* 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(SkillMsg* other) + { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SkillMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final + { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SkillMsg& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const SkillMsg& from) + { + SkillMsg::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(SkillMsg* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() + { + return "protobuf.SkillMsg"; + } + + protected: + explicit SkillMsg(::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, + kPlayerTypeFieldNumber = 2, + kSkillIdFieldNumber = 3, + }; + // 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: + // .protobuf.PlayerType player_type = 2; + void clear_player_type(); + ::protobuf::PlayerType player_type() const; + void set_player_type(::protobuf::PlayerType value); + + private: + ::protobuf::PlayerType _internal_player_type() const; + void _internal_set_player_type(::protobuf::PlayerType value); + + public: + // int32 skill_id = 3; + void clear_skill_id(); + int32_t skill_id() const; + void set_skill_id(int32_t value); + + private: + int32_t _internal_skill_id() const; + void _internal_set_skill_id(int32_t value); + + public: + // @@protoc_insertion_point(class_scope:protobuf.SkillMsg) + + private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ + { + int64_t player_id_; + int player_type_; + int32_t skill_id_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union @@ -1581,7 +1874,31 @@ namespace protobuf // @@protoc_insertion_point(field_set:protobuf.MoveMsg.player_id) } - // double angle = 2; + // .protobuf.PlayerType player_type = 2; + inline void MoveMsg::clear_player_type() + { + _impl_.player_type_ = 0; + } + inline ::protobuf::PlayerType MoveMsg::_internal_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.player_type_); + } + inline ::protobuf::PlayerType MoveMsg::player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.MoveMsg.player_type) + return _internal_player_type(); + } + inline void MoveMsg::_internal_set_player_type(::protobuf::PlayerType value) + { + _impl_.player_type_ = value; + } + inline void MoveMsg::set_player_type(::protobuf::PlayerType value) + { + _internal_set_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.MoveMsg.player_type) + } + + // double angle = 3; inline void MoveMsg::clear_angle() { _impl_.angle_ = 0; @@ -1605,7 +1922,7 @@ namespace protobuf // @@protoc_insertion_point(field_set:protobuf.MoveMsg.angle) } - // int64 time_in_milliseconds = 3; + // int64 time_in_milliseconds = 4; inline void MoveMsg::clear_time_in_milliseconds() { _impl_.time_in_milliseconds_ = int64_t{0}; @@ -1631,54 +1948,78 @@ namespace protobuf // ------------------------------------------------------------------- - // PickMsg + // PropMsg // int64 player_id = 1; - inline void PickMsg::clear_player_id() + inline void PropMsg::clear_player_id() { _impl_.player_id_ = int64_t{0}; } - inline int64_t PickMsg::_internal_player_id() const + inline int64_t PropMsg::_internal_player_id() const { return _impl_.player_id_; } - inline int64_t PickMsg::player_id() const + inline int64_t PropMsg::player_id() const { - // @@protoc_insertion_point(field_get:protobuf.PickMsg.player_id) + // @@protoc_insertion_point(field_get:protobuf.PropMsg.player_id) return _internal_player_id(); } - inline void PickMsg::_internal_set_player_id(int64_t value) + inline void PropMsg::_internal_set_player_id(int64_t value) { _impl_.player_id_ = value; } - inline void PickMsg::set_player_id(int64_t value) + inline void PropMsg::set_player_id(int64_t value) { _internal_set_player_id(value); - // @@protoc_insertion_point(field_set:protobuf.PickMsg.player_id) + // @@protoc_insertion_point(field_set:protobuf.PropMsg.player_id) } - // .protobuf.PropType prop_type = 2; - inline void PickMsg::clear_prop_type() + // .protobuf.PlayerType player_type = 2; + inline void PropMsg::clear_player_type() + { + _impl_.player_type_ = 0; + } + inline ::protobuf::PlayerType PropMsg::_internal_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.player_type_); + } + inline ::protobuf::PlayerType PropMsg::player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.PropMsg.player_type) + return _internal_player_type(); + } + inline void PropMsg::_internal_set_player_type(::protobuf::PlayerType value) + { + _impl_.player_type_ = value; + } + inline void PropMsg::set_player_type(::protobuf::PlayerType value) + { + _internal_set_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.PropMsg.player_type) + } + + // .protobuf.PropType prop_type = 3; + inline void PropMsg::clear_prop_type() { _impl_.prop_type_ = 0; } - inline ::protobuf::PropType PickMsg::_internal_prop_type() const + inline ::protobuf::PropType PropMsg::_internal_prop_type() const { return static_cast<::protobuf::PropType>(_impl_.prop_type_); } - inline ::protobuf::PropType PickMsg::prop_type() const + inline ::protobuf::PropType PropMsg::prop_type() const { - // @@protoc_insertion_point(field_get:protobuf.PickMsg.prop_type) + // @@protoc_insertion_point(field_get:protobuf.PropMsg.prop_type) return _internal_prop_type(); } - inline void PickMsg::_internal_set_prop_type(::protobuf::PropType value) + inline void PropMsg::_internal_set_prop_type(::protobuf::PropType value) { _impl_.prop_type_ = value; } - inline void PickMsg::set_prop_type(::protobuf::PropType value) + inline void PropMsg::set_prop_type(::protobuf::PropType value) { _internal_set_prop_type(value); - // @@protoc_insertion_point(field_set:protobuf.PickMsg.prop_type) + // @@protoc_insertion_point(field_set:protobuf.PropMsg.prop_type) } // ------------------------------------------------------------------- @@ -1709,7 +2050,31 @@ namespace protobuf // @@protoc_insertion_point(field_set:protobuf.SendMsg.player_id) } - // int64 to_player_id = 2; + // .protobuf.PlayerType player_type = 2; + inline void SendMsg::clear_player_type() + { + _impl_.player_type_ = 0; + } + inline ::protobuf::PlayerType SendMsg::_internal_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.player_type_); + } + inline ::protobuf::PlayerType SendMsg::player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.SendMsg.player_type) + return _internal_player_type(); + } + inline void SendMsg::_internal_set_player_type(::protobuf::PlayerType value) + { + _impl_.player_type_ = value; + } + inline void SendMsg::set_player_type(::protobuf::PlayerType value) + { + _internal_set_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.SendMsg.player_type) + } + + // int64 to_player_id = 3; inline void SendMsg::clear_to_player_id() { _impl_.to_player_id_ = int64_t{0}; @@ -1733,7 +2098,31 @@ namespace protobuf // @@protoc_insertion_point(field_set:protobuf.SendMsg.to_player_id) } - // string message = 3; + // .protobuf.PlayerType to_player_type = 4; + inline void SendMsg::clear_to_player_type() + { + _impl_.to_player_type_ = 0; + } + inline ::protobuf::PlayerType SendMsg::_internal_to_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.to_player_type_); + } + inline ::protobuf::PlayerType SendMsg::to_player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.SendMsg.to_player_type) + return _internal_to_player_type(); + } + inline void SendMsg::_internal_set_to_player_type(::protobuf::PlayerType value) + { + _impl_.to_player_type_ = value; + } + inline void SendMsg::set_to_player_type(::protobuf::PlayerType value) + { + _internal_set_to_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.SendMsg.to_player_type) + } + + // string message = 5; inline void SendMsg::clear_message() { _impl_.message_.ClearToEmpty(); @@ -1792,54 +2181,78 @@ namespace protobuf // ------------------------------------------------------------------- - // TrickMsg + // AttackMsg // int64 player_id = 1; - inline void TrickMsg::clear_player_id() + inline void AttackMsg::clear_player_id() { _impl_.player_id_ = int64_t{0}; } - inline int64_t TrickMsg::_internal_player_id() const + inline int64_t AttackMsg::_internal_player_id() const { return _impl_.player_id_; } - inline int64_t TrickMsg::player_id() const + inline int64_t AttackMsg::player_id() const { - // @@protoc_insertion_point(field_get:protobuf.TrickMsg.player_id) + // @@protoc_insertion_point(field_get:protobuf.AttackMsg.player_id) return _internal_player_id(); } - inline void TrickMsg::_internal_set_player_id(int64_t value) + inline void AttackMsg::_internal_set_player_id(int64_t value) { _impl_.player_id_ = value; } - inline void TrickMsg::set_player_id(int64_t value) + inline void AttackMsg::set_player_id(int64_t value) { _internal_set_player_id(value); - // @@protoc_insertion_point(field_set:protobuf.TrickMsg.player_id) + // @@protoc_insertion_point(field_set:protobuf.AttackMsg.player_id) } - // double angle = 2; - inline void TrickMsg::clear_angle() + // .protobuf.PlayerType player_type = 2; + inline void AttackMsg::clear_player_type() + { + _impl_.player_type_ = 0; + } + inline ::protobuf::PlayerType AttackMsg::_internal_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.player_type_); + } + inline ::protobuf::PlayerType AttackMsg::player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.AttackMsg.player_type) + return _internal_player_type(); + } + inline void AttackMsg::_internal_set_player_type(::protobuf::PlayerType value) + { + _impl_.player_type_ = value; + } + inline void AttackMsg::set_player_type(::protobuf::PlayerType value) + { + _internal_set_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.AttackMsg.player_type) + } + + // double angle = 3; + inline void AttackMsg::clear_angle() { _impl_.angle_ = 0; } - inline double TrickMsg::_internal_angle() const + inline double AttackMsg::_internal_angle() const { return _impl_.angle_; } - inline double TrickMsg::angle() const + inline double AttackMsg::angle() const { - // @@protoc_insertion_point(field_get:protobuf.TrickMsg.angle) + // @@protoc_insertion_point(field_get:protobuf.AttackMsg.angle) return _internal_angle(); } - inline void TrickMsg::_internal_set_angle(double value) + inline void AttackMsg::_internal_set_angle(double value) { _impl_.angle_ = value; } - inline void TrickMsg::set_angle(double value) + inline void AttackMsg::set_angle(double value) { _internal_set_angle(value); - // @@protoc_insertion_point(field_set:protobuf.TrickMsg.angle) + // @@protoc_insertion_point(field_set:protobuf.AttackMsg.angle) } // ------------------------------------------------------------------- @@ -1870,6 +2283,106 @@ namespace protobuf // @@protoc_insertion_point(field_set:protobuf.IDMsg.player_id) } + // .protobuf.PlayerType player_type = 2; + inline void IDMsg::clear_player_type() + { + _impl_.player_type_ = 0; + } + inline ::protobuf::PlayerType IDMsg::_internal_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.player_type_); + } + inline ::protobuf::PlayerType IDMsg::player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.IDMsg.player_type) + return _internal_player_type(); + } + inline void IDMsg::_internal_set_player_type(::protobuf::PlayerType value) + { + _impl_.player_type_ = value; + } + inline void IDMsg::set_player_type(::protobuf::PlayerType value) + { + _internal_set_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.IDMsg.player_type) + } + + // ------------------------------------------------------------------- + + // SkillMsg + + // int64 player_id = 1; + inline void SkillMsg::clear_player_id() + { + _impl_.player_id_ = int64_t{0}; + } + inline int64_t SkillMsg::_internal_player_id() const + { + return _impl_.player_id_; + } + inline int64_t SkillMsg::player_id() const + { + // @@protoc_insertion_point(field_get:protobuf.SkillMsg.player_id) + return _internal_player_id(); + } + inline void SkillMsg::_internal_set_player_id(int64_t value) + { + _impl_.player_id_ = value; + } + inline void SkillMsg::set_player_id(int64_t value) + { + _internal_set_player_id(value); + // @@protoc_insertion_point(field_set:protobuf.SkillMsg.player_id) + } + + // .protobuf.PlayerType player_type = 2; + inline void SkillMsg::clear_player_type() + { + _impl_.player_type_ = 0; + } + inline ::protobuf::PlayerType SkillMsg::_internal_player_type() const + { + return static_cast<::protobuf::PlayerType>(_impl_.player_type_); + } + inline ::protobuf::PlayerType SkillMsg::player_type() const + { + // @@protoc_insertion_point(field_get:protobuf.SkillMsg.player_type) + return _internal_player_type(); + } + inline void SkillMsg::_internal_set_player_type(::protobuf::PlayerType value) + { + _impl_.player_type_ = value; + } + inline void SkillMsg::set_player_type(::protobuf::PlayerType value) + { + _internal_set_player_type(value); + // @@protoc_insertion_point(field_set:protobuf.SkillMsg.player_type) + } + + // int32 skill_id = 3; + inline void SkillMsg::clear_skill_id() + { + _impl_.skill_id_ = 0; + } + inline int32_t SkillMsg::_internal_skill_id() const + { + return _impl_.skill_id_; + } + inline int32_t SkillMsg::skill_id() const + { + // @@protoc_insertion_point(field_get:protobuf.SkillMsg.skill_id) + return _internal_skill_id(); + } + inline void SkillMsg::_internal_set_skill_id(int32_t value) + { + _impl_.skill_id_ = value; + } + inline void SkillMsg::set_skill_id(int32_t value) + { + _internal_set_skill_id(value); + // @@protoc_insertion_point(field_set:protobuf.SkillMsg.skill_id) + } + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -1883,6 +2396,8 @@ namespace protobuf // ------------------------------------------------------------------- + // ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) } // namespace protobuf diff --git a/CAPI/proto/MessageType.pb.cc b/CAPI/cpp/proto/MessageType.pb.cc similarity index 76% rename from CAPI/proto/MessageType.pb.cc rename to CAPI/cpp/proto/MessageType.pb.cc index 7383abf..c29ab8e 100644 --- a/CAPI/proto/MessageType.pb.cc +++ b/CAPI/cpp/proto/MessageType.pb.cc @@ -33,37 +33,40 @@ const char descriptor_table_protodef_MessageType_2eproto[] PROTOBUF_SECTION_VARI "\n\021MessageType.proto\022\010protobuf*{\n\nBulletT" "ype\022\024\n\020NULL_BULLET_TYPE\020\000\022\017\n\013LINE_BULLET" "\020\001\022\021\n\rCOMMON_BULLET\020\002\022\017\n\013FAST_BULLET\020\003\022\023" - "\n\017ORDINARY_BULLET\020\004\022\r\n\tATOM_BOMB\020\005*i\n\tPl" - "aceType\022\023\n\017NULL_PLACE_TYPE\020\000\022\010\n\004LAND\020\001\022\010" - "\n\004WALL\020\002\022\t\n\005GRASS\020\003\022\r\n\tCLASSROOM\020\004\022\010\n\004GA" - "TE\020\005\022\017\n\013HIDDEN_GATE\020\006*8\n\tShapeType\022\023\n\017NU" - "LL_SHAPE_TYPE\020\000\022\n\n\006CIRCLE\020\001\022\n\n\006SQUARE\020\002*" - "N\n\010PropType\022\022\n\016NULL_PROP_TYPE\020\000\022\n\n\006PTYPE" - "1\020\001\022\n\n\006PTYPE2\020\002\022\n\n\006PTYPE3\020\003\022\n\n\006PTYPE4\020\004*" - "f\n\017StudentBuffType\022\023\n\017NULL_SBUFF_TYPE\020\000\022" - "\016\n\nSBUFFTYPE1\020\001\022\016\n\nSBUFFTYPE2\020\002\022\016\n\nSBUFF" - "TYPE3\020\003\022\016\n\nSBUFFTYPE4\020\004*\241\001\n\014StudentState" - "\022\017\n\013NULL_STATUS\020\000\022\010\n\004IDLE\020\001\022\014\n\010LEARNING\020" - "\002\022\014\n\010ADDICTED\020\003\022\010\n\004QUIT\020\004\022\r\n\tGRADUATED\020\005" - "\022\013\n\007TREATED\020\006\022\013\n\007RESCUED\020\007\022\013\n\007STUNNED\020\010\022" - "\014\n\010TREATING\020\t\022\014\n\010RESCUING\020\n*f\n\017TrickerBu" - "ffType\022\023\n\017NULL_TBUFF_TYPE\020\000\022\016\n\nTBUFFTYPE" - "1\020\001\022\016\n\nTBUFFTYPE2\020\002\022\016\n\nTBUFFTYPE3\020\003\022\016\n\nT" - "BUFFTYPE4\020\004*J\n\nPlayerType\022\024\n\020NULL_PLAYER" - "_TYPE\020\000\022\022\n\016STUDENT_PLAYER\020\001\022\022\n\016TRICKER_P" - "LAYER\020\002*l\n\013StudentType\022\025\n\021NULL_STUDENT_T" - "YPE\020\000\022\020\n\014STUDENTTYPE1\020\001\022\020\n\014STUDENTTYPE2\020" - "\002\022\020\n\014STUDENTTYPE3\020\003\022\020\n\014STUDENTTYPE4\020\004*l\n" - "\013TrickerType\022\025\n\021NULL_TRICKER_TYPE\020\000\022\020\n\014T" - "RICKERTYPE1\020\001\022\020\n\014TRICKERTYPE2\020\002\022\020\n\014TRICK" - "ERTYPE3\020\003\022\020\n\014TRICKERTYPE4\020\004*P\n\tGameState" - "\022\023\n\017NULL_GAME_STATE\020\000\022\016\n\nGAME_START\020\001\022\020\n" - "\014GAME_RUNNING\020\002\022\014\n\010GAME_END\020\003b\006proto3"; + "\n\017ORDINARY_BULLET\020\004\022\r\n\tATOM_BOMB\020\005*\212\001\n\tP" + "laceType\022\023\n\017NULL_PLACE_TYPE\020\000\022\010\n\004LAND\020\001\022" + "\010\n\004WALL\020\002\022\t\n\005GRASS\020\003\022\r\n\tCLASSROOM\020\004\022\010\n\004G" + "ATE\020\005\022\017\n\013HIDDEN_GATE\020\006\022\n\n\006WINDOW\020\007\022\010\n\004DO" + "OR\020\010\022\t\n\005CHEST\020\t*8\n\tShapeType\022\023\n\017NULL_SHA" + "PE_TYPE\020\000\022\n\n\006CIRCLE\020\001\022\n\n\006SQUARE\020\002*N\n\010Pro" + "pType\022\022\n\016NULL_PROP_TYPE\020\000\022\n\n\006PTYPE1\020\001\022\n\n" + "\006PTYPE2\020\002\022\n\n\006PTYPE3\020\003\022\n\n\006PTYPE4\020\004*f\n\017Stu" + "dentBuffType\022\023\n\017NULL_SBUFF_TYPE\020\000\022\016\n\nSBU" + "FFTYPE1\020\001\022\016\n\nSBUFFTYPE2\020\002\022\016\n\nSBUFFTYPE3\020" + "\003\022\016\n\nSBUFFTYPE4\020\004*\347\001\n\013PlayerState\022\017\n\013NUL" + "L_STATUS\020\000\022\010\n\004IDLE\020\001\022\014\n\010LEARNING\020\002\022\014\n\010AD" + "DICTED\020\003\022\010\n\004QUIT\020\004\022\r\n\tGRADUATED\020\005\022\013\n\007TRE" + "ATED\020\006\022\013\n\007RESCUED\020\007\022\013\n\007STUNNED\020\010\022\014\n\010TREA" + "TING\020\t\022\014\n\010RESCUING\020\n\022\014\n\010SWINGING\020\013\022\r\n\tAT" + "TACKING\020\014\022\013\n\007LOCKING\020\r\022\r\n\tRUMMAGING\020\016\022\014\n" + "\010CLIMBING\020\017*f\n\017TrickerBuffType\022\023\n\017NULL_T" + "BUFF_TYPE\020\000\022\016\n\nTBUFFTYPE1\020\001\022\016\n\nTBUFFTYPE" + "2\020\002\022\016\n\nTBUFFTYPE3\020\003\022\016\n\nTBUFFTYPE4\020\004*J\n\nP" + "layerType\022\024\n\020NULL_PLAYER_TYPE\020\000\022\022\n\016STUDE" + "NT_PLAYER\020\001\022\022\n\016TRICKER_PLAYER\020\002*l\n\013Stude" + "ntType\022\025\n\021NULL_STUDENT_TYPE\020\000\022\020\n\014STUDENT" + "TYPE1\020\001\022\020\n\014STUDENTTYPE2\020\002\022\020\n\014STUDENTTYPE" + "3\020\003\022\020\n\014STUDENTTYPE4\020\004*l\n\013TrickerType\022\025\n\021" + "NULL_TRICKER_TYPE\020\000\022\020\n\014TRICKERTYPE1\020\001\022\020\n" + "\014TRICKERTYPE2\020\002\022\020\n\014TRICKERTYPE3\020\003\022\020\n\014TRI" + "CKERTYPE4\020\004*P\n\tGameState\022\023\n\017NULL_GAME_ST" + "ATE\020\000\022\016\n\nGAME_START\020\001\022\020\n\014GAME_RUNNING\020\002\022" + "\014\n\010GAME_END\020\003b\006proto3"; static ::_pbi::once_flag descriptor_table_MessageType_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_MessageType_2eproto = { false, false, - 1157, + 1261, descriptor_table_protodef_MessageType_2eproto, "MessageType.proto", &descriptor_table_MessageType_2eproto_once, @@ -123,6 +126,9 @@ namespace protobuf case 4: case 5: case 6: + case 7: + case 8: + case 9: return true; default: return false; @@ -187,12 +193,12 @@ namespace protobuf } } - const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentState_descriptor() + const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayerState_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_MessageType_2eproto); return file_level_enum_descriptors_MessageType_2eproto[5]; } - bool StudentState_IsValid(int value) + bool PlayerState_IsValid(int value) { switch (value) { @@ -207,6 +213,11 @@ namespace protobuf case 8: case 9: case 10: + case 11: + case 12: + case 13: + case 14: + case 15: return true; default: return false; diff --git a/CAPI/proto/MessageType.pb.h b/CAPI/cpp/proto/MessageType.pb.h similarity index 93% rename from CAPI/proto/MessageType.pb.h rename to CAPI/cpp/proto/MessageType.pb.h index dbef341..d85d123 100644 --- a/CAPI/proto/MessageType.pb.h +++ b/CAPI/cpp/proto/MessageType.pb.h @@ -92,12 +92,15 @@ namespace protobuf CLASSROOM = 4, GATE = 5, HIDDEN_GATE = 6, + WINDOW = 7, + DOOR = 8, + CHEST = 9, PlaceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), PlaceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool PlaceType_IsValid(int value); constexpr PlaceType PlaceType_MIN = NULL_PLACE_TYPE; - constexpr PlaceType PlaceType_MAX = HIDDEN_GATE; + constexpr PlaceType PlaceType_MAX = CHEST; constexpr int PlaceType_ARRAYSIZE = PlaceType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlaceType_descriptor(); @@ -211,7 +214,7 @@ namespace protobuf StudentBuffType_descriptor(), name, value ); } - enum StudentState : int + enum PlayerState : int { NULL_STATUS = 0, IDLE = 1, @@ -224,29 +227,34 @@ namespace protobuf STUNNED = 8, TREATING = 9, RESCUING = 10, - StudentState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - StudentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() + SWINGING = 11, + ATTACKING = 12, + LOCKING = 13, + RUMMAGING = 14, + CLIMBING = 15, + PlayerState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + PlayerState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; - bool StudentState_IsValid(int value); - constexpr StudentState StudentState_MIN = NULL_STATUS; - constexpr StudentState StudentState_MAX = RESCUING; - constexpr int StudentState_ARRAYSIZE = StudentState_MAX + 1; + bool PlayerState_IsValid(int value); + constexpr PlayerState PlayerState_MIN = NULL_STATUS; + constexpr PlayerState PlayerState_MAX = CLIMBING; + constexpr int PlayerState_ARRAYSIZE = PlayerState_MAX + 1; - const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StudentState_descriptor(); + const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayerState_descriptor(); template - inline const std::string& StudentState_Name(T enum_t_value) + inline const std::string& PlayerState_Name(T enum_t_value) { - static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function StudentState_Name."); + static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function PlayerState_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - StudentState_descriptor(), enum_t_value + PlayerState_descriptor(), enum_t_value ); } - inline bool StudentState_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StudentState* value + inline bool PlayerState_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayerState* value ) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - StudentState_descriptor(), name, value + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PlayerState_descriptor(), name, value ); } enum TrickerBuffType : int @@ -472,13 +480,13 @@ inline const EnumDescriptor* GetEnumDescriptor<::protobuf::StudentBuffType>() return ::protobuf::StudentBuffType_descriptor(); } template<> -struct is_proto_enum<::protobuf::StudentState> : ::std::true_type +struct is_proto_enum<::protobuf::PlayerState> : ::std::true_type { }; template<> -inline const EnumDescriptor* GetEnumDescriptor<::protobuf::StudentState>() +inline const EnumDescriptor* GetEnumDescriptor<::protobuf::PlayerState>() { - return ::protobuf::StudentState_descriptor(); + return ::protobuf::PlayerState_descriptor(); } template<> struct is_proto_enum<::protobuf::TrickerBuffType> : ::std::true_type diff --git a/CAPI/proto/Services.grpc.pb.cc b/CAPI/cpp/proto/Services.grpc.pb.cc similarity index 58% rename from CAPI/proto/Services.grpc.pb.cc rename to CAPI/cpp/proto/Services.grpc.pb.cc index 78c546f..d2372a9 100644 --- a/CAPI/proto/Services.grpc.pb.cc +++ b/CAPI/cpp/proto/Services.grpc.pb.cc @@ -32,10 +32,16 @@ namespace protobuf "/protobuf.AvailableService/SendMessage", "/protobuf.AvailableService/GetMessage", "/protobuf.AvailableService/StartLearning", - "/protobuf.AvailableService/StartHelpMate", - "/protobuf.AvailableService/StartHealMate", - "/protobuf.AvailableService/Trick", + "/protobuf.AvailableService/StartRescueMate", + "/protobuf.AvailableService/StartTreatMate", + "/protobuf.AvailableService/Attack", "/protobuf.AvailableService/Graduate", + "/protobuf.AvailableService/OpenDoor", + "/protobuf.AvailableService/CloseDoor", + "/protobuf.AvailableService/SkipWindow", + "/protobuf.AvailableService/StartOpenGate", + "/protobuf.AvailableService/StartOpenChest", + "/protobuf.AvailableService/EndAllAction", }; std::unique_ptr AvailableService::NewStub(const std::shared_ptr<::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) @@ -56,10 +62,16 @@ namespace protobuf rpcmethod_SendMessage_(AvailableService_method_names[6], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), rpcmethod_GetMessage_(AvailableService_method_names[7], options.suffix_for_stats(), ::grpc::internal::RpcMethod::SERVER_STREAMING, channel), rpcmethod_StartLearning_(AvailableService_method_names[8], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), - rpcmethod_StartHelpMate_(AvailableService_method_names[9], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), - rpcmethod_StartHealMate_(AvailableService_method_names[10], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), - rpcmethod_Trick_(AvailableService_method_names[11], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), - rpcmethod_Graduate_(AvailableService_method_names[12], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + rpcmethod_StartRescueMate_(AvailableService_method_names[9], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_StartTreatMate_(AvailableService_method_names[10], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_Attack_(AvailableService_method_names[11], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_Graduate_(AvailableService_method_names[12], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_OpenDoor_(AvailableService_method_names[13], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_CloseDoor_(AvailableService_method_names[14], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_SkipWindow_(AvailableService_method_names[15], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_StartOpenGate_(AvailableService_method_names[16], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_StartOpenChest_(AvailableService_method_names[17], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel), + rpcmethod_EndAllAction_(AvailableService_method_names[18], options.suffix_for_stats(), ::grpc::internal::RpcMethod::NORMAL_RPC, channel) { } @@ -139,27 +151,27 @@ namespace protobuf return result; } - ::grpc::Status AvailableService::Stub::PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Stub::PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::protobuf::BoolRes* response) { - return ::grpc::internal::BlockingUnaryCall<::protobuf::PickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PickProp_, context, request, response); + return ::grpc::internal::BlockingUnaryCall<::protobuf::PropMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PickProp_, context, request, response); } - void AvailableService::Stub::async::PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, std::function f) + void AvailableService::Stub::async::PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, std::function f) { - ::grpc::internal::CallbackUnaryCall<::protobuf::PickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PickProp_, context, request, response, std::move(f)); + ::grpc::internal::CallbackUnaryCall<::protobuf::PropMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PickProp_, context, request, response, std::move(f)); } - void AvailableService::Stub::async::PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) + void AvailableService::Stub::async::PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PickProp_, context, request, response, reactor); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::PickMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PickProp_, context, request); + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::PropMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PickProp_, context, request); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncPickPropRaw(context, request, cq); @@ -167,27 +179,27 @@ namespace protobuf return result; } - ::grpc::Status AvailableService::Stub::UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Stub::UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::protobuf::BoolRes* response) { - return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UseProp_, context, request, response); + return ::grpc::internal::BlockingUnaryCall<::protobuf::PropMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UseProp_, context, request, response); } - void AvailableService::Stub::async::UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + void AvailableService::Stub::async::UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, std::function f) { - ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseProp_, context, request, response, std::move(f)); + ::grpc::internal::CallbackUnaryCall<::protobuf::PropMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseProp_, context, request, response, std::move(f)); } - void AvailableService::Stub::async::UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) + void AvailableService::Stub::async::UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseProp_, context, request, response, reactor); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UseProp_, context, request); + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::PropMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UseProp_, context, request); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncUsePropRaw(context, request, cq); @@ -195,27 +207,27 @@ namespace protobuf return result; } - ::grpc::Status AvailableService::Stub::UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Stub::UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::protobuf::BoolRes* response) { - return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UseSkill_, context, request, response); + return ::grpc::internal::BlockingUnaryCall<::protobuf::SkillMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UseSkill_, context, request, response); } - void AvailableService::Stub::async::UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + void AvailableService::Stub::async::UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response, std::function f) { - ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseSkill_, context, request, response, std::move(f)); + ::grpc::internal::CallbackUnaryCall<::protobuf::SkillMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseSkill_, context, request, response, std::move(f)); } - void AvailableService::Stub::async::UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) + void AvailableService::Stub::async::UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) { ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UseSkill_, context, request, response, reactor); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UseSkill_, context, request); + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::SkillMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UseSkill_, context, request); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) { auto* result = this->PrepareAsyncUseSkillRaw(context, request, cq); @@ -299,86 +311,86 @@ namespace protobuf return result; } - ::grpc::Status AvailableService::Stub::StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Stub::StartRescueMate(::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_StartHelpMate_, context, request, response); + return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartRescueMate_, context, request, response); } - void AvailableService::Stub::async::StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + void AvailableService::Stub::async::StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) { - ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartHelpMate_, context, request, response, std::move(f)); + ::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)); } - void AvailableService::Stub::async::StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) + void AvailableService::Stub::async::StartRescueMate(::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_StartHelpMate_, context, request, response, 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::PrepareAsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartRescueMateRaw(::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_StartHelpMate_, context, request); + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartRescueMate_, context, request); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartRescueMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) { auto* result = - this->PrepareAsyncStartHelpMateRaw(context, request, cq); + this->PrepareAsyncStartRescueMateRaw(context, request, cq); result->StartCall(); return result; } - ::grpc::Status AvailableService::Stub::StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Stub::StartTreatMate(::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_StartHealMate_, context, request, response); + return ::grpc::internal::BlockingUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartTreatMate_, context, request, response); } - void AvailableService::Stub::async::StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + void AvailableService::Stub::async::StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) { - ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartHealMate_, context, request, response, std::move(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)); } - void AvailableService::Stub::async::StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) + void AvailableService::Stub::async::StartTreatMate(::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_StartHealMate_, context, request, response, 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::PrepareAsyncStartHealMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartTreatMateRaw(::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_StartHealMate_, context, request); + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::IDMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartTreatMate_, context, request); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartHealMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartTreatMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) { auto* result = - this->PrepareAsyncStartHealMateRaw(context, request, cq); + this->PrepareAsyncStartTreatMateRaw(context, request, cq); result->StartCall(); return result; } - ::grpc::Status AvailableService::Stub::Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Stub::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) { - return ::grpc::internal::BlockingUnaryCall<::protobuf::TrickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Trick_, context, request, response); + return ::grpc::internal::BlockingUnaryCall<::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Attack_, context, request, response); } - void AvailableService::Stub::async::Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, std::function f) + void AvailableService::Stub::async::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function f) { - ::grpc::internal::CallbackUnaryCall<::protobuf::TrickMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Trick_, context, request, response, std::move(f)); + ::grpc::internal::CallbackUnaryCall<::protobuf::AttackMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Attack_, context, request, response, std::move(f)); } - void AvailableService::Stub::async::Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) + void AvailableService::Stub::async::Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) { - ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Trick_, context, request, response, reactor); + ::grpc::internal::ClientCallbackUnaryFactory::Create<::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Attack_, context, request, response, reactor); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::TrickMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Trick_, context, request); + return ::grpc::internal::ClientAsyncResponseReaderHelper::Create<::protobuf::BoolRes, ::protobuf::AttackMsg, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Attack_, context, request); } - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncAttackRaw(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) { auto* result = - this->PrepareAsyncTrickRaw(context, request, cq); + this->PrepareAsyncAttackRaw(context, request, cq); result->StartCall(); return result; } @@ -411,6 +423,174 @@ namespace protobuf return result; } + ::grpc::Status AvailableService::Stub::OpenDoor(::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_OpenDoor_, context, request, response); + } + + void AvailableService::Stub::async::OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + { + ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_OpenDoor_, context, request, response, std::move(f)); + } + + void AvailableService::Stub::async::OpenDoor(::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_OpenDoor_, context, request, response, reactor); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncOpenDoorRaw(::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_OpenDoor_, context, request); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncOpenDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + auto* result = + this->PrepareAsyncOpenDoorRaw(context, request, cq); + result->StartCall(); + return result; + } + + ::grpc::Status AvailableService::Stub::CloseDoor(::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_CloseDoor_, context, request, response); + } + + void AvailableService::Stub::async::CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + { + ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CloseDoor_, context, request, response, std::move(f)); + } + + void AvailableService::Stub::async::CloseDoor(::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_CloseDoor_, context, request, response, reactor); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncCloseDoorRaw(::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_CloseDoor_, context, request); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncCloseDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + auto* result = + this->PrepareAsyncCloseDoorRaw(context, request, cq); + result->StartCall(); + return result; + } + + ::grpc::Status AvailableService::Stub::SkipWindow(::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_SkipWindow_, context, request, response); + } + + void AvailableService::Stub::async::SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + { + ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SkipWindow_, context, request, response, std::move(f)); + } + + void AvailableService::Stub::async::SkipWindow(::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_SkipWindow_, context, request, response, reactor); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncSkipWindowRaw(::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_SkipWindow_, context, request); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncSkipWindowRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + auto* result = + this->PrepareAsyncSkipWindowRaw(context, request, cq); + result->StartCall(); + return result; + } + + ::grpc::Status AvailableService::Stub::StartOpenGate(::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_StartOpenGate_, context, request, response); + } + + void AvailableService::Stub::async::StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + { + ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartOpenGate_, context, request, response, std::move(f)); + } + + void AvailableService::Stub::async::StartOpenGate(::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_StartOpenGate_, context, request, response, reactor); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartOpenGateRaw(::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_StartOpenGate_, context, request); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartOpenGateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + auto* result = + this->PrepareAsyncStartOpenGateRaw(context, request, cq); + result->StartCall(); + return result; + } + + ::grpc::Status AvailableService::Stub::StartOpenChest(::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_StartOpenChest_, context, request, response); + } + + void AvailableService::Stub::async::StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + { + ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartOpenChest_, context, request, response, std::move(f)); + } + + void AvailableService::Stub::async::StartOpenChest(::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_StartOpenChest_, context, request, response, reactor); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncStartOpenChestRaw(::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_StartOpenChest_, context, request); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncStartOpenChestRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + auto* result = + this->PrepareAsyncStartOpenChestRaw(context, request, cq); + result->StartCall(); + return result; + } + + ::grpc::Status AvailableService::Stub::EndAllAction(::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_EndAllAction_, context, request, response); + } + + void AvailableService::Stub::async::EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function f) + { + ::grpc::internal::CallbackUnaryCall<::protobuf::IDMsg, ::protobuf::BoolRes, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EndAllAction_, context, request, response, std::move(f)); + } + + void AvailableService::Stub::async::EndAllAction(::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_EndAllAction_, context, request, response, reactor); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::PrepareAsyncEndAllActionRaw(::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_EndAllAction_, context, request); + } + + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AvailableService::Stub::AsyncEndAllActionRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + auto* result = + this->PrepareAsyncEndAllActionRaw(context, request, cq); + result->StartCall(); + return result; + } + AvailableService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( @@ -458,10 +638,10 @@ namespace protobuf AddMethod(new ::grpc::internal::RpcServiceMethod( AvailableService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler( + new ::grpc::internal::RpcMethodHandler( [](AvailableService::Service* service, ::grpc::ServerContext* ctx, - const ::protobuf::PickMsg* req, + const ::protobuf::PropMsg* req, ::protobuf::BoolRes* resp) { return service->PickProp(ctx, req, resp); @@ -472,10 +652,10 @@ namespace protobuf AddMethod(new ::grpc::internal::RpcServiceMethod( AvailableService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler( + new ::grpc::internal::RpcMethodHandler( [](AvailableService::Service* service, ::grpc::ServerContext* ctx, - const ::protobuf::IDMsg* req, + const ::protobuf::PropMsg* req, ::protobuf::BoolRes* resp) { return service->UseProp(ctx, req, resp); @@ -486,10 +666,10 @@ namespace protobuf AddMethod(new ::grpc::internal::RpcServiceMethod( AvailableService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler( + new ::grpc::internal::RpcMethodHandler( [](AvailableService::Service* service, ::grpc::ServerContext* ctx, - const ::protobuf::IDMsg* req, + const ::protobuf::SkillMsg* req, ::protobuf::BoolRes* resp) { return service->UseSkill(ctx, req, resp); @@ -548,7 +728,7 @@ namespace protobuf const ::protobuf::IDMsg* req, ::protobuf::BoolRes* resp) { - return service->StartHelpMate(ctx, req, resp); + return service->StartRescueMate(ctx, req, resp); }, this ) @@ -562,7 +742,7 @@ namespace protobuf const ::protobuf::IDMsg* req, ::protobuf::BoolRes* resp) { - return service->StartHealMate(ctx, req, resp); + return service->StartTreatMate(ctx, req, resp); }, this ) @@ -570,13 +750,13 @@ namespace protobuf AddMethod(new ::grpc::internal::RpcServiceMethod( AvailableService_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler( + new ::grpc::internal::RpcMethodHandler( [](AvailableService::Service* service, ::grpc::ServerContext* ctx, - const ::protobuf::TrickMsg* req, + const ::protobuf::AttackMsg* req, ::protobuf::BoolRes* resp) { - return service->Trick(ctx, req, resp); + return service->Attack(ctx, req, resp); }, this ) @@ -595,6 +775,90 @@ namespace protobuf this ) )); + AddMethod(new ::grpc::internal::RpcServiceMethod( + AvailableService_method_names[13], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler( + [](AvailableService::Service* service, + ::grpc::ServerContext* ctx, + const ::protobuf::IDMsg* req, + ::protobuf::BoolRes* resp) + { + return service->OpenDoor(ctx, req, resp); + }, + this + ) + )); + AddMethod(new ::grpc::internal::RpcServiceMethod( + AvailableService_method_names[14], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler( + [](AvailableService::Service* service, + ::grpc::ServerContext* ctx, + const ::protobuf::IDMsg* req, + ::protobuf::BoolRes* resp) + { + return service->CloseDoor(ctx, req, resp); + }, + this + ) + )); + AddMethod(new ::grpc::internal::RpcServiceMethod( + AvailableService_method_names[15], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler( + [](AvailableService::Service* service, + ::grpc::ServerContext* ctx, + const ::protobuf::IDMsg* req, + ::protobuf::BoolRes* resp) + { + return service->SkipWindow(ctx, req, resp); + }, + this + ) + )); + AddMethod(new ::grpc::internal::RpcServiceMethod( + AvailableService_method_names[16], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler( + [](AvailableService::Service* service, + ::grpc::ServerContext* ctx, + const ::protobuf::IDMsg* req, + ::protobuf::BoolRes* resp) + { + return service->StartOpenGate(ctx, req, resp); + }, + this + ) + )); + AddMethod(new ::grpc::internal::RpcServiceMethod( + AvailableService_method_names[17], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler( + [](AvailableService::Service* service, + ::grpc::ServerContext* ctx, + const ::protobuf::IDMsg* req, + ::protobuf::BoolRes* resp) + { + return service->StartOpenChest(ctx, req, resp); + }, + this + ) + )); + AddMethod(new ::grpc::internal::RpcServiceMethod( + AvailableService_method_names[18], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler( + [](AvailableService::Service* service, + ::grpc::ServerContext* ctx, + const ::protobuf::IDMsg* req, + ::protobuf::BoolRes* resp) + { + return service->EndAllAction(ctx, req, resp); + }, + this + ) + )); } AvailableService::Service::~Service() @@ -625,7 +889,7 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - ::grpc::Status AvailableService::Service::PickProp(::grpc::ServerContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Service::PickProp(::grpc::ServerContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response) { (void)context; (void)request; @@ -633,7 +897,7 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - ::grpc::Status AvailableService::Service::UseProp(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Service::UseProp(::grpc::ServerContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response) { (void)context; (void)request; @@ -641,7 +905,7 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - ::grpc::Status AvailableService::Service::UseSkill(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Service::UseSkill(::grpc::ServerContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response) { (void)context; (void)request; @@ -673,7 +937,7 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - ::grpc::Status AvailableService::Service::StartHelpMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Service::StartRescueMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) { (void)context; (void)request; @@ -681,7 +945,7 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - ::grpc::Status AvailableService::Service::StartHealMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Service::StartTreatMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) { (void)context; (void)request; @@ -689,7 +953,7 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - ::grpc::Status AvailableService::Service::Trick(::grpc::ServerContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response) + ::grpc::Status AvailableService::Service::Attack(::grpc::ServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response) { (void)context; (void)request; @@ -705,4 +969,52 @@ namespace protobuf return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } + ::grpc::Status AvailableService::Service::OpenDoor(::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::CloseDoor(::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::SkipWindow(::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::StartOpenGate(::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::StartOpenChest(::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::EndAllAction(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { + (void)context; + (void)request; + (void)response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + } // namespace protobuf diff --git a/CAPI/proto/Services.grpc.pb.h b/CAPI/cpp/proto/Services.grpc.pb.h similarity index 60% rename from CAPI/proto/Services.grpc.pb.h rename to CAPI/cpp/proto/Services.grpc.pb.h index 3dfd1f8..04be257 100644 --- a/CAPI/proto/Services.grpc.pb.h +++ b/CAPI/cpp/proto/Services.grpc.pb.h @@ -74,30 +74,30 @@ namespace protobuf { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>>(PrepareAsyncMoveRaw(context, request, cq)); } - virtual ::grpc::Status PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::protobuf::BoolRes* response) = 0; - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) + virtual ::grpc::Status PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncPickPropRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncPickPropRaw(context, request, cq)); } - virtual ::grpc::Status UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + virtual ::grpc::Status UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncUseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncUsePropRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncUseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncUsePropRaw(context, request, cq)); } - virtual ::grpc::Status UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + virtual ::grpc::Status UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncUseSkillRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncUseSkillRaw(context, request, cq)); } @@ -132,33 +132,33 @@ namespace protobuf return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartLearningRaw(context, request, cq)); } // 开始修理机器 - virtual ::grpc::Status StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* 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) { - return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartHelpMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartRescueMateRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartHelpMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartRescueMateRaw(context, request, cq)); } // 开始救人 - virtual ::grpc::Status StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* 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) { - return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartHealMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartTreatMateRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartHealMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartTreatMateRaw(context, request, cq)); } - virtual ::grpc::Status Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::protobuf::BoolRes* response) = 0; - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncTrick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) + virtual ::grpc::Status Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncTrickRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncAttackRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncTrick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncTrickRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncAttackRaw(context, request, cq)); } // 攻击 virtual ::grpc::Status Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; @@ -171,6 +171,65 @@ namespace protobuf return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncGraduateRaw(context, request, cq)); } // 相当于逃跑 + virtual ::grpc::Status OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncOpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncOpenDoorRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncOpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncOpenDoorRaw(context, request, cq)); + } + // 开门 + virtual ::grpc::Status CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncCloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncCloseDoorRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncCloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncCloseDoorRaw(context, request, cq)); + } + // 关门 + virtual ::grpc::Status SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncSkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncSkipWindowRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncSkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncSkipWindowRaw(context, request, cq)); + } + // 窗户 + virtual ::grpc::Status StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartOpenGateRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartOpenGateRaw(context, request, cq)); + } + // 开闸门 + virtual ::grpc::Status StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncStartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncStartOpenChestRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncStartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncStartOpenChestRaw(context, request, cq)); + } + virtual ::grpc::Status EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) = 0; + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> AsyncEndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(AsyncEndAllActionRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>> PrepareAsyncEndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>>(PrepareAsyncEndAllActionRaw(context, request, cq)); + } + // 结束所有动作 class async_interface { public: @@ -185,29 +244,46 @@ namespace protobuf // 游戏过程中玩家执行操作的服务 virtual void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, std::function) = 0; virtual void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; - virtual void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, std::function) = 0; - virtual void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; - virtual void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; - virtual void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; - virtual void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; - virtual void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, std::function) = 0; virtual void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::grpc::ClientReadReactor<::protobuf::MsgRes>* reactor) = 0; virtual void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; virtual void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; // 开始修理机器 - virtual void StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; - virtual void StartHelpMate(::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) = 0; + virtual void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; // 开始救人 - virtual void StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; - virtual void StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; - virtual void Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, std::function) = 0; - virtual void Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; // 攻击 virtual void Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; virtual void Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; // 相当于逃跑 + virtual void OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // 开门 + virtual void CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // 关门 + virtual void SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // 窗户 + virtual void StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // 开闸门 + virtual void StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + virtual void EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) = 0; + virtual void EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) = 0; + // 结束所有动作 }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() @@ -227,12 +303,12 @@ namespace protobuf virtual ::grpc::ClientAsyncReaderInterface<::protobuf::MessageToClient>* PrepareAsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>* AsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::MoveRes>* PrepareAsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface<::protobuf::MsgRes>* GetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request) = 0; @@ -240,14 +316,26 @@ namespace protobuf virtual ::grpc::ClientAsyncReaderInterface<::protobuf::MsgRes>* PrepareAsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& 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>* AsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartHealMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartHealMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& 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>* 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; virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncGraduateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncOpenDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncOpenDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncCloseDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncCloseDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncSkipWindowRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncSkipWindowRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartOpenGateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartOpenGateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncStartOpenChestRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncStartOpenChestRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* AsyncEndAllActionRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface<::protobuf::BoolRes>* PrepareAsyncEndAllActionRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { @@ -283,30 +371,30 @@ namespace protobuf { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>>(PrepareAsyncMoveRaw(context, request, cq)); } - ::grpc::Status PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::protobuf::BoolRes* response) override; - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::Status PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncPickPropRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncPickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncPickPropRaw(context, request, cq)); } - ::grpc::Status UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::Status UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncUseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncUsePropRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncUseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncUseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncUsePropRaw(context, request, cq)); } - ::grpc::Status UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::Status UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncUseSkillRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncUseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncUseSkillRaw(context, request, cq)); } @@ -340,32 +428,32 @@ namespace protobuf { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartLearningRaw(context, request, cq)); } - ::grpc::Status StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* 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) { - return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartHelpMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartRescueMateRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartHelpMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartRescueMateRaw(context, request, cq)); } - ::grpc::Status StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* 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) { - return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartHealMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartTreatMateRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartHealMateRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartTreatMateRaw(context, request, cq)); } - ::grpc::Status Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::protobuf::BoolRes* response) override; - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncTrick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) + ::grpc::Status Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncTrickRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncAttackRaw(context, request, cq)); } - std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncTrick(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncAttack(::grpc::ClientContext* context, const ::protobuf::AttackMsg& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncTrickRaw(context, request, cq)); + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncAttackRaw(context, request, cq)); } ::grpc::Status Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncGraduate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) @@ -376,6 +464,60 @@ namespace protobuf { return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncGraduateRaw(context, request, cq)); } + ::grpc::Status OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncOpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncOpenDoorRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncOpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncOpenDoorRaw(context, request, cq)); + } + ::grpc::Status CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncCloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncCloseDoorRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncCloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncCloseDoorRaw(context, request, cq)); + } + ::grpc::Status SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncSkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncSkipWindowRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncSkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncSkipWindowRaw(context, request, cq)); + } + ::grpc::Status StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartOpenGateRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartOpenGateRaw(context, request, cq)); + } + ::grpc::Status StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncStartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncStartOpenChestRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncStartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncStartOpenChestRaw(context, request, cq)); + } + ::grpc::Status EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::protobuf::BoolRes* response) override; + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> AsyncEndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(AsyncEndAllActionRaw(context, request, cq)); + } + std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>> PrepareAsyncEndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) + { + return std::unique_ptr<::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>>(PrepareAsyncEndAllActionRaw(context, request, cq)); + } class async final : public StubInterface::async_interface { @@ -385,25 +527,37 @@ namespace protobuf void AddPlayer(::grpc::ClientContext* context, const ::protobuf::PlayerMsg* request, ::grpc::ClientReadReactor<::protobuf::MessageToClient>* reactor) override; void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, std::function) override; void Move(::grpc::ClientContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response, ::grpc::ClientUnaryReactor* reactor) override; - void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, std::function) override; - void PickProp(::grpc::ClientContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; - void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; - void UseProp(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; - void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; - void UseSkill(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, std::function) override; + void PickProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, std::function) override; + void UseProp(::grpc::ClientContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response, std::function) override; + void UseSkill(::grpc::ClientContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, std::function) override; void SendMessage(::grpc::ClientContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; void GetMessage(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::grpc::ClientReadReactor<::protobuf::MsgRes>* reactor) override; void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; void StartLearning(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; - void StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; - void StartHelpMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; - void StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; - void StartHealMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; - void Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, std::function) override; - void Trick(::grpc::ClientContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void StartRescueMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) 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) override; + void StartTreatMate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void Attack(::grpc::ClientContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response, std::function) 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) override; void Graduate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; + void OpenDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; + void CloseDoor(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; + void SkipWindow(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; + void StartOpenGate(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; + void StartOpenChest(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; + void EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, std::function) override; + void EndAllAction(::grpc::ClientContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response, ::grpc::ClientUnaryReactor* reactor) override; private: friend class Stub; @@ -435,12 +589,12 @@ namespace protobuf ::grpc::ClientAsyncReader<::protobuf::MessageToClient>* PrepareAsyncAddPlayerRaw(::grpc::ClientContext* context, const ::protobuf::PlayerMsg& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>* AsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader<::protobuf::MoveRes>* PrepareAsyncMoveRaw(::grpc::ClientContext* context, const ::protobuf::MoveMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PickMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncPickPropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncUsePropRaw(::grpc::ClientContext* context, const ::protobuf::PropMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncUseSkillRaw(::grpc::ClientContext* context, const ::protobuf::SkillMsg& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncSendMessageRaw(::grpc::ClientContext* context, const ::protobuf::SendMsg& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader<::protobuf::MsgRes>* GetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request) override; @@ -448,14 +602,26 @@ namespace protobuf ::grpc::ClientAsyncReader<::protobuf::MsgRes>* PrepareAsyncGetMessageRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& 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>* AsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartHelpMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartHealMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartHealMateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncTrickRaw(::grpc::ClientContext* context, const ::protobuf::TrickMsg& 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>* 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; ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncGraduateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncOpenDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncOpenDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncCloseDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncCloseDoorRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncSkipWindowRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncSkipWindowRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartOpenGateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartOpenGateRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncStartOpenChestRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncStartOpenChestRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* AsyncEndAllActionRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader<::protobuf::BoolRes>* PrepareAsyncEndAllActionRaw(::grpc::ClientContext* context, const ::protobuf::IDMsg& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_TryConnection_; const ::grpc::internal::RpcMethod rpcmethod_AddPlayer_; const ::grpc::internal::RpcMethod rpcmethod_Move_; @@ -465,10 +631,16 @@ namespace protobuf const ::grpc::internal::RpcMethod rpcmethod_SendMessage_; const ::grpc::internal::RpcMethod rpcmethod_GetMessage_; const ::grpc::internal::RpcMethod rpcmethod_StartLearning_; - const ::grpc::internal::RpcMethod rpcmethod_StartHelpMate_; - const ::grpc::internal::RpcMethod rpcmethod_StartHealMate_; - const ::grpc::internal::RpcMethod rpcmethod_Trick_; + const ::grpc::internal::RpcMethod rpcmethod_StartRescueMate_; + const ::grpc::internal::RpcMethod rpcmethod_StartTreatMate_; + const ::grpc::internal::RpcMethod rpcmethod_Attack_; const ::grpc::internal::RpcMethod rpcmethod_Graduate_; + const ::grpc::internal::RpcMethod rpcmethod_OpenDoor_; + const ::grpc::internal::RpcMethod rpcmethod_CloseDoor_; + const ::grpc::internal::RpcMethod rpcmethod_SkipWindow_; + const ::grpc::internal::RpcMethod rpcmethod_StartOpenGate_; + const ::grpc::internal::RpcMethod rpcmethod_StartOpenChest_; + const ::grpc::internal::RpcMethod rpcmethod_EndAllAction_; }; static std::unique_ptr NewStub(const std::shared_ptr<::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); @@ -483,20 +655,31 @@ namespace protobuf // 连接上后等待游戏开始，server会定时通过该服务向所有client发送消息。 // 游戏过程中玩家执行操作的服务 virtual ::grpc::Status Move(::grpc::ServerContext* context, const ::protobuf::MoveMsg* request, ::protobuf::MoveRes* response); - virtual ::grpc::Status PickProp(::grpc::ServerContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response); - virtual ::grpc::Status UseProp(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); - virtual ::grpc::Status UseSkill(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + virtual ::grpc::Status PickProp(::grpc::ServerContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response); + virtual ::grpc::Status UseProp(::grpc::ServerContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response); + virtual ::grpc::Status UseSkill(::grpc::ServerContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response); virtual ::grpc::Status SendMessage(::grpc::ServerContext* context, const ::protobuf::SendMsg* request, ::protobuf::BoolRes* response); virtual ::grpc::Status GetMessage(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::grpc::ServerWriter<::protobuf::MsgRes>* writer); virtual ::grpc::Status StartLearning(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); // 开始修理机器 - virtual ::grpc::Status StartHelpMate(::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 StartHealMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); - virtual ::grpc::Status Trick(::grpc::ServerContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response); + virtual ::grpc::Status StartTreatMate(::grpc::ServerContext* context, const ::protobuf::IDMsg* 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); // 相当于逃跑 + virtual ::grpc::Status OpenDoor(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + // 开门 + virtual ::grpc::Status CloseDoor(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + // 关门 + virtual ::grpc::Status SkipWindow(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + // 窗户 + virtual ::grpc::Status StartOpenGate(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + // 开闸门 + virtual ::grpc::Status StartOpenChest(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + virtual ::grpc::Status EndAllAction(::grpc::ServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response); + // 结束所有动作 }; template class WithAsyncMethod_TryConnection : public BaseClass @@ -600,12 +783,12 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPickProp(::grpc::ServerContext* context, ::protobuf::PickMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestPickProp(::grpc::ServerContext* context, ::protobuf::PropMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } @@ -628,12 +811,12 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestUseProp(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestUseProp(::grpc::ServerContext* context, ::protobuf::PropMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } @@ -656,12 +839,12 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestUseSkill(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestUseSkill(::grpc::ServerContext* context, ::protobuf::SkillMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } @@ -751,7 +934,7 @@ namespace protobuf } }; template - class WithAsyncMethod_StartHelpMate : public BaseClass + class WithAsyncMethod_StartRescueMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -759,27 +942,27 @@ namespace protobuf } public: - WithAsyncMethod_StartHelpMate() + WithAsyncMethod_StartRescueMate() { ::grpc::Service::MarkMethodAsync(9); } - ~WithAsyncMethod_StartHelpMate() override + ~WithAsyncMethod_StartRescueMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHelpMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestStartHelpMate(::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::IDMsg* 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); } }; template - class WithAsyncMethod_StartHealMate : public BaseClass + class WithAsyncMethod_StartTreatMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -787,27 +970,27 @@ namespace protobuf } public: - WithAsyncMethod_StartHealMate() + WithAsyncMethod_StartTreatMate() { ::grpc::Service::MarkMethodAsync(10); } - ~WithAsyncMethod_StartHealMate() override + ~WithAsyncMethod_StartTreatMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHealMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestStartHealMate(::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::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_Trick : public BaseClass + class WithAsyncMethod_Attack : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -815,21 +998,21 @@ namespace protobuf } public: - WithAsyncMethod_Trick() + WithAsyncMethod_Attack() { ::grpc::Service::MarkMethodAsync(11); } - ~WithAsyncMethod_Trick() override + ~WithAsyncMethod_Attack() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Trick(::grpc::ServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestTrick(::grpc::ServerContext* context, ::protobuf::TrickMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestAttack(::grpc::ServerContext* context, ::protobuf::AttackMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } @@ -862,7 +1045,175 @@ namespace protobuf ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_TryConnection>>>>>>>>>>>> AsyncService; + template + class WithAsyncMethod_OpenDoor : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithAsyncMethod_OpenDoor() + { + ::grpc::Service::MarkMethodAsync(13); + } + ~WithAsyncMethod_OpenDoor() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status OpenDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestOpenDoor(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_CloseDoor : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithAsyncMethod_CloseDoor() + { + ::grpc::Service::MarkMethodAsync(14); + } + ~WithAsyncMethod_CloseDoor() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CloseDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCloseDoor(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_SkipWindow : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithAsyncMethod_SkipWindow() + { + ::grpc::Service::MarkMethodAsync(15); + } + ~WithAsyncMethod_SkipWindow() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SkipWindow(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSkipWindow(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(15, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StartOpenGate : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithAsyncMethod_StartOpenGate() + { + ::grpc::Service::MarkMethodAsync(16); + } + ~WithAsyncMethod_StartOpenGate() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartOpenGate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartOpenGate(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(16, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_StartOpenChest : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithAsyncMethod_StartOpenChest() + { + ::grpc::Service::MarkMethodAsync(17); + } + ~WithAsyncMethod_StartOpenChest() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartOpenChest(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartOpenChest(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(17, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_EndAllAction : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithAsyncMethod_EndAllAction() + { + ::grpc::Service::MarkMethodAsync(18); + } + ~WithAsyncMethod_EndAllAction() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EndAllAction(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestEndAllAction(::grpc::ServerContext* context, ::protobuf::IDMsg* request, ::grpc::ServerAsyncResponseWriter<::protobuf::BoolRes>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(18, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_TryConnection>>>>>>>>>>>>>>>>>> AsyncService; template class WithCallbackMethod_TryConnection : public BaseClass { @@ -983,15 +1334,15 @@ namespace protobuf public: WithCallbackMethod_PickProp() { - ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler<::protobuf::PickMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::PickMsg* request, ::protobuf::BoolRes* response) + ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler<::protobuf::PropMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response) { return this->PickProp(context, request, response); })); } void SetMessageAllocatorFor_PickProp( - ::grpc::MessageAllocator<::protobuf::PickMsg, ::protobuf::BoolRes>* allocator + ::grpc::MessageAllocator<::protobuf::PropMsg, ::protobuf::BoolRes>* allocator ) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); - static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::PickMsg, ::protobuf::BoolRes>*>(handler) + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::PropMsg, ::protobuf::BoolRes>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_PickProp() override @@ -999,13 +1350,13 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* PickProp( - ::grpc::CallbackServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/ ) { return nullptr; @@ -1022,15 +1373,15 @@ namespace protobuf public: WithCallbackMethod_UseProp() { - ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) - { return this->UseProp(context, request, response); })); + ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler<::protobuf::PropMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::PropMsg* request, ::protobuf::BoolRes* response) + { return this->UseProp(context, request, response); })); } void SetMessageAllocatorFor_UseProp( - ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ::grpc::MessageAllocator<::protobuf::PropMsg, ::protobuf::BoolRes>* allocator ) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); - static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::PropMsg, ::protobuf::BoolRes>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_UseProp() override @@ -1038,13 +1389,13 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* UseProp( - ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/ ) { return nullptr; @@ -1061,15 +1412,15 @@ namespace protobuf public: WithCallbackMethod_UseSkill() { - ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) - { return this->UseSkill(context, request, response); })); + ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler<::protobuf::SkillMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::SkillMsg* request, ::protobuf::BoolRes* response) + { return this->UseSkill(context, request, response); })); } void SetMessageAllocatorFor_UseSkill( - ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ::grpc::MessageAllocator<::protobuf::SkillMsg, ::protobuf::BoolRes>* allocator ) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); - static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::SkillMsg, ::protobuf::BoolRes>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_UseSkill() override @@ -1077,13 +1428,13 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* UseSkill( - ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/ ) { return nullptr; @@ -1199,7 +1550,7 @@ namespace protobuf } }; template - class WithCallbackMethod_StartHelpMate : public BaseClass + class WithCallbackMethod_StartRescueMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1207,12 +1558,12 @@ namespace protobuf } public: - WithCallbackMethod_StartHelpMate() + 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->StartHelpMate(context, request, response); })); + { return this->StartRescueMate(context, request, response); })); } - void SetMessageAllocatorFor_StartHelpMate( + void SetMessageAllocatorFor_StartRescueMate( ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator ) { @@ -1220,17 +1571,17 @@ namespace protobuf static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) ->SetMessageAllocator(allocator); } - ~WithCallbackMethod_StartHelpMate() override + ~WithCallbackMethod_StartRescueMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHelpMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* StartHelpMate( + virtual ::grpc::ServerUnaryReactor* StartRescueMate( ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ ) { @@ -1238,7 +1589,7 @@ namespace protobuf } }; template - class WithCallbackMethod_StartHealMate : public BaseClass + class WithCallbackMethod_StartTreatMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1246,12 +1597,12 @@ namespace protobuf } public: - WithCallbackMethod_StartHealMate() + 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->StartHealMate(context, request, response); })); + { return this->StartTreatMate(context, request, response); })); } - void SetMessageAllocatorFor_StartHealMate( + void SetMessageAllocatorFor_StartTreatMate( ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator ) { @@ -1259,17 +1610,17 @@ namespace protobuf static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) ->SetMessageAllocator(allocator); } - ~WithCallbackMethod_StartHealMate() override + ~WithCallbackMethod_StartTreatMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHealMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* StartHealMate( + virtual ::grpc::ServerUnaryReactor* StartTreatMate( ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ ) { @@ -1277,7 +1628,7 @@ namespace protobuf } }; template - class WithCallbackMethod_Trick : public BaseClass + class WithCallbackMethod_Attack : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1285,31 +1636,31 @@ namespace protobuf } public: - WithCallbackMethod_Trick() + WithCallbackMethod_Attack() { - ::grpc::Service::MarkMethodCallback(11, new ::grpc::internal::CallbackUnaryHandler<::protobuf::TrickMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::TrickMsg* request, ::protobuf::BoolRes* response) - { return this->Trick(context, request, response); })); + ::grpc::Service::MarkMethodCallback(11, new ::grpc::internal::CallbackUnaryHandler<::protobuf::AttackMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::AttackMsg* request, ::protobuf::BoolRes* response) + { return this->Attack(context, request, response); })); } - void SetMessageAllocatorFor_Trick( - ::grpc::MessageAllocator<::protobuf::TrickMsg, ::protobuf::BoolRes>* allocator + void SetMessageAllocatorFor_Attack( + ::grpc::MessageAllocator<::protobuf::AttackMsg, ::protobuf::BoolRes>* allocator ) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(11); - static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::TrickMsg, ::protobuf::BoolRes>*>(handler) + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::AttackMsg, ::protobuf::BoolRes>*>(handler) ->SetMessageAllocator(allocator); } - ~WithCallbackMethod_Trick() override + ~WithCallbackMethod_Attack() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Trick(::grpc::ServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* Trick( - ::grpc::CallbackServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + virtual ::grpc::ServerUnaryReactor* Attack( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/ ) { return nullptr; @@ -1354,10 +1705,8 @@ namespace protobuf return nullptr; } }; - typedef WithCallbackMethod_TryConnection>>>>>>>>>>>> CallbackService; - typedef CallbackService ExperimentalCallbackService; template - class WithGenericMethod_TryConnection : public BaseClass + class WithCallbackMethod_OpenDoor : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1365,23 +1714,38 @@ namespace protobuf } public: - WithGenericMethod_TryConnection() + WithCallbackMethod_OpenDoor() { - ::grpc::Service::MarkMethodGeneric(0); + ::grpc::Service::MarkMethodCallback(13, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { return this->OpenDoor(context, request, response); })); } - ~WithGenericMethod_TryConnection() override + void SetMessageAllocatorFor_OpenDoor( + ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ) + { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(13); + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_OpenDoor() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status TryConnection(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status OpenDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } + virtual ::grpc::ServerUnaryReactor* OpenDoor( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ) + { + return nullptr; + } }; template - class WithGenericMethod_AddPlayer : public BaseClass + class WithCallbackMethod_CloseDoor : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1389,23 +1753,38 @@ namespace protobuf } public: - WithGenericMethod_AddPlayer() + WithCallbackMethod_CloseDoor() { - ::grpc::Service::MarkMethodGeneric(1); + ::grpc::Service::MarkMethodCallback(14, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { return this->CloseDoor(context, request, response); })); } - ~WithGenericMethod_AddPlayer() override + void SetMessageAllocatorFor_CloseDoor( + ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ) + { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(14); + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_CloseDoor() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override + ::grpc::Status CloseDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } + virtual ::grpc::ServerUnaryReactor* CloseDoor( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ) + { + return nullptr; + } }; template - class WithGenericMethod_Move : public BaseClass + class WithCallbackMethod_SkipWindow : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1413,23 +1792,38 @@ namespace protobuf } public: - WithGenericMethod_Move() + WithCallbackMethod_SkipWindow() { - ::grpc::Service::MarkMethodGeneric(2); + ::grpc::Service::MarkMethodCallback(15, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { return this->SkipWindow(context, request, response); })); } - ~WithGenericMethod_Move() override + void SetMessageAllocatorFor_SkipWindow( + ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ) + { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(15); + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_SkipWindow() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override + ::grpc::Status SkipWindow(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } + virtual ::grpc::ServerUnaryReactor* SkipWindow( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ) + { + return nullptr; + } }; template - class WithGenericMethod_PickProp : public BaseClass + class WithCallbackMethod_StartOpenGate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1437,23 +1831,38 @@ namespace protobuf } public: - WithGenericMethod_PickProp() + WithCallbackMethod_StartOpenGate() { - ::grpc::Service::MarkMethodGeneric(3); + ::grpc::Service::MarkMethodCallback(16, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { return this->StartOpenGate(context, request, response); })); } - ~WithGenericMethod_PickProp() override + void SetMessageAllocatorFor_StartOpenGate( + ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ) + { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(16); + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StartOpenGate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartOpenGate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } + virtual ::grpc::ServerUnaryReactor* StartOpenGate( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ) + { + return nullptr; + } }; template - class WithGenericMethod_UseProp : public BaseClass + class WithCallbackMethod_StartOpenChest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1461,21 +1870,197 @@ namespace protobuf } public: - WithGenericMethod_UseProp() + WithCallbackMethod_StartOpenChest() { - ::grpc::Service::MarkMethodGeneric(4); + ::grpc::Service::MarkMethodCallback(17, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { return this->StartOpenChest(context, request, response); })); } - ~WithGenericMethod_UseProp() override + void SetMessageAllocatorFor_StartOpenChest( + ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ) + { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(17); + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_StartOpenChest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartOpenChest(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - }; + virtual ::grpc::ServerUnaryReactor* StartOpenChest( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ) + { + return nullptr; + } + }; + template + class WithCallbackMethod_EndAllAction : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithCallbackMethod_EndAllAction() + { + ::grpc::Service::MarkMethodCallback(18, new ::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::CallbackServerContext* context, const ::protobuf::IDMsg* request, ::protobuf::BoolRes* response) + { return this->EndAllAction(context, request, response); })); + } + void SetMessageAllocatorFor_EndAllAction( + ::grpc::MessageAllocator<::protobuf::IDMsg, ::protobuf::BoolRes>* allocator + ) + { + ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(18); + static_cast<::grpc::internal::CallbackUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>*>(handler) + ->SetMessageAllocator(allocator); + } + ~WithCallbackMethod_EndAllAction() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EndAllAction(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* EndAllAction( + ::grpc::CallbackServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/ + ) + { + return nullptr; + } + }; + typedef WithCallbackMethod_TryConnection>>>>>>>>>>>>>>>>>> CallbackService; + typedef CallbackService ExperimentalCallbackService; + template + class WithGenericMethod_TryConnection : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithGenericMethod_TryConnection() + { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_TryConnection() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status TryConnection(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_AddPlayer : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithGenericMethod_AddPlayer() + { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_AddPlayer() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_Move : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithGenericMethod_Move() + { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_Move() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_PickProp : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithGenericMethod_PickProp() + { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_PickProp() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_UseProp : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithGenericMethod_UseProp() + { + ::grpc::Service::MarkMethodGeneric(4); + } + ~WithGenericMethod_UseProp() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; template class WithGenericMethod_UseSkill : public BaseClass { @@ -1494,7 +2079,7 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); @@ -1573,7 +2158,7 @@ namespace protobuf } }; template - class WithGenericMethod_StartHelpMate : public BaseClass + class WithGenericMethod_StartRescueMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1581,23 +2166,23 @@ namespace protobuf } public: - WithGenericMethod_StartHelpMate() + WithGenericMethod_StartRescueMate() { ::grpc::Service::MarkMethodGeneric(9); } - ~WithGenericMethod_StartHelpMate() override + ~WithGenericMethod_StartRescueMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHelpMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_StartHealMate : public BaseClass + class WithGenericMethod_StartTreatMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1605,23 +2190,23 @@ namespace protobuf } public: - WithGenericMethod_StartHealMate() + WithGenericMethod_StartTreatMate() { ::grpc::Service::MarkMethodGeneric(10); } - ~WithGenericMethod_StartHealMate() override + ~WithGenericMethod_StartTreatMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHealMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_Trick : public BaseClass + class WithGenericMethod_Attack : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1629,16 +2214,16 @@ namespace protobuf } public: - WithGenericMethod_Trick() + WithGenericMethod_Attack() { ::grpc::Service::MarkMethodGeneric(11); } - ~WithGenericMethod_Trick() override + ~WithGenericMethod_Attack() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Trick(::grpc::ServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); @@ -1669,7 +2254,7 @@ namespace protobuf } }; template - class WithRawMethod_TryConnection : public BaseClass + class WithGenericMethod_OpenDoor : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1677,27 +2262,23 @@ namespace protobuf } public: - WithRawMethod_TryConnection() + WithGenericMethod_OpenDoor() { - ::grpc::Service::MarkMethodRaw(0); + ::grpc::Service::MarkMethodGeneric(13); } - ~WithRawMethod_TryConnection() override + ~WithGenericMethod_OpenDoor() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status TryConnection(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status OpenDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestTryConnection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) - { - ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); - } }; template - class WithRawMethod_AddPlayer : public BaseClass + class WithGenericMethod_CloseDoor : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1705,27 +2286,23 @@ namespace protobuf } public: - WithRawMethod_AddPlayer() + WithGenericMethod_CloseDoor() { - ::grpc::Service::MarkMethodRaw(1); + ::grpc::Service::MarkMethodGeneric(14); } - ~WithRawMethod_AddPlayer() override + ~WithGenericMethod_CloseDoor() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override + ::grpc::Status CloseDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestAddPlayer(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter<::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) - { - ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); - } }; template - class WithRawMethod_Move : public BaseClass + class WithGenericMethod_SkipWindow : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1733,27 +2310,23 @@ namespace protobuf } public: - WithRawMethod_Move() + WithGenericMethod_SkipWindow() { - ::grpc::Service::MarkMethodRaw(2); + ::grpc::Service::MarkMethodGeneric(15); } - ~WithRawMethod_Move() override + ~WithGenericMethod_SkipWindow() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override + ::grpc::Status SkipWindow(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestMove(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) - { - ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); - } }; template - class WithRawMethod_PickProp : public BaseClass + class WithGenericMethod_StartOpenGate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1761,27 +2334,23 @@ namespace protobuf } public: - WithRawMethod_PickProp() + WithGenericMethod_StartOpenGate() { - ::grpc::Service::MarkMethodRaw(3); + ::grpc::Service::MarkMethodGeneric(16); } - ~WithRawMethod_PickProp() override + ~WithGenericMethod_StartOpenGate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartOpenGate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPickProp(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) - { - ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); - } }; template - class WithRawMethod_UseProp : public BaseClass + class WithGenericMethod_StartOpenChest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1789,27 +2358,23 @@ namespace protobuf } public: - WithRawMethod_UseProp() + WithGenericMethod_StartOpenChest() { - ::grpc::Service::MarkMethodRaw(4); + ::grpc::Service::MarkMethodGeneric(17); } - ~WithRawMethod_UseProp() override + ~WithGenericMethod_StartOpenChest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartOpenChest(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestUseProp(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) - { - ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); - } }; template - class WithRawMethod_UseSkill : public BaseClass + class WithGenericMethod_EndAllAction : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1817,27 +2382,23 @@ namespace protobuf } public: - WithRawMethod_UseSkill() + WithGenericMethod_EndAllAction() { - ::grpc::Service::MarkMethodRaw(5); + ::grpc::Service::MarkMethodGeneric(18); } - ~WithRawMethod_UseSkill() override + ~WithGenericMethod_EndAllAction() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status EndAllAction(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestUseSkill(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) - { - ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); - } }; template - class WithRawMethod_SendMessage : public BaseClass + class WithRawMethod_TryConnection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1845,27 +2406,27 @@ namespace protobuf } public: - WithRawMethod_SendMessage() + WithRawMethod_TryConnection() { - ::grpc::Service::MarkMethodRaw(6); + ::grpc::Service::MarkMethodRaw(0); } - ~WithRawMethod_SendMessage() override + ~WithRawMethod_TryConnection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status TryConnection(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestSendMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestTryConnection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { - ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_GetMessage : public BaseClass + class WithRawMethod_AddPlayer : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1873,27 +2434,27 @@ namespace protobuf } public: - WithRawMethod_GetMessage() + WithRawMethod_AddPlayer() { - ::grpc::Service::MarkMethodRaw(7); + ::grpc::Service::MarkMethodRaw(1); } - ~WithRawMethod_GetMessage() override + ~WithRawMethod_AddPlayer() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MsgRes>* /*writer*/) override + ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestGetMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter<::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestAddPlayer(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter<::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { - ::grpc::Service::RequestAsyncServerStreaming(7, context, request, writer, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_StartLearning : public BaseClass + class WithRawMethod_Move : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1901,27 +2462,27 @@ namespace protobuf } public: - WithRawMethod_StartLearning() + WithRawMethod_Move() { - ::grpc::Service::MarkMethodRaw(8); + ::grpc::Service::MarkMethodRaw(2); } - ~WithRawMethod_StartLearning() override + ~WithRawMethod_Move() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartLearning(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestStartLearning(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestMove(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { - ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_StartHelpMate : public BaseClass + class WithRawMethod_PickProp : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1929,27 +2490,83 @@ namespace protobuf } public: - WithRawMethod_StartHelpMate() + WithRawMethod_PickProp() { - ::grpc::Service::MarkMethodRaw(9); + ::grpc::Service::MarkMethodRaw(3); } - ~WithRawMethod_StartHelpMate() override + ~WithRawMethod_PickProp() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHelpMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestStartHelpMate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + void RequestPickProp(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) { - ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_StartHealMate : public BaseClass + class WithRawMethod_UseProp : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_UseProp() + { + ::grpc::Service::MarkMethodRaw(4); + } + ~WithRawMethod_UseProp() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUseProp(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_UseSkill : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_UseSkill() + { + ::grpc::Service::MarkMethodRaw(5); + } + ~WithRawMethod_UseSkill() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestUseSkill(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SendMessage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1957,27 +2574,487 @@ namespace protobuf } public: - WithRawMethod_StartHealMate() + WithRawMethod_SendMessage() + { + ::grpc::Service::MarkMethodRaw(6); + } + ~WithRawMethod_SendMessage() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSendMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_GetMessage : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_GetMessage() + { + ::grpc::Service::MarkMethodRaw(7); + } + ~WithRawMethod_GetMessage() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MsgRes>* /*writer*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMessage(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter<::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncServerStreaming(7, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartLearning : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_StartLearning() + { + ::grpc::Service::MarkMethodRaw(8); + } + ~WithRawMethod_StartLearning() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartLearning(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartLearning(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartRescueMate : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_StartRescueMate() + { + ::grpc::Service::MarkMethodRaw(9); + } + ~WithRawMethod_StartRescueMate() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartRescueMate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartTreatMate : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_StartTreatMate() { ::grpc::Service::MarkMethodRaw(10); } - ~WithRawMethod_StartHealMate() override + ~WithRawMethod_StartTreatMate() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartTreatMate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_Attack : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_Attack() + { + ::grpc::Service::MarkMethodRaw(11); + } + ~WithRawMethod_Attack() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAttack(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_Graduate : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_Graduate() + { + ::grpc::Service::MarkMethodRaw(12); + } + ~WithRawMethod_Graduate() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Graduate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGraduate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_OpenDoor : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_OpenDoor() + { + ::grpc::Service::MarkMethodRaw(13); + } + ~WithRawMethod_OpenDoor() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status OpenDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestOpenDoor(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_CloseDoor : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_CloseDoor() + { + ::grpc::Service::MarkMethodRaw(14); + } + ~WithRawMethod_CloseDoor() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CloseDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCloseDoor(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_SkipWindow : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_SkipWindow() + { + ::grpc::Service::MarkMethodRaw(15); + } + ~WithRawMethod_SkipWindow() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SkipWindow(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSkipWindow(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(15, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartOpenGate : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_StartOpenGate() + { + ::grpc::Service::MarkMethodRaw(16); + } + ~WithRawMethod_StartOpenGate() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartOpenGate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartOpenGate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(16, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_StartOpenChest : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_StartOpenChest() + { + ::grpc::Service::MarkMethodRaw(17); + } + ~WithRawMethod_StartOpenChest() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status StartOpenChest(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStartOpenChest(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(17, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_EndAllAction : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawMethod_EndAllAction() + { + ::grpc::Service::MarkMethodRaw(18); + } + ~WithRawMethod_EndAllAction() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status EndAllAction(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestEndAllAction(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + { + ::grpc::Service::RequestAsyncUnary(18, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawCallbackMethod_TryConnection : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawCallbackMethod_TryConnection() + { + ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->TryConnection(context, request, response); })); + } + ~WithRawCallbackMethod_TryConnection() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status TryConnection(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* TryConnection( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ + ) + { + return nullptr; + } + }; + template + class WithRawCallbackMethod_AddPlayer : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawCallbackMethod_AddPlayer() + { + ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackServerStreamingHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request) + { return this->AddPlayer(context, request); })); + } + ~WithRawCallbackMethod_AddPlayer() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerWriteReactor<::grpc::ByteBuffer>* AddPlayer( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/ + ) + { + return nullptr; + } + }; + template + class WithRawCallbackMethod_Move : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawCallbackMethod_Move() + { + ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->Move(context, request, response); })); + } + ~WithRawCallbackMethod_Move() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerUnaryReactor* Move( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ + ) + { + return nullptr; + } + }; + template + class WithRawCallbackMethod_PickProp : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithRawCallbackMethod_PickProp() + { + ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->PickProp(context, request, response); })); + } + ~WithRawCallbackMethod_PickProp() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHealMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestStartHealMate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + virtual ::grpc::ServerUnaryReactor* PickProp( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ + ) { - ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag); + return nullptr; } }; template - class WithRawMethod_Trick : public BaseClass + class WithRawCallbackMethod_UseProp : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -1985,27 +3062,30 @@ namespace protobuf } public: - WithRawMethod_Trick() + WithRawCallbackMethod_UseProp() { - ::grpc::Service::MarkMethodRaw(11); + ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->UseProp(context, request, response); })); } - ~WithRawMethod_Trick() override + ~WithRawCallbackMethod_UseProp() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Trick(::grpc::ServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestTrick(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + virtual ::grpc::ServerUnaryReactor* UseProp( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ + ) { - ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); + return nullptr; } }; template - class WithRawMethod_Graduate : public BaseClass + class WithRawCallbackMethod_UseSkill : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2013,27 +3093,30 @@ namespace protobuf } public: - WithRawMethod_Graduate() + WithRawCallbackMethod_UseSkill() { - ::grpc::Service::MarkMethodRaw(12); + ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->UseSkill(context, request, response); })); } - ~WithRawMethod_Graduate() override + ~WithRawCallbackMethod_UseSkill() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Graduate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestGraduate(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter<::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void* tag) + virtual ::grpc::ServerUnaryReactor* UseSkill( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ + ) { - ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag); + return nullptr; } }; template - class WithRawCallbackMethod_TryConnection : public BaseClass + class WithRawCallbackMethod_SendMessage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2041,22 +3124,22 @@ namespace protobuf } public: - WithRawCallbackMethod_TryConnection() + WithRawCallbackMethod_SendMessage() { - ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->TryConnection(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->SendMessage(context, request, response); })); } - ~WithRawCallbackMethod_TryConnection() override + ~WithRawCallbackMethod_SendMessage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status TryConnection(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* TryConnection( + virtual ::grpc::ServerUnaryReactor* SendMessage( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2064,7 +3147,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_AddPlayer : public BaseClass + class WithRawCallbackMethod_GetMessage : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2072,22 +3155,22 @@ namespace protobuf } public: - WithRawCallbackMethod_AddPlayer() + WithRawCallbackMethod_GetMessage() { - ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackServerStreamingHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request) - { return this->AddPlayer(context, request); })); + ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackServerStreamingHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request) + { return this->GetMessage(context, request); })); } - ~WithRawCallbackMethod_AddPlayer() override + ~WithRawCallbackMethod_GetMessage() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status AddPlayer(::grpc::ServerContext* /*context*/, const ::protobuf::PlayerMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MessageToClient>* /*writer*/) override + ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MsgRes>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerWriteReactor<::grpc::ByteBuffer>* AddPlayer( + virtual ::grpc::ServerWriteReactor<::grpc::ByteBuffer>* GetMessage( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/ ) { @@ -2095,7 +3178,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_Move : public BaseClass + class WithRawCallbackMethod_StartLearning : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2103,22 +3186,22 @@ namespace protobuf } public: - WithRawCallbackMethod_Move() + WithRawCallbackMethod_StartLearning() { - ::grpc::Service::MarkMethodRawCallback(2, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->Move(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->StartLearning(context, request, response); })); } - ~WithRawCallbackMethod_Move() override + ~WithRawCallbackMethod_StartLearning() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Move(::grpc::ServerContext* /*context*/, const ::protobuf::MoveMsg* /*request*/, ::protobuf::MoveRes* /*response*/) override + ::grpc::Status StartLearning(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* Move( + virtual ::grpc::ServerUnaryReactor* StartLearning( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2126,7 +3209,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_PickProp : public BaseClass + class WithRawCallbackMethod_StartRescueMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2134,22 +3217,22 @@ namespace protobuf } public: - WithRawCallbackMethod_PickProp() + WithRawCallbackMethod_StartRescueMate() { - ::grpc::Service::MarkMethodRawCallback(3, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->PickProp(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->StartRescueMate(context, request, response); })); } - ~WithRawCallbackMethod_PickProp() override + ~WithRawCallbackMethod_StartRescueMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* PickProp( + virtual ::grpc::ServerUnaryReactor* StartRescueMate( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2157,7 +3240,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_UseProp : public BaseClass + class WithRawCallbackMethod_StartTreatMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2165,22 +3248,22 @@ namespace protobuf } public: - WithRawCallbackMethod_UseProp() + WithRawCallbackMethod_StartTreatMate() { - ::grpc::Service::MarkMethodRawCallback(4, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->UseProp(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(10, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->StartTreatMate(context, request, response); })); } - ~WithRawCallbackMethod_UseProp() override + ~WithRawCallbackMethod_StartTreatMate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* UseProp( + virtual ::grpc::ServerUnaryReactor* StartTreatMate( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2188,7 +3271,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_UseSkill : public BaseClass + class WithRawCallbackMethod_Attack : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2196,22 +3279,22 @@ namespace protobuf } public: - WithRawCallbackMethod_UseSkill() + WithRawCallbackMethod_Attack() { - ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->UseSkill(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(11, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->Attack(context, request, response); })); } - ~WithRawCallbackMethod_UseSkill() override + ~WithRawCallbackMethod_Attack() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* UseSkill( + virtual ::grpc::ServerUnaryReactor* Attack( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2219,7 +3302,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_SendMessage : public BaseClass + class WithRawCallbackMethod_Graduate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2227,22 +3310,22 @@ namespace protobuf } public: - WithRawCallbackMethod_SendMessage() + WithRawCallbackMethod_Graduate() { - ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->SendMessage(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(12, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->Graduate(context, request, response); })); } - ~WithRawCallbackMethod_SendMessage() override + ~WithRawCallbackMethod_Graduate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendMessage(::grpc::ServerContext* /*context*/, const ::protobuf::SendMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Graduate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* SendMessage( + virtual ::grpc::ServerUnaryReactor* Graduate( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2250,7 +3333,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_GetMessage : public BaseClass + class WithRawCallbackMethod_OpenDoor : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2258,30 +3341,30 @@ namespace protobuf } public: - WithRawCallbackMethod_GetMessage() + WithRawCallbackMethod_OpenDoor() { - ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackServerStreamingHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request) - { return this->GetMessage(context, request); })); + ::grpc::Service::MarkMethodRawCallback(13, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->OpenDoor(context, request, response); })); } - ~WithRawCallbackMethod_GetMessage() override + ~WithRawCallbackMethod_OpenDoor() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetMessage(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::grpc::ServerWriter<::protobuf::MsgRes>* /*writer*/) override + ::grpc::Status OpenDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerWriteReactor<::grpc::ByteBuffer>* GetMessage( - ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/ + virtual ::grpc::ServerUnaryReactor* OpenDoor( + ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { return nullptr; } }; template - class WithRawCallbackMethod_StartLearning : public BaseClass + class WithRawCallbackMethod_CloseDoor : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2289,22 +3372,22 @@ namespace protobuf } public: - WithRawCallbackMethod_StartLearning() + WithRawCallbackMethod_CloseDoor() { - ::grpc::Service::MarkMethodRawCallback(8, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->StartLearning(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(14, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->CloseDoor(context, request, response); })); } - ~WithRawCallbackMethod_StartLearning() override + ~WithRawCallbackMethod_CloseDoor() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartLearning(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status CloseDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* StartLearning( + virtual ::grpc::ServerUnaryReactor* CloseDoor( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2312,7 +3395,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_StartHelpMate : public BaseClass + class WithRawCallbackMethod_SkipWindow : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2320,22 +3403,22 @@ namespace protobuf } public: - WithRawCallbackMethod_StartHelpMate() + WithRawCallbackMethod_SkipWindow() { - ::grpc::Service::MarkMethodRawCallback(9, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->StartHelpMate(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(15, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->SkipWindow(context, request, response); })); } - ~WithRawCallbackMethod_StartHelpMate() override + ~WithRawCallbackMethod_SkipWindow() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHelpMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status SkipWindow(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* StartHelpMate( + virtual ::grpc::ServerUnaryReactor* SkipWindow( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2343,7 +3426,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_StartHealMate : public BaseClass + class WithRawCallbackMethod_StartOpenGate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2351,22 +3434,22 @@ namespace protobuf } public: - WithRawCallbackMethod_StartHealMate() + WithRawCallbackMethod_StartOpenGate() { - ::grpc::Service::MarkMethodRawCallback(10, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->StartHealMate(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(16, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->StartOpenGate(context, request, response); })); } - ~WithRawCallbackMethod_StartHealMate() override + ~WithRawCallbackMethod_StartOpenGate() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status StartHealMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartOpenGate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* StartHealMate( + virtual ::grpc::ServerUnaryReactor* StartOpenGate( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2374,7 +3457,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_Trick : public BaseClass + class WithRawCallbackMethod_StartOpenChest : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2382,22 +3465,22 @@ namespace protobuf } public: - WithRawCallbackMethod_Trick() + WithRawCallbackMethod_StartOpenChest() { - ::grpc::Service::MarkMethodRawCallback(11, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->Trick(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(17, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->StartOpenChest(context, request, response); })); } - ~WithRawCallbackMethod_Trick() override + ~WithRawCallbackMethod_StartOpenChest() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Trick(::grpc::ServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartOpenChest(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* Trick( + virtual ::grpc::ServerUnaryReactor* StartOpenChest( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2405,7 +3488,7 @@ namespace protobuf } }; template - class WithRawCallbackMethod_Graduate : public BaseClass + class WithRawCallbackMethod_EndAllAction : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2413,22 +3496,22 @@ namespace protobuf } public: - WithRawCallbackMethod_Graduate() + WithRawCallbackMethod_EndAllAction() { - ::grpc::Service::MarkMethodRawCallback(12, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) - { return this->Graduate(context, request, response); })); + ::grpc::Service::MarkMethodRawCallback(18, new ::grpc::internal::CallbackUnaryHandler<::grpc::ByteBuffer, ::grpc::ByteBuffer>([this](::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) + { return this->EndAllAction(context, request, response); })); } - ~WithRawCallbackMethod_Graduate() override + ~WithRawCallbackMethod_EndAllAction() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Graduate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status EndAllAction(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* Graduate( + virtual ::grpc::ServerUnaryReactor* EndAllAction( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/ ) { @@ -2500,7 +3583,7 @@ namespace protobuf public: WithStreamedUnaryMethod_PickProp() { - ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler<::protobuf::PickMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PickMsg, ::protobuf::BoolRes>* streamer) + ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler<::protobuf::PropMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PropMsg, ::protobuf::BoolRes>* streamer) { return this->StreamedPickProp(context, streamer); })); } ~WithStreamedUnaryMethod_PickProp() override @@ -2508,13 +3591,13 @@ namespace protobuf BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status PickProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedPickProp(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PickMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedPickProp(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PropMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_UseProp : public BaseClass @@ -2527,21 +3610,21 @@ namespace protobuf public: WithStreamedUnaryMethod_UseProp() { - ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) - { return this->StreamedUseProp(context, streamer); })); + ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler<::protobuf::PropMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PropMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedUseProp(context, streamer); })); } ~WithStreamedUnaryMethod_UseProp() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseProp(::grpc::ServerContext* /*context*/, const ::protobuf::PropMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedUseProp(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedUseProp(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::PropMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_UseSkill : public BaseClass @@ -2554,21 +3637,21 @@ namespace protobuf public: WithStreamedUnaryMethod_UseSkill() { - ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) - { return this->StreamedUseSkill(context, streamer); })); + ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler<::protobuf::SkillMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::SkillMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedUseSkill(context, streamer); })); } ~WithStreamedUnaryMethod_UseSkill() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status UseSkill(::grpc::ServerContext* /*context*/, const ::protobuf::SkillMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedUseSkill(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedUseSkill(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::SkillMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SendMessage : public BaseClass @@ -2625,7 +3708,7 @@ namespace protobuf virtual ::grpc::Status StreamedStartLearning(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_StartHelpMate : public BaseClass + class WithStreamedUnaryMethod_StartRescueMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2633,26 +3716,26 @@ namespace protobuf } public: - WithStreamedUnaryMethod_StartHelpMate() + 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->StreamedStartHelpMate(context, streamer); })); + { return this->StreamedStartRescueMate(context, streamer); })); } - ~WithStreamedUnaryMethod_StartHelpMate() override + ~WithStreamedUnaryMethod_StartRescueMate() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status StartHelpMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartRescueMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedStartHelpMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedStartRescueMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_StartHealMate : public BaseClass + class WithStreamedUnaryMethod_StartTreatMate : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2660,26 +3743,26 @@ namespace protobuf } public: - WithStreamedUnaryMethod_StartHealMate() + 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->StreamedStartHealMate(context, streamer); })); + { return this->StreamedStartTreatMate(context, streamer); })); } - ~WithStreamedUnaryMethod_StartHealMate() override + ~WithStreamedUnaryMethod_StartTreatMate() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status StartHealMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status StartTreatMate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedStartHealMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedStartTreatMate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_Trick : public BaseClass + class WithStreamedUnaryMethod_Attack : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) @@ -2687,23 +3770,23 @@ namespace protobuf } public: - WithStreamedUnaryMethod_Trick() + WithStreamedUnaryMethod_Attack() { - ::grpc::Service::MarkMethodStreamed(11, new ::grpc::internal::StreamedUnaryHandler<::protobuf::TrickMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::TrickMsg, ::protobuf::BoolRes>* streamer) - { return this->StreamedTrick(context, streamer); })); + ::grpc::Service::MarkMethodStreamed(11, new ::grpc::internal::StreamedUnaryHandler<::protobuf::AttackMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::AttackMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedAttack(context, streamer); })); } - ~WithStreamedUnaryMethod_Trick() override + ~WithStreamedUnaryMethod_Attack() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status Trick(::grpc::ServerContext* /*context*/, const ::protobuf::TrickMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + ::grpc::Status Attack(::grpc::ServerContext* /*context*/, const ::protobuf::AttackMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedTrick(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::TrickMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedAttack(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::AttackMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Graduate : public BaseClass @@ -2732,7 +3815,169 @@ namespace protobuf // replace default version of method with streamed unary virtual ::grpc::Status StreamedGraduate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_TryConnection>>>>>>>>>> StreamedUnaryService; + template + class WithStreamedUnaryMethod_OpenDoor : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithStreamedUnaryMethod_OpenDoor() + { + ::grpc::Service::MarkMethodStreamed(13, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedOpenDoor(context, streamer); })); + } + ~WithStreamedUnaryMethod_OpenDoor() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status OpenDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedOpenDoor(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_CloseDoor : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithStreamedUnaryMethod_CloseDoor() + { + ::grpc::Service::MarkMethodStreamed(14, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedCloseDoor(context, streamer); })); + } + ~WithStreamedUnaryMethod_CloseDoor() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status CloseDoor(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedCloseDoor(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_SkipWindow : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithStreamedUnaryMethod_SkipWindow() + { + ::grpc::Service::MarkMethodStreamed(15, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedSkipWindow(context, streamer); })); + } + ~WithStreamedUnaryMethod_SkipWindow() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SkipWindow(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSkipWindow(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_StartOpenGate : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithStreamedUnaryMethod_StartOpenGate() + { + ::grpc::Service::MarkMethodStreamed(16, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedStartOpenGate(context, streamer); })); + } + ~WithStreamedUnaryMethod_StartOpenGate() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StartOpenGate(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStartOpenGate(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_StartOpenChest : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithStreamedUnaryMethod_StartOpenChest() + { + ::grpc::Service::MarkMethodStreamed(17, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedStartOpenChest(context, streamer); })); + } + ~WithStreamedUnaryMethod_StartOpenChest() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status StartOpenChest(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStartOpenChest(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_EndAllAction : public BaseClass + { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) + { + } + + public: + WithStreamedUnaryMethod_EndAllAction() + { + ::grpc::Service::MarkMethodStreamed(18, new ::grpc::internal::StreamedUnaryHandler<::protobuf::IDMsg, ::protobuf::BoolRes>([this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* streamer) + { return this->StreamedEndAllAction(context, streamer); })); + } + ~WithStreamedUnaryMethod_EndAllAction() override + { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status EndAllAction(::grpc::ServerContext* /*context*/, const ::protobuf::IDMsg* /*request*/, ::protobuf::BoolRes* /*response*/) override + { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedEndAllAction(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer<::protobuf::IDMsg, ::protobuf::BoolRes>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_TryConnection>>>>>>>>>>>>>>>> StreamedUnaryService; template class WithSplitStreamingMethod_AddPlayer : public BaseClass { @@ -2788,7 +4033,7 @@ namespace protobuf virtual ::grpc::Status StreamedGetMessage(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer<::protobuf::IDMsg, ::protobuf::MsgRes>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_AddPlayer> SplitStreamedService; - typedef WithStreamedUnaryMethod_TryConnection>>>>>>>>>>>> StreamedService; + typedef WithStreamedUnaryMethod_TryConnection>>>>>>>>>>>>>>>>>> StreamedService; }; } // namespace protobuf diff --git a/CAPI/proto/Services.pb.cc b/CAPI/cpp/proto/Services.pb.cc similarity index 93% rename from CAPI/proto/Services.pb.cc rename to CAPI/cpp/proto/Services.pb.cc index 32afa86..11e1aa4 100644 --- a/CAPI/proto/Services.pb.cc +++ b/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\262\007\n\020Avai" + "nts.proto\032\024Message2Server.proto2\350\007\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" @@ -54,8 +54,10 @@ const char descriptor_table_protodef_Services_2eproto[] PROTOBUF_SECTION_VARIABL ".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\0222\n\014EndAllAction\022\017.protobuf.IDMs" - "g\032\021.protobuf.BoolResb\006proto3"; + ".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"; static const ::_pbi::DescriptorTable* const descriptor_table_Services_2eproto_deps[2] = { &::descriptor_table_Message2Clients_2eproto, &::descriptor_table_Message2Server_2eproto, @@ -64,7 +66,7 @@ static ::_pbi::once_flag descriptor_table_Services_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_Services_2eproto = { false, false, - 1028, + 1082, descriptor_table_protodef_Services_2eproto, "Services.proto", &descriptor_table_Services_2eproto_once, diff --git a/CAPI/proto/Services.pb.h b/CAPI/cpp/proto/Services.pb.h similarity index 100% rename from CAPI/proto/Services.pb.h rename to CAPI/cpp/proto/Services.pb.h diff --git a/CAPI/spdlog/include/spdlog/async.h b/CAPI/cpp/spdlog/include/spdlog/async.h similarity index 100% rename from CAPI/spdlog/include/spdlog/async.h rename to CAPI/cpp/spdlog/include/spdlog/async.h diff --git a/CAPI/spdlog/include/spdlog/async_logger-inl.h b/CAPI/cpp/spdlog/include/spdlog/async_logger-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/async_logger-inl.h rename to CAPI/cpp/spdlog/include/spdlog/async_logger-inl.h diff --git a/CAPI/spdlog/include/spdlog/async_logger.h b/CAPI/cpp/spdlog/include/spdlog/async_logger.h similarity index 100% rename from CAPI/spdlog/include/spdlog/async_logger.h rename to CAPI/cpp/spdlog/include/spdlog/async_logger.h diff --git a/CAPI/spdlog/include/spdlog/cfg/argv.h b/CAPI/cpp/spdlog/include/spdlog/cfg/argv.h similarity index 100% rename from CAPI/spdlog/include/spdlog/cfg/argv.h rename to CAPI/cpp/spdlog/include/spdlog/cfg/argv.h diff --git a/CAPI/spdlog/include/spdlog/cfg/env.h b/CAPI/cpp/spdlog/include/spdlog/cfg/env.h similarity index 100% rename from CAPI/spdlog/include/spdlog/cfg/env.h rename to CAPI/cpp/spdlog/include/spdlog/cfg/env.h diff --git a/CAPI/spdlog/include/spdlog/cfg/helpers-inl.h b/CAPI/cpp/spdlog/include/spdlog/cfg/helpers-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/cfg/helpers-inl.h rename to CAPI/cpp/spdlog/include/spdlog/cfg/helpers-inl.h diff --git a/CAPI/spdlog/include/spdlog/cfg/helpers.h b/CAPI/cpp/spdlog/include/spdlog/cfg/helpers.h similarity index 100% rename from CAPI/spdlog/include/spdlog/cfg/helpers.h rename to CAPI/cpp/spdlog/include/spdlog/cfg/helpers.h diff --git a/CAPI/spdlog/include/spdlog/common-inl.h b/CAPI/cpp/spdlog/include/spdlog/common-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/common-inl.h rename to CAPI/cpp/spdlog/include/spdlog/common-inl.h diff --git a/CAPI/spdlog/include/spdlog/common.h b/CAPI/cpp/spdlog/include/spdlog/common.h similarity index 100% rename from CAPI/spdlog/include/spdlog/common.h rename to CAPI/cpp/spdlog/include/spdlog/common.h diff --git a/CAPI/spdlog/include/spdlog/details/backtracer-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/backtracer-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/backtracer-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/backtracer-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/backtracer.h b/CAPI/cpp/spdlog/include/spdlog/details/backtracer.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/backtracer.h rename to CAPI/cpp/spdlog/include/spdlog/details/backtracer.h diff --git a/CAPI/spdlog/include/spdlog/details/circular_q.h b/CAPI/cpp/spdlog/include/spdlog/details/circular_q.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/circular_q.h rename to CAPI/cpp/spdlog/include/spdlog/details/circular_q.h diff --git a/CAPI/spdlog/include/spdlog/details/console_globals.h b/CAPI/cpp/spdlog/include/spdlog/details/console_globals.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/console_globals.h rename to CAPI/cpp/spdlog/include/spdlog/details/console_globals.h diff --git a/CAPI/spdlog/include/spdlog/details/file_helper-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/file_helper-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/file_helper-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/file_helper-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/file_helper.h b/CAPI/cpp/spdlog/include/spdlog/details/file_helper.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/file_helper.h rename to CAPI/cpp/spdlog/include/spdlog/details/file_helper.h diff --git a/CAPI/spdlog/include/spdlog/details/fmt_helper.h b/CAPI/cpp/spdlog/include/spdlog/details/fmt_helper.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/fmt_helper.h rename to CAPI/cpp/spdlog/include/spdlog/details/fmt_helper.h diff --git a/CAPI/spdlog/include/spdlog/details/log_msg-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/log_msg-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/log_msg-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/log_msg-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/log_msg.h b/CAPI/cpp/spdlog/include/spdlog/details/log_msg.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/log_msg.h rename to CAPI/cpp/spdlog/include/spdlog/details/log_msg.h diff --git a/CAPI/spdlog/include/spdlog/details/log_msg_buffer-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/log_msg_buffer-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/log_msg_buffer-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/log_msg_buffer-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/log_msg_buffer.h b/CAPI/cpp/spdlog/include/spdlog/details/log_msg_buffer.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/log_msg_buffer.h rename to CAPI/cpp/spdlog/include/spdlog/details/log_msg_buffer.h diff --git a/CAPI/spdlog/include/spdlog/details/mpmc_blocking_q.h b/CAPI/cpp/spdlog/include/spdlog/details/mpmc_blocking_q.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/mpmc_blocking_q.h rename to CAPI/cpp/spdlog/include/spdlog/details/mpmc_blocking_q.h diff --git a/CAPI/spdlog/include/spdlog/details/null_mutex.h b/CAPI/cpp/spdlog/include/spdlog/details/null_mutex.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/null_mutex.h rename to CAPI/cpp/spdlog/include/spdlog/details/null_mutex.h diff --git a/CAPI/spdlog/include/spdlog/details/os-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/os-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/os-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/os-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/os.h b/CAPI/cpp/spdlog/include/spdlog/details/os.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/os.h rename to CAPI/cpp/spdlog/include/spdlog/details/os.h diff --git a/CAPI/spdlog/include/spdlog/details/periodic_worker-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/periodic_worker-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/periodic_worker-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/periodic_worker-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/periodic_worker.h b/CAPI/cpp/spdlog/include/spdlog/details/periodic_worker.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/periodic_worker.h rename to CAPI/cpp/spdlog/include/spdlog/details/periodic_worker.h diff --git a/CAPI/spdlog/include/spdlog/details/registry-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/registry-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/registry-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/registry-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/registry.h b/CAPI/cpp/spdlog/include/spdlog/details/registry.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/registry.h rename to CAPI/cpp/spdlog/include/spdlog/details/registry.h diff --git a/CAPI/spdlog/include/spdlog/details/synchronous_factory.h b/CAPI/cpp/spdlog/include/spdlog/details/synchronous_factory.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/synchronous_factory.h rename to CAPI/cpp/spdlog/include/spdlog/details/synchronous_factory.h diff --git a/CAPI/spdlog/include/spdlog/details/tcp_client-windows.h b/CAPI/cpp/spdlog/include/spdlog/details/tcp_client-windows.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/tcp_client-windows.h rename to CAPI/cpp/spdlog/include/spdlog/details/tcp_client-windows.h diff --git a/CAPI/spdlog/include/spdlog/details/tcp_client.h b/CAPI/cpp/spdlog/include/spdlog/details/tcp_client.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/tcp_client.h rename to CAPI/cpp/spdlog/include/spdlog/details/tcp_client.h diff --git a/CAPI/spdlog/include/spdlog/details/thread_pool-inl.h b/CAPI/cpp/spdlog/include/spdlog/details/thread_pool-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/thread_pool-inl.h rename to CAPI/cpp/spdlog/include/spdlog/details/thread_pool-inl.h diff --git a/CAPI/spdlog/include/spdlog/details/thread_pool.h b/CAPI/cpp/spdlog/include/spdlog/details/thread_pool.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/thread_pool.h rename to CAPI/cpp/spdlog/include/spdlog/details/thread_pool.h diff --git a/CAPI/spdlog/include/spdlog/details/udp_client-windows.h b/CAPI/cpp/spdlog/include/spdlog/details/udp_client-windows.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/udp_client-windows.h rename to CAPI/cpp/spdlog/include/spdlog/details/udp_client-windows.h diff --git a/CAPI/spdlog/include/spdlog/details/udp_client.h b/CAPI/cpp/spdlog/include/spdlog/details/udp_client.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/udp_client.h rename to CAPI/cpp/spdlog/include/spdlog/details/udp_client.h diff --git a/CAPI/spdlog/include/spdlog/details/windows_include.h b/CAPI/cpp/spdlog/include/spdlog/details/windows_include.h similarity index 100% rename from CAPI/spdlog/include/spdlog/details/windows_include.h rename to CAPI/cpp/spdlog/include/spdlog/details/windows_include.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bin_to_hex.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bin_to_hex.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bin_to_hex.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bin_to_hex.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/args.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/args.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/args.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/args.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/chrono.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/chrono.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/chrono.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/chrono.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/color.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/color.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/color.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/color.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/compile.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/compile.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/compile.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/compile.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/core.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/core.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/core.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/core.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/fmt.license.rst b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/fmt.license.rst similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/fmt.license.rst rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/fmt.license.rst diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/format-inl.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/format-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/format-inl.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/format-inl.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/format.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/format.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/format.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/format.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/locale.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/locale.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/locale.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/locale.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/os.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/os.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/os.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/os.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/ostream.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/ostream.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/ostream.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/ostream.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/printf.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/printf.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/printf.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/printf.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/ranges.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/ranges.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/ranges.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/ranges.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/std.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/std.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/std.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/std.h diff --git a/CAPI/spdlog/include/spdlog/fmt/bundled/xchar.h b/CAPI/cpp/spdlog/include/spdlog/fmt/bundled/xchar.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/bundled/xchar.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/bundled/xchar.h diff --git a/CAPI/spdlog/include/spdlog/fmt/chrono.h b/CAPI/cpp/spdlog/include/spdlog/fmt/chrono.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/chrono.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/chrono.h diff --git a/CAPI/spdlog/include/spdlog/fmt/compile.h b/CAPI/cpp/spdlog/include/spdlog/fmt/compile.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/compile.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/compile.h diff --git a/CAPI/spdlog/include/spdlog/fmt/fmt.h b/CAPI/cpp/spdlog/include/spdlog/fmt/fmt.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/fmt.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/fmt.h diff --git a/CAPI/spdlog/include/spdlog/fmt/ostr.h b/CAPI/cpp/spdlog/include/spdlog/fmt/ostr.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/ostr.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/ostr.h diff --git a/CAPI/spdlog/include/spdlog/fmt/ranges.h b/CAPI/cpp/spdlog/include/spdlog/fmt/ranges.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/ranges.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/ranges.h diff --git a/CAPI/spdlog/include/spdlog/fmt/std.h b/CAPI/cpp/spdlog/include/spdlog/fmt/std.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/std.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/std.h diff --git a/CAPI/spdlog/include/spdlog/fmt/xchar.h b/CAPI/cpp/spdlog/include/spdlog/fmt/xchar.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fmt/xchar.h rename to CAPI/cpp/spdlog/include/spdlog/fmt/xchar.h diff --git a/CAPI/spdlog/include/spdlog/formatter.h b/CAPI/cpp/spdlog/include/spdlog/formatter.h similarity index 100% rename from CAPI/spdlog/include/spdlog/formatter.h rename to CAPI/cpp/spdlog/include/spdlog/formatter.h diff --git a/CAPI/spdlog/include/spdlog/fwd.h b/CAPI/cpp/spdlog/include/spdlog/fwd.h similarity index 100% rename from CAPI/spdlog/include/spdlog/fwd.h rename to CAPI/cpp/spdlog/include/spdlog/fwd.h diff --git a/CAPI/spdlog/include/spdlog/logger-inl.h b/CAPI/cpp/spdlog/include/spdlog/logger-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/logger-inl.h rename to CAPI/cpp/spdlog/include/spdlog/logger-inl.h diff --git a/CAPI/spdlog/include/spdlog/logger.h b/CAPI/cpp/spdlog/include/spdlog/logger.h similarity index 100% rename from CAPI/spdlog/include/spdlog/logger.h rename to CAPI/cpp/spdlog/include/spdlog/logger.h diff --git a/CAPI/spdlog/include/spdlog/pattern_formatter-inl.h b/CAPI/cpp/spdlog/include/spdlog/pattern_formatter-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/pattern_formatter-inl.h rename to CAPI/cpp/spdlog/include/spdlog/pattern_formatter-inl.h diff --git a/CAPI/spdlog/include/spdlog/pattern_formatter.h b/CAPI/cpp/spdlog/include/spdlog/pattern_formatter.h similarity index 100% rename from CAPI/spdlog/include/spdlog/pattern_formatter.h rename to CAPI/cpp/spdlog/include/spdlog/pattern_formatter.h diff --git a/CAPI/spdlog/include/spdlog/sinks/android_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/android_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/android_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/android_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/ansicolor_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/ansicolor_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/ansicolor_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/ansicolor_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/base_sink-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/base_sink-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/base_sink-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/base_sink-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/base_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/base_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/base_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/base_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/basic_file_sink-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/basic_file_sink-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/basic_file_sink-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/basic_file_sink-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/basic_file_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/basic_file_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/basic_file_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/basic_file_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/daily_file_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/daily_file_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/daily_file_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/daily_file_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/dist_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/dist_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/dist_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/dist_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/dup_filter_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/dup_filter_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/dup_filter_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/dup_filter_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/hourly_file_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/hourly_file_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/hourly_file_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/hourly_file_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/mongo_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/mongo_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/mongo_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/mongo_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/msvc_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/msvc_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/msvc_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/msvc_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/null_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/null_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/null_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/null_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/ostream_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/ostream_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/ostream_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/ostream_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/qt_sinks.h b/CAPI/cpp/spdlog/include/spdlog/sinks/qt_sinks.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/qt_sinks.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/qt_sinks.h diff --git a/CAPI/spdlog/include/spdlog/sinks/ringbuffer_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/ringbuffer_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/ringbuffer_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/ringbuffer_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/rotating_file_sink-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/rotating_file_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/rotating_file_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/rotating_file_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/rotating_file_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/sink-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/sink-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/sink-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/sink-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/stdout_color_sinks.h b/CAPI/cpp/spdlog/include/spdlog/sinks/stdout_color_sinks.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/stdout_color_sinks.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/stdout_color_sinks.h diff --git a/CAPI/spdlog/include/spdlog/sinks/stdout_sinks-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/stdout_sinks-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/stdout_sinks-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/stdout_sinks-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/stdout_sinks.h b/CAPI/cpp/spdlog/include/spdlog/sinks/stdout_sinks.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/stdout_sinks.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/stdout_sinks.h diff --git a/CAPI/spdlog/include/spdlog/sinks/syslog_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/syslog_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/syslog_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/syslog_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/systemd_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/systemd_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/systemd_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/systemd_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/tcp_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/tcp_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/tcp_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/tcp_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/udp_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/udp_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/udp_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/udp_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/win_eventlog_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/win_eventlog_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/win_eventlog_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/win_eventlog_sink.h diff --git a/CAPI/spdlog/include/spdlog/sinks/wincolor_sink-inl.h b/CAPI/cpp/spdlog/include/spdlog/sinks/wincolor_sink-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/wincolor_sink-inl.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/wincolor_sink-inl.h diff --git a/CAPI/spdlog/include/spdlog/sinks/wincolor_sink.h b/CAPI/cpp/spdlog/include/spdlog/sinks/wincolor_sink.h similarity index 100% rename from CAPI/spdlog/include/spdlog/sinks/wincolor_sink.h rename to CAPI/cpp/spdlog/include/spdlog/sinks/wincolor_sink.h diff --git a/CAPI/spdlog/include/spdlog/spdlog-inl.h b/CAPI/cpp/spdlog/include/spdlog/spdlog-inl.h similarity index 100% rename from CAPI/spdlog/include/spdlog/spdlog-inl.h rename to CAPI/cpp/spdlog/include/spdlog/spdlog-inl.h diff --git a/CAPI/spdlog/include/spdlog/spdlog.h b/CAPI/cpp/spdlog/include/spdlog/spdlog.h similarity index 100% rename from CAPI/spdlog/include/spdlog/spdlog.h rename to CAPI/cpp/spdlog/include/spdlog/spdlog.h diff --git a/CAPI/spdlog/include/spdlog/stopwatch.h b/CAPI/cpp/spdlog/include/spdlog/stopwatch.h similarity index 100% rename from CAPI/spdlog/include/spdlog/stopwatch.h rename to CAPI/cpp/spdlog/include/spdlog/stopwatch.h diff --git a/CAPI/spdlog/include/spdlog/tweakme.h b/CAPI/cpp/spdlog/include/spdlog/tweakme.h similarity index 100% rename from CAPI/spdlog/include/spdlog/tweakme.h rename to CAPI/cpp/spdlog/include/spdlog/tweakme.h diff --git a/CAPI/spdlog/include/spdlog/version.h b/CAPI/cpp/spdlog/include/spdlog/version.h similarity index 100% rename from CAPI/spdlog/include/spdlog/version.h rename to CAPI/cpp/spdlog/include/spdlog/version.h diff --git a/CAPI/tclap/COPYING b/CAPI/cpp/tclap/COPYING similarity index 100% rename from CAPI/tclap/COPYING rename to CAPI/cpp/tclap/COPYING diff --git a/CAPI/tclap/include/tclap/Arg.h b/CAPI/cpp/tclap/include/tclap/Arg.h similarity index 100% rename from CAPI/tclap/include/tclap/Arg.h rename to CAPI/cpp/tclap/include/tclap/Arg.h diff --git a/CAPI/tclap/include/tclap/ArgException.h b/CAPI/cpp/tclap/include/tclap/ArgException.h similarity index 100% rename from CAPI/tclap/include/tclap/ArgException.h rename to CAPI/cpp/tclap/include/tclap/ArgException.h diff --git a/CAPI/tclap/include/tclap/ArgTraits.h b/CAPI/cpp/tclap/include/tclap/ArgTraits.h similarity index 100% rename from CAPI/tclap/include/tclap/ArgTraits.h rename to CAPI/cpp/tclap/include/tclap/ArgTraits.h diff --git a/CAPI/tclap/include/tclap/CmdLine.h b/CAPI/cpp/tclap/include/tclap/CmdLine.h similarity index 100% rename from CAPI/tclap/include/tclap/CmdLine.h rename to CAPI/cpp/tclap/include/tclap/CmdLine.h diff --git a/CAPI/tclap/include/tclap/CmdLineInterface.h b/CAPI/cpp/tclap/include/tclap/CmdLineInterface.h similarity index 100% rename from CAPI/tclap/include/tclap/CmdLineInterface.h rename to CAPI/cpp/tclap/include/tclap/CmdLineInterface.h diff --git a/CAPI/tclap/include/tclap/CmdLineOutput.h b/CAPI/cpp/tclap/include/tclap/CmdLineOutput.h similarity index 100% rename from CAPI/tclap/include/tclap/CmdLineOutput.h rename to CAPI/cpp/tclap/include/tclap/CmdLineOutput.h diff --git a/CAPI/tclap/include/tclap/Constraint.h b/CAPI/cpp/tclap/include/tclap/Constraint.h similarity index 100% rename from CAPI/tclap/include/tclap/Constraint.h rename to CAPI/cpp/tclap/include/tclap/Constraint.h diff --git a/CAPI/tclap/include/tclap/DocBookOutput.h b/CAPI/cpp/tclap/include/tclap/DocBookOutput.h similarity index 100% rename from CAPI/tclap/include/tclap/DocBookOutput.h rename to CAPI/cpp/tclap/include/tclap/DocBookOutput.h diff --git a/CAPI/tclap/include/tclap/HelpVisitor.h b/CAPI/cpp/tclap/include/tclap/HelpVisitor.h similarity index 100% rename from CAPI/tclap/include/tclap/HelpVisitor.h rename to CAPI/cpp/tclap/include/tclap/HelpVisitor.h diff --git a/CAPI/tclap/include/tclap/IgnoreRestVisitor.h b/CAPI/cpp/tclap/include/tclap/IgnoreRestVisitor.h similarity index 100% rename from CAPI/tclap/include/tclap/IgnoreRestVisitor.h rename to CAPI/cpp/tclap/include/tclap/IgnoreRestVisitor.h diff --git a/CAPI/tclap/include/tclap/Makefile.am b/CAPI/cpp/tclap/include/tclap/Makefile.am similarity index 100% rename from CAPI/tclap/include/tclap/Makefile.am rename to CAPI/cpp/tclap/include/tclap/Makefile.am diff --git a/CAPI/tclap/include/tclap/MultiArg.h b/CAPI/cpp/tclap/include/tclap/MultiArg.h similarity index 100% rename from CAPI/tclap/include/tclap/MultiArg.h rename to CAPI/cpp/tclap/include/tclap/MultiArg.h diff --git a/CAPI/tclap/include/tclap/MultiSwitchArg.h b/CAPI/cpp/tclap/include/tclap/MultiSwitchArg.h similarity index 100% rename from CAPI/tclap/include/tclap/MultiSwitchArg.h rename to CAPI/cpp/tclap/include/tclap/MultiSwitchArg.h diff --git a/CAPI/tclap/include/tclap/OptionalUnlabeledTracker.h b/CAPI/cpp/tclap/include/tclap/OptionalUnlabeledTracker.h similarity index 100% rename from CAPI/tclap/include/tclap/OptionalUnlabeledTracker.h rename to CAPI/cpp/tclap/include/tclap/OptionalUnlabeledTracker.h diff --git a/CAPI/tclap/include/tclap/StandardTraits.h b/CAPI/cpp/tclap/include/tclap/StandardTraits.h similarity index 100% rename from CAPI/tclap/include/tclap/StandardTraits.h rename to CAPI/cpp/tclap/include/tclap/StandardTraits.h diff --git a/CAPI/tclap/include/tclap/StdOutput.h b/CAPI/cpp/tclap/include/tclap/StdOutput.h similarity index 100% rename from CAPI/tclap/include/tclap/StdOutput.h rename to CAPI/cpp/tclap/include/tclap/StdOutput.h diff --git a/CAPI/tclap/include/tclap/SwitchArg.h b/CAPI/cpp/tclap/include/tclap/SwitchArg.h similarity index 100% rename from CAPI/tclap/include/tclap/SwitchArg.h rename to CAPI/cpp/tclap/include/tclap/SwitchArg.h diff --git a/CAPI/tclap/include/tclap/UnlabeledMultiArg.h b/CAPI/cpp/tclap/include/tclap/UnlabeledMultiArg.h similarity index 100% rename from CAPI/tclap/include/tclap/UnlabeledMultiArg.h rename to CAPI/cpp/tclap/include/tclap/UnlabeledMultiArg.h diff --git a/CAPI/tclap/include/tclap/UnlabeledValueArg.h b/CAPI/cpp/tclap/include/tclap/UnlabeledValueArg.h similarity index 100% rename from CAPI/tclap/include/tclap/UnlabeledValueArg.h rename to CAPI/cpp/tclap/include/tclap/UnlabeledValueArg.h diff --git a/CAPI/tclap/include/tclap/ValueArg.h b/CAPI/cpp/tclap/include/tclap/ValueArg.h similarity index 100% rename from CAPI/tclap/include/tclap/ValueArg.h rename to CAPI/cpp/tclap/include/tclap/ValueArg.h diff --git a/CAPI/tclap/include/tclap/ValuesConstraint.h b/CAPI/cpp/tclap/include/tclap/ValuesConstraint.h similarity index 100% rename from CAPI/tclap/include/tclap/ValuesConstraint.h rename to CAPI/cpp/tclap/include/tclap/ValuesConstraint.h diff --git a/CAPI/tclap/include/tclap/VersionVisitor.h b/CAPI/cpp/tclap/include/tclap/VersionVisitor.h similarity index 100% rename from CAPI/tclap/include/tclap/VersionVisitor.h rename to CAPI/cpp/tclap/include/tclap/VersionVisitor.h diff --git a/CAPI/tclap/include/tclap/Visitor.h b/CAPI/cpp/tclap/include/tclap/Visitor.h similarity index 100% rename from CAPI/tclap/include/tclap/Visitor.h rename to CAPI/cpp/tclap/include/tclap/Visitor.h diff --git a/CAPI/tclap/include/tclap/XorHandler.h b/CAPI/cpp/tclap/include/tclap/XorHandler.h similarity index 100% rename from CAPI/tclap/include/tclap/XorHandler.h rename to CAPI/cpp/tclap/include/tclap/XorHandler.h diff --git a/CAPI/tclap/include/tclap/ZshCompletionOutput.h b/CAPI/cpp/tclap/include/tclap/ZshCompletionOutput.h similarity index 100% rename from CAPI/tclap/include/tclap/ZshCompletionOutput.h rename to CAPI/cpp/tclap/include/tclap/ZshCompletionOutput.h diff --git a/CAPI/tclap/include/tclap/sstream.h b/CAPI/cpp/tclap/include/tclap/sstream.h similarity index 100% rename from CAPI/tclap/include/tclap/sstream.h rename to CAPI/cpp/tclap/include/tclap/sstream.h diff --git a/PyAPI/.gitattributes b/CAPI/python/.gitattributes similarity index 100% rename from PyAPI/.gitattributes rename to CAPI/python/.gitattributes diff --git a/PyAPI/.gitignore b/CAPI/python/.gitignore similarity index 100% rename from PyAPI/.gitignore rename to CAPI/python/.gitignore diff --git a/PyAPI/PyAPI/AI.py b/CAPI/python/PyAPI/AI.py similarity index 100% rename from PyAPI/PyAPI/AI.py rename to CAPI/python/PyAPI/AI.py diff --git a/PyAPI/PyAPI/API.py b/CAPI/python/PyAPI/API.py similarity index 100% rename from PyAPI/PyAPI/API.py rename to CAPI/python/PyAPI/API.py diff --git a/PyAPI/PyAPI/Communication.py b/CAPI/python/PyAPI/Communication.py similarity index 100% rename from PyAPI/PyAPI/Communication.py rename to CAPI/python/PyAPI/Communication.py diff --git a/PyAPI/PyAPI/DebugAPI.py b/CAPI/python/PyAPI/DebugAPI.py similarity index 100% rename from PyAPI/PyAPI/DebugAPI.py rename to CAPI/python/PyAPI/DebugAPI.py diff --git a/PyAPI/PyAPI/Interface.py b/CAPI/python/PyAPI/Interface.py similarity index 100% rename from PyAPI/PyAPI/Interface.py rename to CAPI/python/PyAPI/Interface.py diff --git a/PyAPI/PyAPI/State.py b/CAPI/python/PyAPI/State.py similarity index 100% rename from PyAPI/PyAPI/State.py rename to CAPI/python/PyAPI/State.py diff --git a/PyAPI/PyAPI/logic.py b/CAPI/python/PyAPI/logic.py similarity index 100% rename from PyAPI/PyAPI/logic.py rename to CAPI/python/PyAPI/logic.py diff --git a/PyAPI/PyAPI/main.py b/CAPI/python/PyAPI/main.py similarity index 100% rename from PyAPI/PyAPI/main.py rename to CAPI/python/PyAPI/main.py diff --git a/PyAPI/PyAPI/structures.py b/CAPI/python/PyAPI/structures.py similarity index 100% rename from PyAPI/PyAPI/structures.py rename to CAPI/python/PyAPI/structures.py diff --git a/PyAPI/PyAPI/utils.py b/CAPI/python/PyAPI/utils.py similarity index 100% rename from PyAPI/PyAPI/utils.py rename to CAPI/python/PyAPI/utils.py diff --git a/PyAPI/README.md b/CAPI/python/README.md similarity index 100% rename from PyAPI/README.md rename to CAPI/python/README.md diff --git a/PyAPI/requirements.txt b/CAPI/python/requirements.txt similarity index 100% rename from PyAPI/requirements.txt rename to CAPI/python/requirements.txt diff --git a/dependency/proto/Message2Clients.proto b/dependency/proto/Message2Clients.proto index 6f57f1b..f915329 100755 --- a/dependency/proto/Message2Clients.proto +++ b/dependency/proto/Message2Clients.proto @@ -27,7 +27,8 @@ message MessageOfStudent int32 score = 20; int32 treat_progress = 21; // 治疗进度 int32 rescue_progress = 22; // 救援进度 - repeated StudentBuffType buff = 23; + StudentType student_type = 23; + repeated StudentBuffType buff = 24; } message MessageOfTricker diff --git a/dependency/proto/Services.proto b/dependency/proto/Services.proto index 73662f4..dc7d08a 100755 --- a/dependency/proto/Services.proto +++ b/dependency/proto/Services.proto @@ -27,5 +27,6 @@ service AvailableService rpc CloseDoor (IDMsg) returns (BoolRes); // 关门 rpc SkipWindow (IDMsg) returns (BoolRes); // 窗户 rpc StartOpenGate (IDMsg) returns (BoolRes); // 开闸门 + rpc StartOpenChest (IDMsg) returns (BoolRes); rpc EndAllAction (IDMsg) returns (BoolRes); // 结束所有动作 } \ No newline at end of file