From 1f35b07a5fdb6355f1a37608b3855a196d3c098a Mon Sep 17 00:00:00 2001 From: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> Date: Sat, 21 Mar 2026 22:08:27 +0100 Subject: [PATCH 1/6] WIP savedata.proto: Added protobuf file for savedata Signed-off-by: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> --- CMakeLists.txt | 4 +- cmake/LinuxToolchain.cmake | 2 +- src/game/server/CMakeLists.txt | 19 +- src/game/server/player/player.cpp | 10 +- src/game/server/proto/CMakeLists.txt | 11 + src/game/server/proto/savedata.proto | 174 +++++++ src/game/server/save/protosave.cpp | 707 +++++++++++++++++++++++++++ src/game/server/save/protosave.h | 29 ++ src/game/server/sv_character.cpp | 38 +- src/game/shared/ms/mscharacter.cpp | 12 +- src/game/shared/ms/mscharacter.h | 3 +- 11 files changed, 986 insertions(+), 23 deletions(-) create mode 100644 src/game/server/proto/CMakeLists.txt create mode 100644 src/game/server/proto/savedata.proto create mode 100644 src/game/server/save/protosave.cpp create mode 100644 src/game/server/save/protosave.h diff --git a/CMakeLists.txt b/CMakeLists.txt index fed1665e..5142421c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,7 +18,7 @@ if (UNIX) # which compilers to use for C and C++ set(CMAKE_C_COMPILER gcc) set(CMAKE_CXX_COMPILER g++) - set(CMAKE_CXX_FLAGS "-m32 -static-libgcc -static-libstdc++ -D_GLIBCXX_USE_CXX11_ABI=0") + set(CMAKE_CXX_FLAGS "-m32 -static-libgcc -static-libstdc++") set(CMAKE_MAKE_PROGRAM make) set(VCPKG_TARGET_TRIPLET x86-linux) @@ -135,6 +135,8 @@ endfunction(set_common_properties) add_compile_definitions($<$:DEBUG> $<$:_DEBUG>) add_compile_definitions($<$:NDEBUG>) +find_package(Protobuf REQUIRED) + # Add Projects add_subdirectory(src/game/client) add_subdirectory(src/game/server) diff --git a/cmake/LinuxToolchain.cmake b/cmake/LinuxToolchain.cmake index 1d6bbe8f..664129b6 100644 --- a/cmake/LinuxToolchain.cmake +++ b/cmake/LinuxToolchain.cmake @@ -1,2 +1,2 @@ # VCPKG -set(VCPKG_TARGET_TRIPLET "x86-linux" CACHE INTERNAL "Triplet to use for Linux development. Do not modify.") \ No newline at end of file +set(VCPKG_TARGET_TRIPLET "x86-linux" CACHE INTERNAL "Triplet to use for Linux development. Do not modify.") diff --git a/src/game/server/CMakeLists.txt b/src/game/server/CMakeLists.txt index fe38f62b..c98827b3 100644 --- a/src/game/server/CMakeLists.txt +++ b/src/game/server/CMakeLists.txt @@ -2,6 +2,8 @@ set(ZLIB_USE_STATIC_LIBS "ON") set(ZLIB_ROOT "${BASEDIR}/lib/zlib") find_package(ZLIB REQUIRED) +add_subdirectory(proto) + add_library(server SHARED $<$:ms.def>) add_library(libcurl STATIC IMPORTED) @@ -27,7 +29,10 @@ target_link_libraries(server PRIVATE $<$:Crypt32> $<$:Normaliz> ${ZLIB_LIBRARIES} - libcurl) + libcurl + savedata-protoc + ${Protobuf_LIBRARIES} + ) # Include directories target_include_directories(server PRIVATE @@ -52,7 +57,11 @@ target_include_directories(server PRIVATE monsters player fn - ${ZLIB_INCLUDE_DIRS}) + save + ${ZLIB_INCLUDE_DIRS} + ${Protobuf_INCLUDE_DIRS} + $ # protobuf +) target_compile_definitions(server PRIVATE VERSION_SAFE_STEAM_API_INTERFACES @@ -405,6 +414,11 @@ set(ThirdParty_AngelScript ) source_group("ThirdParty\\AngelScript" FILES ${ThirdParty_AngelScript}) +set(Shared_Save + "save/protosave.cpp" + "save/protosave.h" +) + set(ALL_FILES ${Common} ${Engine} @@ -420,6 +434,7 @@ set(ALL_FILES ${Shared_AngelScript} ${Server_AngelScript} ${ThirdParty_AngelScript} + ${Shared_Save} ) target_sources(server PRIVATE ${ALL_FILES}) diff --git a/src/game/server/player/player.cpp b/src/game/server/player/player.cpp index d8af019d..32eda802 100644 --- a/src/game/server/player/player.cpp +++ b/src/game/server/player/player.cpp @@ -58,6 +58,7 @@ #include "magic.h" #include "fn/FNSharedDefs.h" #include "mslogger.h" +#include "save/protosave.h" #define MAX_ENTITIES_TO_SEARCH 4096 static CBaseEntity* g_pEntitiesInBox[MAX_ENTITIES_TO_SEARCH]; @@ -6719,7 +6720,14 @@ void CBasePlayer::Storage_Send() void CBasePlayer::SaveChar() { //Save right now - MSChar_Interface::SaveChar(this, NULL); + if (SAVECHAR_VERSION == SAVECHAR_VERSION_MSR_PROTOBUF) + { + msr::ProtoSave::SaveCharProtobuf(this, NULL); + } + else + { + MSChar_Interface::SaveChar(this, NULL); + } } void CBasePlayer::QuickSlot_Create(int Slot, ulong ID, bool Verbose) diff --git a/src/game/server/proto/CMakeLists.txt b/src/game/server/proto/CMakeLists.txt new file mode 100644 index 00000000..7524a4e2 --- /dev/null +++ b/src/game/server/proto/CMakeLists.txt @@ -0,0 +1,11 @@ +add_library(savedata-protoc SHARED OBJECT "${CMAKE_CURRENT_LIST_DIR}/savedata.proto") +target_link_libraries(savedata-protoc PRIVATE ${Protobuf_LIBRARIES}) +target_include_directories(savedata-protoc INTERFACE $) + + +message("🏗️ Generating protobuf.") +protobuf_generate( + TARGET savedata-protoc + IMPORT_DIRS "${CMAKE_CURRENT_LIST_DIR}" + PROTOC_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}" +) diff --git a/src/game/server/proto/savedata.proto b/src/game/server/proto/savedata.proto new file mode 100644 index 00000000..94e3f26b --- /dev/null +++ b/src/game/server/proto/savedata.proto @@ -0,0 +1,174 @@ +syntax = "proto3"; + +package MSRProto; + +/** STATS **/ +message Stat { + enum StatId { + StatId_UNKNOWN=0; // default value for backward compatibility + // stats + Strength=1; + Agility=2; + Concentration=3; + Awareness=4; + Fitness=5; + Wisdom=6; + // skills + Swordsmanship=1001; + MartialArts=1002; + SmallArms=1003; + AxeHandling=1004; + BluntArms=1005; + Archery=1006; + SpellCasting=1007; + Parry=1008; + PoleArms=1009; + } + StatId statId=1; + + message SubStat { + enum SubStatId { + SubStatId_UNKNOWN=0; // default value for backward compatibility + // substats + Proficiency=1; + Balance=2; + Power=3; + // spells + Fire=1001; + Ice=1002; + Lightning=1003; + Divination=1004; + Affliction=1005; + } + SubStatId substatId=1; + uint32 value=2; // level + uint32 exp=3; + } + repeated SubStat subStats=2; +} + +/** ITEMS **/ +message GenericItemFull { + message GenericItem { + uint32 id=1; + string name=2; + + /* { + ITEM_WEARABLE = 1; // (1 << 0) + ITEM_SHIELD = 2; // (1 << 1) + ITEM_ARMOR = 4; // (1 << 2) + ITEM_GENERIC = 8 // (1 << 3) + ITEM_GROUPABLE = 16; // (1 << 4) + ITEM_CONTAINER = 32; // (1 << 5) + ITEM_PROJECTILE = 64; // (1 << 6) + ITEM_DRINKABLE = 128; // (1 << 7) + ITEM_PERISHABLE = 256; // (1 << 8) + ITEM_SPELL = 512; // (1 << 9) + ITEM_NOPICKUP = 32768; // (1 << 15) + + ENT_BODYPART = 1024; // (1 << 10) + MS_NPC = 2048; // (1 << 11) + MS_PLAYER = 4096; // (1 << 12) + MS_CORPSE = 8192; // (1 << 13) + MS_SHIELD = 16384; // (1 << 14) + } */ + uint32 properties=3; // flags, see list above + uint32 quantity=4; // ITEM_GROUPABLE (like arrows) + uint32 quality=5; // uses/durability + uint32 maxQuality=6; // may be zero (e.g. for potions) + } + GenericItem genericItem=1; + + /* { + ITEMPOS_NONE = 0; + ITEMPOS_HANDS = 1; + ITEMPOS_BODY = 2; + } */ + uint32 Location=2; // see above, Location of the item on the monster (Hands, back, etc) + + enum HandId { // NOTE hand_e starts with LEFT_HAND=0 + HandId_UNKNOWN=0; // default value for backward compatibility + LEFT_HAND=1; + RIGHT_HAND=2; + + HAND_PLAYERHANDS=3; // Special undroppable item -- Player hands + ANY_HAND=4; + BOTH_HANDS=5; + } + HandId Hand=3; + repeated GenericItemFull containerItems=4; +} + +message Storage { + string name=1; + repeated GenericItemFull items=2; +} + + +/** SAVE DATA **/ +message CharData { + message SaveData { + int32 version=1; + string name=2; + string steamId=3; + string race=4; // Human after all? + + enum GenderId { + GenderId_UNKNOWN=0; // default value for backward compatibility + Male=1; + Female=2; + } + GenderId gender=5; + string mapName=6; // Current map + string nextMap=7; + string oldTransition=8; // Map transition + string newTransition=9; // Map transition + + message Vector3 { + double x=1; + double y=2; + double z=3; + } + Vector3 origin=10; + Vector3 angles=11; + bool isElite=12; // @todo is developer? + uint32 gold=13; + uint32 maxHP=14; + uint32 maxMP=15; + uint32 currentHP=16; + uint32 currentMP=17; + string partyName=18; + uint32 partyId=19; // Unique Id for party. If I join a server that has a party with the same name, I won't automatically join their party + uint32 playerKills=20; + double timeWaitedToForgetKill=21; // Counts up... when reachs a certain number, decrement PlayerKills + double timeWaitedToForgetSteal=22; // Counts up... when reachs a certain number, player is not considered a thief + } + SaveData saveData=1; + repeated string visitedMaps=2; // All the maps I've visited + repeated Stat statList=3; // All stats. Natural stats and Skill-based stats + repeated string knownSpells=4; // All known spells + repeated GenericItemFull items=5; // All carried items + repeated Storage storages=6; // Storage places where I have items + + message Companion { + string scriptName=1; + map scriptedSaveVariables=2; // Save any variables that start with "companion.save." + } + repeated Companion companions=7; // Companions + repeated string viewedHelpTips=8; // List of all help tips the player has already viewed + + map quests=9; // All the quests I've completed + + message QuickSlot { + enum QuickSlotTypeId { // NOTE quickslottype_e starts with QS_ITEM=0 + QuickSlotTypeId_UNKNOWN=0; // default value for backward compatibility + QS_EMPTY=1; + QS_ITEM=2; + QS_SPELL=3; + QS_ARROW=4; + } + QuickSlotTypeId type=1; + uint32 id=2; + } + repeated QuickSlot quickslots=10; // All the quickslots (based on the item Ids of the last save) +} diff --git a/src/game/server/save/protosave.cpp b/src/game/server/save/protosave.cpp new file mode 100644 index 00000000..4b353902 --- /dev/null +++ b/src/game/server/save/protosave.cpp @@ -0,0 +1,707 @@ +#include "protosave.h" +#include "savedata.pb.h" + +#include "inc_weapondefs.h" +#include "stats/stats.h" +#include "stats/statdefs.h" +#include "global.h" +#include "mscharacter.h" +#include "magic.h" +#include "script.h" +#include "fn/FNSharedDefs.h" +#include "mslogger.h" +#include "player/player.h" + +#ifndef _WIN32 +#include "sys/io.h" +#endif + +//NOTENOTE: remove this when char corruption bug is fixed - Solokiller 5/10/2017 +#include "game.h" +//END NOTE + + +#include +#include +#include + +namespace msr +{ + + namespace { + // game -> proto + const auto GetProtoStatId = [](int statIndex) + { + switch(statIndex) + { + // Stats + case NATURAL_STR: return MSRProto::Stat::Strength; + case NATURAL_DEX: return MSRProto::Stat::Agility; + case NATURAL_CON: return MSRProto::Stat::Concentration; + case NATURAL_AWR: return MSRProto::Stat::Awareness; + case NATURAL_FIT: return MSRProto::Stat::Fitness; + case NATURAL_WIS: return MSRProto::Stat::Wisdom; + // Skills + case SKILL_SWORDSMANSHIP: return MSRProto::Stat::Swordsmanship; + case SKILL_MARTIALARTS: return MSRProto::Stat::MartialArts; + case SKILL_SMALLARMS: return MSRProto::Stat::SmallArms; + case SKILL_AXEHANDLING: return MSRProto::Stat::AxeHandling; + case SKILL_BLUNTARMS: return MSRProto::Stat::BluntArms; + case SKILL_ARCHERY: return MSRProto::Stat::Archery; + case SKILL_SPELLCASTING: return MSRProto::Stat::SpellCasting; + case SKILL_PARRY: return MSRProto::Stat::Parry; + case SKILL_POLEARMS: return MSRProto::Stat::PoleArms; + default: + return MSRProto::Stat::StatId_UNKNOWN; + } + }; + const auto GetProtoSubStatId = [](int subStatIndex, bool spellcasting) + { + if(spellcasting) + { + switch(subStatIndex) + { + case STAT_MAGIC_FIRE: return MSRProto::Stat::SubStat::Fire; + case STAT_MAGIC_ICE: return MSRProto::Stat::SubStat::Ice; + case STAT_MAGIC_LIGHTNING: return MSRProto::Stat::SubStat::Lightning; + case STAT_MAGIC_DIVINATION: return MSRProto::Stat::SubStat::Divination; + case STAT_MAGIC_AFFLICTION: return MSRProto::Stat::SubStat::Affliction; + default: + return MSRProto::Stat::SubStat::SubStatId_UNKNOWN; + } + } + else + { + switch(subStatIndex) + { + case STATPROP_SKILL: return MSRProto::Stat::SubStat::Proficiency; + case STATPROP_BALANCE: return MSRProto::Stat::SubStat::Balance; + case STATPROP_POWER: return MSRProto::Stat::SubStat::Power; + default: + return MSRProto::Stat::SubStat::SubStatId_UNKNOWN; + } + } + }; + const auto GetProtoHandId = [](auto handId) -> MSRProto::GenericItemFull::HandId { + switch(handId){ + case hand_e::LEFT_HAND: return MSRProto::GenericItemFull::LEFT_HAND; + case hand_e::RIGHT_HAND: return MSRProto::GenericItemFull::RIGHT_HAND; + case hand_e::HAND_PLAYERHANDS: return MSRProto::GenericItemFull::HAND_PLAYERHANDS; + case hand_e::ANY_HAND: return MSRProto::GenericItemFull::ANY_HAND; + case hand_e::BOTH_HANDS: return MSRProto::GenericItemFull::BOTH_HANDS; + default: + return MSRProto::GenericItemFull::HandId_UNKNOWN; + } + }; + const auto GetProtoQuickSlotId = [](quickslottype_e quickSlotType) { + switch (quickSlotType) { + case quickslottype_e::QS_ITEM: return MSRProto::CharData::QuickSlot::QS_ITEM; + case quickslottype_e::QS_SPELL: return MSRProto::CharData::QuickSlot::QS_SPELL; + case quickslottype_e::QS_ARROW: return MSRProto::CharData::QuickSlot::QS_ARROW; + default: return MSRProto::CharData::QuickSlot::QuickSlotTypeId_UNKNOWN; + } + }; + const auto GetProtoGender = [](gender_e gender) -> MSRProto::CharData::SaveData::GenderId { + switch(gender) + { + case GENDER_MALE: return MSRProto::CharData::SaveData::Male; + case GENDER_FEMALE: return MSRProto::CharData::SaveData::Female; + case GENDER_UNKNOWN: return MSRProto::CharData::SaveData::GenderId_UNKNOWN; + default: + return MSRProto::CharData::SaveData::GenderId_UNKNOWN; + } + }; + + // proto -> game + const auto GetGameStatId = [](MSRProto::Stat::StatId protoStatId) -> std::int32_t + { + switch(protoStatId) + { + // Stats + case MSRProto::Stat::Strength: return NATURAL_STR; + case MSRProto::Stat::Agility: return NATURAL_DEX; + case MSRProto::Stat::Concentration: return NATURAL_CON; + case MSRProto::Stat::Awareness: return NATURAL_AWR; + case MSRProto::Stat::Fitness: return NATURAL_FIT; + case MSRProto::Stat::Wisdom: return NATURAL_WIS; + // Skills + case MSRProto::Stat::Swordsmanship: return SKILL_SWORDSMANSHIP; + case MSRProto::Stat::MartialArts: return SKILL_MARTIALARTS; + case MSRProto::Stat::SmallArms: return SKILL_SMALLARMS; + case MSRProto::Stat::AxeHandling: return SKILL_AXEHANDLING; + case MSRProto::Stat::BluntArms: return SKILL_BLUNTARMS; + case MSRProto::Stat::Archery: return SKILL_ARCHERY; + case MSRProto::Stat::SpellCasting: return SKILL_SPELLCASTING; + case MSRProto::Stat::Parry: return SKILL_PARRY; + case MSRProto::Stat::PoleArms: return SKILL_POLEARMS; + default: + return MSRProto::Stat::StatId_UNKNOWN; + } + }; + const auto GetGameSubStatId = [](MSRProto::Stat::SubStat::SubStatId protoSubStatId, bool spellcasting) -> std::int32_t + { + if(spellcasting) + { + switch(protoSubStatId) + { + case MSRProto::Stat::SubStat::Fire: return STAT_MAGIC_FIRE; + case MSRProto::Stat::SubStat::Ice: return STAT_MAGIC_ICE; + case MSRProto::Stat::SubStat::Lightning: return STAT_MAGIC_LIGHTNING; + case MSRProto::Stat::SubStat::Divination: return STAT_MAGIC_DIVINATION; + case MSRProto::Stat::SubStat::Affliction: return STAT_MAGIC_AFFLICTION; + default: + return -1; + } + } + else + { + switch(protoSubStatId) + { + case MSRProto::Stat::SubStat::Proficiency: return STATPROP_SKILL; + case MSRProto::Stat::SubStat::Balance: return STATPROP_BALANCE; + case MSRProto::Stat::SubStat::Power: return STATPROP_POWER; + default: + return -1; + } + } + }; + const auto GetGameHandId = [](MSRProto::GenericItemFull::HandId handId) -> std::int32_t { + switch(handId){ + case MSRProto::GenericItemFull::LEFT_HAND: return hand_e::LEFT_HAND; + case MSRProto::GenericItemFull::RIGHT_HAND: return hand_e::RIGHT_HAND; + case MSRProto::GenericItemFull::HAND_PLAYERHANDS: return hand_e::HAND_PLAYERHANDS; + case MSRProto::GenericItemFull::ANY_HAND: return hand_e::ANY_HAND; + case MSRProto::GenericItemFull::BOTH_HANDS: return hand_e::BOTH_HANDS; + default: + return -1; + } + }; + const auto GetGameQuickSlotId = [](MSRProto::CharData::QuickSlot::QuickSlotTypeId protoQuickslot, bool &active) -> std::int32_t { + switch (protoQuickslot) { + case MSRProto::CharData::QuickSlot::QS_EMPTY: + active=false; + return 0; + case MSRProto::CharData::QuickSlot::QS_ITEM: return quickslottype_e::QS_ITEM; + case MSRProto::CharData::QuickSlot::QS_SPELL: return quickslottype_e::QS_SPELL; + case MSRProto::CharData::QuickSlot::QS_ARROW: return quickslottype_e::QS_ARROW; + default: + return -1; + } + }; + const auto GetGameGender = [](MSRProto::CharData::SaveData::GenderId gender) -> gender_e{ + switch(gender) + { + case MSRProto::CharData::SaveData::Male: return GENDER_MALE; + case MSRProto::CharData::SaveData::Female: return GENDER_FEMALE; + case MSRProto::CharData::SaveData::GenderId_UNKNOWN: return GENDER_UNKNOWN; + default: + return GENDER_UNKNOWN; + } + }; + } + + + void ProtoSave::CreateCharData(CBasePlayer *pPlayer, savedata_t *pData, MSRProto::CharData *out) + { + if (pPlayer->m_CharacterState == CHARSTATE_UNLOADED) return; //Can't save if no character is created + if (MSGlobals::DevModeEnabled) return; + if (pPlayer->MaxHP() < 15) return; //FEB2015_25 Thothie - don't save if <15 hp (char delete bug workaround) + if (!MSChar_Interface::HasVisited(MSGlobals::MapName, pPlayer->m_Maps)) pPlayer->m_Maps.add(MSGlobals::MapName); + + // create the main protobuf message + MSRProto::CharData::SaveData *saveData = out->mutable_savedata(); + + saveData->set_version(SAVECHAR_VERSION_MSR_PROTOBUF); + if (pData == nullptr) // saving existing character + { + MS_WARN("Saving existing character: {}", pPlayer->m_DisplayName); + saveData->set_name(pPlayer->m_DisplayName); + saveData->set_steamid(GETPLAYERAUTHID(pPlayer->edict())); + saveData->set_race("Human"); // LEGACY + + saveData->set_gender(GetProtoGender(pPlayer->m_Gender)); + // map + saveData->set_mapname(MSGlobals::MapName); + saveData->set_nextmap(pPlayer->m_NextMap); + saveData->set_oldtransition(pPlayer->m_OldTransition); + saveData->set_newtransition(pPlayer->m_NextTransition); + // stats + // MISSING: Origin + // MISSING: Angle + saveData->set_iselite(pPlayer->m_fIsElite); + saveData->set_gold(pPlayer->m_Gold); + saveData->set_maxhp(pPlayer->m_MaxHP); + saveData->set_maxmp(pPlayer->m_MaxMP); + if (pPlayer->pev->deadflag == DEAD_NO) + { + saveData->set_currenthp(pPlayer->m_HP); + saveData->set_currentmp(pPlayer->m_MP); + } + else + { + //Tried to save while dead. + //Set Health/Mana to 0 to indicate this + saveData->set_currenthp(0); + saveData->set_currentmp(0); + } + // party + saveData->set_partyname(pPlayer->GetPartyName()); + saveData->set_partyid(pPlayer->GetPartyID()); + + // PKs + saveData->set_playerkills(pPlayer->m_PlayersKilled); + saveData->set_timewaitedtoforgetkill(pPlayer->m_TimeWaitedToForgetKill); + saveData->set_timewaitedtoforgetsteal(pPlayer->m_TimeWaitedToForgetSteal); + } + else // saving new character + { + MS_WARN(std::format("Saving new character: {}", pData->Name).c_str()); + saveData->set_name(pData->Name); + saveData->set_steamid(pData->SteamID); + saveData->set_race(pData->Race); + saveData->set_gender(GetProtoGender(static_cast(pData->Gender))); + // map + saveData->set_mapname(pData->MapName); + saveData->set_nextmap(pData->NextMap); + saveData->set_oldtransition(pData->OldTrans); + saveData->set_newtransition(pData->NewTrans); + // stats + auto protoOrigin = saveData->mutable_origin(); + protoOrigin->set_x(pData->Origin.x); + protoOrigin->set_y(pData->Origin.y); + protoOrigin->set_z(pData->Origin.z); + auto protoAngle = saveData->mutable_angles(); + protoAngle->set_x(pData->Angles.x); + protoAngle->set_y(pData->Angles.y); + protoAngle->set_z(pData->Angles.z); + saveData->set_iselite(pData->IsElite); + saveData->set_gold(pData->Gold); + saveData->set_maxhp(pData->MaxHP); + saveData->set_maxmp(pData->MaxMP); + + saveData->set_currenthp(pData->HP); + saveData->set_currentmp(pData->MP); + // party + saveData->set_partyname(pData->Party); + saveData->set_partyid(pData->PartyID); + + // PKs + saveData->set_playerkills(pData->PlayerKills); + saveData->set_timewaitedtoforgetkill(pData->TimeWaitedToForgetKill); + saveData->set_timewaitedtoforgetsteal(pData->TimeWaitedToForgetSteal); + } + + // visitedMaps + for (int mapIdx = 0; mapIdx < pPlayer->m_Maps.size(); ++mapIdx) /// @todo replace with range based for + { + out->add_visitedmaps(pPlayer->m_Maps[mapIdx]); + } + for (int statId = 0; statId < pPlayer->m_Stats.size(); ++statId) + { + const CStat &stat = pPlayer->m_Stats[statId]; + auto protoStat = out->add_statlist(); + protoStat->set_statid(GetProtoStatId(statId)); + for (int subStatId = 0; subStatId < stat.m_SubStats.size(); ++subStatId) + { + const CSubStat &subStat = stat.m_SubStats[subStatId]; + auto protoSubStat = protoStat->add_substats(); + protoSubStat->set_substatid(GetProtoSubStatId(subStatId, (protoStat->statid() == MSRProto::Stat::SpellCasting))); + protoSubStat->set_value(subStat.Value); + protoSubStat->set_exp(subStat.Exp); + } + } + + + // knownSpells + for (int spellIdx = 0; spellIdx < pPlayer->m_SpellList.size(); ++spellIdx) /// @todo replace with range based for + { + out->add_knownspells(pPlayer->m_SpellList[spellIdx]); + } + + // items + struct { + // recursion is easier to do in a struct rather than passing a lambda to itself + void PopulateProtoItem (const genericitem_full_t &item, MSRProto::GenericItemFull *out){ + auto gItem = out->mutable_genericitem(); + gItem->set_id(item.ID); + gItem->set_name(item.Name.c_str()); + gItem->set_properties(item.Properties); + if (FBitSet(item.Properties, ITEM_GROUPABLE)) gItem->set_quantity(item.Quantity); + + if (FBitSet(item.Properties, ITEM_PERISHABLE) || FBitSet(item.Properties, ITEM_DRINKABLE)) + { + gItem->set_quality(item.Quality); + gItem->set_maxquality(item.MaxQuality); + } + + out->set_location(item.Location); + out->set_hand(GetProtoHandId(item.Hand)); + + if (FBitSet(item.Properties, ITEM_CONTAINER)) //Writing contained items should be the *LAST* thing you do + { + for(int containerIdx = 0; containerIdx < item.ContainerItems.size(); ++containerIdx) /// @todo replace with range based for + { + auto protoItem = out->add_containeritems(); + PopulateProtoItem(genericitem_full_t(item.ContainerItems[containerIdx]), protoItem); + } + } + } + } itemHelper; + + + for (const auto currentItem : pPlayer->Gear) + { + if (currentItem == pPlayer->PlayerHands) continue; //Skip player hands + if (FBitSet(currentItem->Properties, ITEM_SPELL)) continue; // skip learned spells, they are stored in knownSpells + + auto protoItem = out->add_items(); + itemHelper.PopulateProtoItem(genericitem_full_t(currentItem), protoItem); + } + + // storage items + for(int storageIdx = 0; storageIdx < pPlayer->m_Storages.size(); ++storageIdx) /// @todo replace with range based for + { + auto protoStorage = out->add_storages(); + const auto currentStorage = pPlayer->m_Storages[storageIdx]; + protoStorage->set_name(currentStorage.Name.c_str()); + for(int storageItemIdx = 0; storageItemIdx < currentStorage.Items.size(); ++storageItemIdx) /// @todo replace with range based for + { + auto protoItem = protoStorage->add_items(); + itemHelper.PopulateProtoItem(genericitem_full_t(currentStorage.Items[storageItemIdx]), protoItem); + } + } + + // companions + for (int companionIdx = 0; companionIdx < pPlayer->m_Companions.size(); ++companionIdx) /// @todo replace with range based for + { + companion_t &Companion = pPlayer->m_Companions[companionIdx]; + + //Save any variables that start with "companion.save." + CBaseEntity *pEntity = Companion.Entity.Entity(); + if (!pEntity) continue; + + IScripted *pScripted = pEntity->GetScripted(); + + if (!pScripted || pScripted->m_Scripts.size() == 0) continue; + + pScripted->CallScriptEvent("game_companion_save"); + + CScript *Script = pScripted->m_Scripts[0]; /// @todo why is the first script the right one? + + std::unordered_map saveVarMap {}; + for (int variableIdx = 0; variableIdx < Script->m_Variables.size(); ++variableIdx) /// @todo replace with range based for + { + if (Script->m_Variables[variableIdx].Name.starts_with("companion.save.")) + { + saveVarMap.insert_or_assign(Script->m_Variables[variableIdx].Name.c_str(), Script->m_Variables[variableIdx].Value.c_str()); + } + } + if(!saveVarMap.empty()) + { + auto protoCompanion = out->add_companions(); + protoCompanion->set_scriptname(Companion.ScriptName); + auto protoMap = protoCompanion->mutable_scriptedsavevariables(); + + for(const auto &[tmpKey, tmpValue] : saveVarMap) + { + (*protoMap)[tmpKey] = tmpValue; + } + } + } + + // viewed help tips + for(int helpIdx = 0; helpIdx < pPlayer->m_ViewedHelpTips.size(); ++helpIdx) /// @todo replace with range based for + { + out->add_viewedhelptips(pPlayer->m_ViewedHelpTips[helpIdx]); + } + + // quests + std::unordered_map questData; + for(int questIdx = 0; questIdx < pPlayer->m_Quests.size(); ++questIdx) /// @todo replace with range based for + { + questData.insert_or_assign(pPlayer->m_Quests[questIdx].Name.c_str(), pPlayer->m_Quests[questIdx].Data.c_str()); + } + if(!questData.empty()) + { + auto protoQuestMap = out->mutable_quests(); + + for(const auto &[tmpKey, tmpValue] : questData) + { + (*protoQuestMap)[tmpKey] = tmpValue; + } + } + + // quickslots + for (int quickSlotIdx = 0; quickSlotIdx < MAX_QUICKSLOTS; quickSlotIdx++) + { + const auto &quickSlot = pPlayer->m_QuickSlots[quickSlotIdx]; + auto protoQuickSlot = out->add_quickslots(); + if (quickSlot.Active) + { + protoQuickSlot->set_type(GetProtoQuickSlotId(quickSlot.Type)); + protoQuickSlot->set_id(quickSlot.ID); + } + else + { + protoQuickSlot->set_type(MSRProto::CharData::QuickSlot::QS_EMPTY); + } + } + } + + bool ProtoSave::LoadCharProtobuf(void *pData, unsigned long Size, chardata_t *CharData) + { + MS_INFO("Loading protobuf character"); + + + const std::string protoDataByteString(static_cast(pData), Size); + MS_INFO(std::format("Loaded protobuf data size: {}, checksum: {}", protoDataByteString.size(), std::hash{}(protoDataByteString)).c_str()); + + MSRProto::CharData protoData; + if (!protoData.ParseFromString(protoDataByteString)) { + MS_ERROR("Protobuf failed to deserialize character"); + return false; + } + + const auto &protoSaveData = protoData.savedata(); + CharData->Version = protoSaveData.version(); + std::strncpy(CharData->Name, protoSaveData.name().c_str(), sizeof(CharData->Name)); + std::strncpy(CharData->SteamID, protoSaveData.steamid().c_str(), sizeof(CharData->SteamID)); + std::strncpy(CharData->Race, protoSaveData.race().c_str(), sizeof(CharData->Race)); + CharData->Gender = GetGameGender(protoSaveData.gender()); + std::strncpy(CharData->MapName, protoSaveData.mapname().c_str(), sizeof(CharData->MapName)); + std::strncpy(CharData->NextMap, protoSaveData.nextmap().c_str(), sizeof(CharData->NextMap)); + std::strncpy(CharData->OldTrans, protoSaveData.oldtransition().c_str(), sizeof(CharData->OldTrans)); + std::strncpy(CharData->NewTrans, protoSaveData.newtransition().c_str(), sizeof(CharData->NewTrans)); + // CharData->Origin = protoSaveData.origin(); + const auto &protoAngles = protoSaveData.angles(); + CharData->Angles.x = protoAngles.x(); + CharData->Angles.y = protoAngles.y(); + CharData->Angles.z = protoAngles.z(); + // CharData->Angles = protoSaveData.angles(); + const auto &protoOrigin = protoSaveData.origin(); + CharData->Origin.x = protoOrigin.x(); + CharData->Origin.y = protoOrigin.y(); + CharData->Origin.z = protoOrigin.z(); + CharData->IsElite = protoSaveData.iselite(); + CharData->Gold = protoSaveData.gold(); + CharData->MaxHP = protoSaveData.maxhp(); + CharData->MaxMP = protoSaveData.maxmp(); + CharData->HP = protoSaveData.currenthp(); + CharData->MP = protoSaveData.currentmp(); + std::strncpy(CharData->Party, protoSaveData.partyname().c_str(), sizeof(CharData->Party)); + CharData->PartyID = protoSaveData.partyid(); + CharData->PlayerKills = protoSaveData.playerkills(); + CharData->TimeWaitedToForgetKill = protoSaveData.timewaitedtoforgetkill(); + CharData->TimeWaitedToForgetSteal = protoSaveData.timewaitedtoforgetsteal(); + + + // ReadMaps1(DataID, m_File); equivalent + CharData->m_VisitedMaps.clear(); + for (const auto &mapName : protoData.visitedmaps()) + { + CharData->m_VisitedMaps.add(mapName.c_str()); + } + + // ReadSkills1(DataID, m_File); equivalent + CStat::InitStatList(CharData->m_Stats); + + CStat* pStat = NULL; + CSubStat* pSubStat = NULL; + + for (const auto tmpStat : protoData.statlist()) + { + pStat = CharData->GetStat(GetGameStatId(tmpStat.statid())); + + for (const auto tmpSubStat : tmpStat.substats()) + { + pSubStat = (pStat ? pStat->GetSubStat(GetGameSubStatId(tmpSubStat.substatid(), (tmpStat.statid() == MSRProto::Stat::SpellCasting))) : NULL); + + if (pStat && pSubStat) + { + pSubStat->Value = tmpSubStat.value(); + pSubStat->Exp = tmpSubStat.exp(); + + // check for newly added stats not yet in the save file + if(tmpStat.statid() != MSRProto::Stat::SpellCasting + && tmpSubStat.substatid() == MSRProto::Stat::SubStat::Power + && tmpSubStat.value() == 0) + { + pSubStat->Value = 1; // power defaults to 1 + } + } + } + } + + // ReadSpells1(DataID, m_File); equivalent + for (const auto &spell : protoData.knownspells()) + { + CharData->m_Spells.add(spell.c_str()); + } + + struct { + // ReadItem1(...); equivalent + bool ReadProtoItem(const MSRProto::GenericItemFull *protoItem, genericitem_full_t &outItem){ + clrmem(outItem); + + outItem.ID = protoItem->genericitem().id(); + outItem.Name = protoItem->genericitem().name().c_str(); + const msstringstringhash::iterator iAlias = CGenericItemMgr::mItemAlias.find(outItem.Name); + if (iAlias != CGenericItemMgr::mItemAlias.end()) outItem.Name = iAlias->second; + + outItem.Properties = protoItem->genericitem().properties(); + if (FBitSet(outItem.Properties, ITEM_PERISHABLE) || + FBitSet(outItem.Properties, ITEM_DRINKABLE)) + { + outItem.Quality = protoItem->genericitem().quality(); + outItem.MaxQuality = protoItem->genericitem().maxquality(); + } + + if (FBitSet(outItem.Properties, ITEM_GROUPABLE)) + { + outItem.Quantity = protoItem->genericitem().quantity(); + } + + outItem.Location = protoItem->location(); + outItem.Hand = GetGameHandId(protoItem->hand()); + if (FBitSet(outItem.Properties, ITEM_CONTAINER)) + { + genericitem_full_t PackItem; + for (const auto &protoContainerItem : protoItem->containeritems()) + { + bool Success = ReadProtoItem(&protoContainerItem, PackItem); + if (!Success) + { + MS_ERROR("Protobuf Bad item in container, skipping..."); + continue; + } + outItem.ContainerItems.add(PackItem); + } + } + + return true; + } + } protoItemizer; + + // ReadItems1(DataID, m_File); equivalent + for(const auto &protoItem : protoData.items()) + { + genericitem_full_t Item; + if (!protoItemizer.ReadProtoItem(&protoItem, Item)) continue; + CharData->m_Items.add(Item); + } + + // ReadStorageItems1(DataID, m_File); equivalent + for(const auto &protoStorage : protoData.storages()) + { + storage_t Storage; + Storage.Name = protoStorage.name().c_str(); + + for(const auto &protoStorageItem : protoStorage.items()) + { + genericitem_full_t Item; + if (!protoItemizer.ReadProtoItem(&protoStorageItem, Item)) continue; + Storage.Items.add(Item); + } + CharData->m_Storages.add(Storage); + } + + // ReadCompanions1(DataID, m_File); equivalent + for(const auto &protoCompanion : protoData.companions()) + { + companion_t &Companion = CharData->m_Companions.add(companion_t()); + Companion.ScriptName = protoCompanion.scriptname().c_str(); + Companion.Active = false; + + for(const auto &[protoKey, protoValue] : protoCompanion.scriptedsavevariables()) + { + Companion.SaveVarName.add(protoKey.c_str()); + Companion.SaveVarValue.add(protoValue.c_str()); + } + } + + // ReadHelpTips1(DataID, m_File); + CharData->m_ViewedHelpTips.clear(); + for(const auto &protoHelpTip : protoData.viewedhelptips()) + { + CharData->m_ViewedHelpTips.add(protoHelpTip.c_str()); + } + + // ReadQuests1(DataID, m_File); equivalent + CharData->m_Quests.clear(); + for(const auto &[protoQuestkey, protoQuestValue] : protoData.quests()) + { + CharData->m_Quests.add(quest_t{.Name=protoQuestkey.c_str(), .Data=protoQuestValue.c_str()}); + } + + // ReadQuickSlots1(DataID, m_File); + CharData->m_QuickSlots.clear(); + for(const auto &protoQuickslot : protoData.quickslots()) + { + quickslot_t QuickSlot; + QuickSlot.Active = true; + QuickSlot.Type = static_cast(GetGameQuickSlotId(protoQuickslot.type(), QuickSlot.Active)); + if(QuickSlot.Active) + { + QuickSlot.ID = protoQuickslot.id(); + } + } + + return true; + } + + void ProtoSave::SaveCharJSON(CBasePlayer *pPlayer, savedata_t *pData) + { + MS_INFO("Protobuf exporting save to json"); + std::string jsonSaveName {GetSaveFileName(pPlayer->m_CharacterNum, pPlayer)}; + jsonSaveName += ".json"; + + MSRProto::CharData charData; + + ProtoSave::CreateCharData(pPlayer, pData, &charData); + + google::protobuf::util::JsonPrintOptions options; + options.add_whitespace = true; + options.always_print_primitive_fields = true; + options.preserve_proto_field_names = true; + + std::string jsonResult; + google::protobuf::util::MessageToJsonString(charData, &jsonResult, options); + + CGameFile jsonFile; + jsonFile.OpenWrite(jsonSaveName.c_str()); + jsonFile.Write(jsonResult.c_str(), jsonResult.size()); + jsonFile.Close(); + } + + void ProtoSave::SaveCharProtobuf(CBasePlayer *pPlayer, savedata_t *pData) + { + MSRProto::CharData charData; + + ProtoSave::CreateCharData(pPlayer, pData, &charData); + std::string charDataByteString; + if(!charData.SerializeToString(&charDataByteString)) + { + MS_ERROR("Protobuf failed to serialize string"); + return; + } + MS_INFO(std::format("Serialized protobuf data size: {}, checksum: {}", charDataByteString.size(), std::hash{}(charDataByteString)).c_str()); + + if (FNShared::IsEnabled()) + { + // If Central Server is enabled, save to the Central Server instead of locally + FNShared::CreateOrUpdateCharacter(pPlayer, pPlayer->m_CharacterNum, charDataByteString.c_str(), charDataByteString.size(), (pData == NULL)); + return; + } + else if (!MSGlobals::ServerSideChar) + { + charinfo_t &CharInfo = pPlayer->m_CharInfo[pPlayer->m_CharacterNum]; + CharInfo.AssignChar(pPlayer->m_CharacterNum, LOC_CLIENT, charDataByteString.c_str(), charDataByteString.size(), pPlayer); + return; + } + + CGameFile saveFile; + saveFile.OpenWrite(GetSaveFileName(pPlayer->m_CharacterNum, pPlayer)); + saveFile.Write(charDataByteString.c_str(), charDataByteString.size()); + saveFile.Close(); + } +} // namespace msr diff --git a/src/game/server/save/protosave.h b/src/game/server/save/protosave.h new file mode 100644 index 00000000..09f0d562 --- /dev/null +++ b/src/game/server/save/protosave.h @@ -0,0 +1,29 @@ +#pragma once + +namespace MSRProto { class CharData; } +class CBasePlayer; +struct savedata_t; +struct chardata_t; + +namespace msr +{ + class ProtoSave + { + public: + /** + * @brief ProtoSave::CreateSave + * @param pPlayer + * @param pData + * @param out Writes to the CharData + */ + static void CreateCharData(CBasePlayer *pPlayer, savedata_t *pData, MSRProto::CharData *out); + static bool LoadCharProtobuf(void *pData, unsigned long Size, chardata_t *CharData); + /** + * @brief Save character to json for easier debugging + */ + static void SaveCharJSON(CBasePlayer *pPlayer, savedata_t *pData); + static void SaveCharProtobuf(CBasePlayer *pPlayer, savedata_t *pData); + }; + +} // namespace msr + diff --git a/src/game/server/sv_character.cpp b/src/game/server/sv_character.cpp index 1d7fa00a..655350b2 100644 --- a/src/game/server/sv_character.cpp +++ b/src/game/server/sv_character.cpp @@ -19,6 +19,8 @@ #include "game.h" //END NOTE +#include "save/protosave.h" + void CBasePlayer::CreateChar(createchar_t &CharData) { //Create a new character, using the options the user specified. @@ -98,7 +100,15 @@ void CBasePlayer::CreateChar(createchar_t &CharData) m_CharacterNum = CharData.iChar; m_CharacterState = CHARSTATE_LOADED; //Temporary, so the save will succeed - MSChar_Interface::SaveChar(this, &Data); //Save the new character + + if (SAVECHAR_VERSION == SAVECHAR_VERSION_MSR_PROTOBUF) + { + msr::ProtoSave::SaveCharProtobuf(this, &Data); //Save the new char with protobuf + } + else + { + MSChar_Interface::SaveChar(this, &Data); //Save the new character + } m_CharacterState = CHARSTATE_UNLOADED; //Created a new character... this one is no longer valid @@ -197,13 +207,13 @@ void chardata_t::ReadSkills1(byte DataID, CPlayer_DataBuffer &m_File) { switch (r) { - case 5: // Used to be DIVINATION - pSubStat = (pStat ? pStat->GetSubStat(STAT_MAGIC_DIVINATION) : NULL); - break; + case 5: // Used to be DIVINATION + pSubStat = (pStat ? pStat->GetSubStat(STAT_MAGIC_DIVINATION) : NULL); + break; - case 6: // Used to be AFFLICTION - pSubStat = (pStat ? pStat->GetSubStat(STAT_MAGIC_AFFLICTION) : NULL); - break; + case 6: // Used to be AFFLICTION + pSubStat = (pStat ? pStat->GetSubStat(STAT_MAGIC_AFFLICTION) : NULL); + break; } } @@ -394,10 +404,10 @@ bool chardata_t::ReadItem1(byte DataID, CPlayer_DataBuffer &Data, genericitem_fu if (!cTemp || !cTemp[0]) return false; - outItem.Name = cTemp; + outItem.Name = cTemp; msstringstringhash::iterator iAlias = CGenericItemMgr::mItemAlias.find(outItem.Name); - if (iAlias != CGenericItemMgr::mItemAlias.end()) - outItem.Name = iAlias->second; + if (iAlias != CGenericItemMgr::mItemAlias.end()) + outItem.Name = iAlias->second; //It is now possible to read an item from file correctly, but not be able to spawn that item. //Be sure that, even if the item can't be created, all of the item's data is read from file properly @@ -423,7 +433,7 @@ bool chardata_t::ReadItem1(byte DataID, CPlayer_DataBuffer &Data, genericitem_fu } if (FBitSet(Properties, ITEM_PERISHABLE) || - FBitSet(Properties, ITEM_DRINKABLE)) + FBitSet(Properties, ITEM_DRINKABLE)) { short Quality = 0, MaxQuality = 0; Data.ReadShort(Quality); //[SHORT] @@ -484,8 +494,8 @@ void MSChar_Interface::SaveChar(CBasePlayer *pPlayer, savedata_t *pData) //Can I save right now? if (pPlayer->m_CharacterState == CHARSTATE_UNLOADED /*|| //Can't save if no character is created - MSGlobals::GameType != GAMETYPE_ADVENTURE*/ - ) //If the gametype isn't adventure, we can't save no matter what. + MSGlobals::GameType != GAMETYPE_ADVENTURE*/ + ) //If the gametype isn't adventure, we can't save no matter what. { return; } @@ -727,4 +737,4 @@ void MSChar_Interface::SaveChar(CBasePlayer *pPlayer, savedata_t *pData) gFile.WriteToFile(pszFileName, "wb", true); gFile.Close(); -} \ No newline at end of file +} diff --git a/src/game/shared/ms/mscharacter.cpp b/src/game/shared/ms/mscharacter.cpp index 8ec41031..8f080666 100644 --- a/src/game/shared/ms/mscharacter.cpp +++ b/src/game/shared/ms/mscharacter.cpp @@ -7,6 +7,7 @@ #ifdef VALVE_DLL #include "global.h" #include "fn/FNSharedDefs.h" +#include "save/protosave.h" #else #include "inc_huditem.h" #include "ms/clglobal.h" @@ -31,7 +32,7 @@ void ReplaceChar(char *pString, char org, char dest); bool IsValidCharVersion(int Version) { - return (Version == SAVECHAR_VERSION_MSC) || (Version == SAVECHAR_VERSION_MSR) || (Version == SAVECHAR_VERSION); + return (Version == SAVECHAR_VERSION_MSC) || (Version == SAVECHAR_VERSION_MSR); } const char *GetSaveFileName(int iCharacter, CBasePlayer *pPlayer) @@ -119,9 +120,14 @@ savedata_t *GetCharInfo(const char *pszFileName, msstringlist &VisitedMaps) return (fCharLoaded ? &Data : NULL); } - bool MSChar_Interface::ReadCharData(void *pData, ulong Size, chardata_t *CharData) { + #ifdef VALVE_DLL + if(msr::ProtoSave::LoadCharProtobuf(pData, Size, CharData)) // try protobuf first, if that fails try CharData->ReadData(pData, Size) + { + return true; + } + #endif return CharData->ReadData(pData, Size); } @@ -308,4 +314,4 @@ void WriteItem(CPlayer_DataBuffer &gFile, genericitem_full_t &Item) for (int i = 0; i < Item.ContainerItems.size(); i++) WriteItem(gFile, Item.ContainerItems[i]); } -} \ No newline at end of file +} diff --git a/src/game/shared/ms/mscharacter.h b/src/game/shared/ms/mscharacter.h index 624b9317..51c43c7f 100644 --- a/src/game/shared/ms/mscharacter.h +++ b/src/game/shared/ms/mscharacter.h @@ -124,8 +124,9 @@ struct spellskillstat_t #define SAVECHAR_VERSION_MSC 11 // Legacy MS: Classic #define SAVECHAR_VERSION_MSR 12 // MS Rebirth and up. +#define SAVECHAR_VERSION_MSR_PROTOBUF 13 // MS Rebirth protocol buffers -#define SAVECHAR_VERSION SAVECHAR_VERSION_MSR +#define SAVECHAR_VERSION SAVECHAR_VERSION_MSR_PROTOBUF //The types of headers. Each time the save file is revised, a new header is added. //The old headers are kept so the game knows when it is encountering an old save file From 87e8d4cd12f6faf002a7519edaea1651eab5811c Mon Sep 17 00:00:00 2001 From: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> Date: Mon, 23 Mar 2026 00:00:30 +0100 Subject: [PATCH 2/6] build-linux.sh: Build multithreaded with -j8 Signed-off-by: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> --- build-linux.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build-linux.sh b/build-linux.sh index 99db8de3..112a7290 100755 --- a/build-linux.sh +++ b/build-linux.sh @@ -26,4 +26,4 @@ gcc -v ./createall.sh -p $path -t $type -make -C $path/build +make -C $path/build -j 8 From eb1a07f3257ac4c0f10427c6e174ffddd6136639 Mon Sep 17 00:00:00 2001 From: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> Date: Mon, 23 Mar 2026 00:01:12 +0100 Subject: [PATCH 3/6] client/CMakeLists.txt: Removed manually set opengl library paths With the dockerfile it is not necessary anymore Signed-off-by: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> --- src/game/client/CMakeLists.txt | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/game/client/CMakeLists.txt b/src/game/client/CMakeLists.txt index f0a5b25f..20eb4526 100644 --- a/src/game/client/CMakeLists.txt +++ b/src/game/client/CMakeLists.txt @@ -4,12 +4,6 @@ add_library(fmod SHARED IMPORTED) add_library(discord SHARED IMPORTED) add_library(steam_api SHARED IMPORTED) -# for some reason it can't find these libraries, even when installed? -if (LINUX) - set(OPENGL_gl_LIBRARY /usr/lib/i386-linux-gnu/libGL.so) - set(OPENGL_glx_LIBRARY /usr/lib/i386-linux-gnu/libGLX.so) -endif() - find_package(OpenGL REQUIRED) target_include_directories(vgui INTERFACE ${BASEDIR}/lib/include/vgui) From 0dad493fa205b86cf67cef06dc15560cb4a09a4e Mon Sep 17 00:00:00 2001 From: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> Date: Mon, 23 Mar 2026 00:02:16 +0100 Subject: [PATCH 4/6] docker/Dockerfile: Added dockerfile with helper scripts and default configs Signed-off-by: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> --- docker/.gitignore | 1 + docker/Dockerfile | 37 ++++++++++++++++++++++++++++ docker/build_dockerfile.sh | 23 ++++++++++++++++++ docker/install_server.sh | 13 ++++++++++ docker/run_devenv.sh | 33 +++++++++++++++++++++++++ docker/run_server.sh | 29 ++++++++++++++++++++++ docker/server.cfg | 36 ++++++++++++++++++++++++++++ docker/server_central.cfg | 3 +++ docker/server_core.cfg | 8 +++++++ docker/server_msr.cfg | 49 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 232 insertions(+) create mode 100644 docker/.gitignore create mode 100644 docker/Dockerfile create mode 100755 docker/build_dockerfile.sh create mode 100644 docker/install_server.sh create mode 100755 docker/run_devenv.sh create mode 100644 docker/run_server.sh create mode 100644 docker/server.cfg create mode 100644 docker/server_central.cfg create mode 100644 docker/server_core.cfg create mode 100644 docker/server_msr.cfg diff --git a/docker/.gitignore b/docker/.gitignore new file mode 100644 index 00000000..4fc63770 --- /dev/null +++ b/docker/.gitignore @@ -0,0 +1 @@ +hlds/* diff --git a/docker/Dockerfile b/docker/Dockerfile new file mode 100644 index 00000000..9c985f72 --- /dev/null +++ b/docker/Dockerfile @@ -0,0 +1,37 @@ +# syntax=docker/dockerfile:1 +FROM fedora:latest as BASE_IMAGE + +RUN dnf install -y su sudo cmake gcc gcc-c++ pkgconf-pkg-config libstdc++.i686 libstdc++-static.i686 gdb gdbserver strace file binutils patchelf htop nano procps-ng \ + glibc.i686 glibc-devel.i686 \ + glfw-devel.i686 \ + libglvnd-glx.i686 \ + mesa-libGL-devel.i686 \ + protobuf-devel.i686 \ + libcurl-devel.i686 \ + zlib-ng-compat-devel.i686 \ + gtest.i686 gtest-devel.i686 + + +FROM BASE_IMAGE as MSR_BUILDER + +# copy developer configs +COPY ./*.cfg ./*.sh /workspace/scripts/ +RUN chmod -x /workspace/scripts/*.sh && \ + chmod u+x /workspace/scripts/install_server.sh && \ + chmod u+x /workspace/scripts/run_server.sh + +# setup steam user +RUN useradd -m steam && \ + mkdir -p /workspace/server/ && \ + mkdir -p /home/steam/bin + +WORKDIR /home/steam/bin +# install steamCMD and download HLDS (steam_legacy) +RUN curl -sqL "https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz" | tar zxvf - && \ + chown -R steam:steam /home/steam/bin + +# we can check with this env if a script runs inside docker +ENV DOCKER_RUNNING=true + +WORKDIR /workspace/ +ENTRYPOINT ["bash"] diff --git a/docker/build_dockerfile.sh b/docker/build_dockerfile.sh new file mode 100755 index 00000000..2eb414ae --- /dev/null +++ b/docker/build_dockerfile.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +# error on unbound variable +set -u + +readonly red="\033[31m" +readonly normal="\033[0m" + +# check if docker is installed unless ${CONTAINER_BUILDER} is already set +[[ -z "${CONTAINER_BUILDER:-}" ]] && CONTAINER_BUILDER=$(which docker 2>/dev/null) +# if docker is not installed check for podman +[[ -z ${CONTAINER_BUILDER:-} ]] && CONTAINER_BUILDER=$(which podman 2>/dev/null) +# cannot run without either podman or docker, so better exit now +[[ -z ${CONTAINER_BUILDER:-} ]] && { echo "⚠️ Need to have either docker or podman installed!"; exit 1; } + +# If you have just installed podman and want to run without root/sudo you need to assign extra subuids/subgids to your user and run podman system migrate like this: +# +# sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER +# podman system migrate + +${CONTAINER_BUILDER} build . -t msrebirth || exit 1 + +echo -e "🏗️ Finished building ${red}msrebirth${normal} container" diff --git a/docker/install_server.sh b/docker/install_server.sh new file mode 100644 index 00000000..40d26b47 --- /dev/null +++ b/docker/install_server.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +# error on unbound variable +set -u + +[[ ${DOCKER_RUNNING:-} != "true" ]] && { echo "⚠️ This script only runs inside the container."; exit 1; } +[[ -z "${STEAM_USER:-}" ]] && { echo "⚠️ Need to export the environment variable e.g. 'export STEAM_USER=whatever'."; exit 1; } + +echo "⚙️ Running steamCMD" +sudo -u steam /home/steam/bin/steamcmd.sh +force_install_dir /workspace/server/ +login ${STEAM_USER} +app_update 1961680 validate +quit || { echo "⚠️ Installation failed!"; exit 1; } + +# Fix execstack error: 'engine_i486.so: cannot enable executable stack as shared object' +patchelf --clear-execstack /workspace/server/engine_i486.so diff --git a/docker/run_devenv.sh b/docker/run_devenv.sh new file mode 100755 index 00000000..54469705 --- /dev/null +++ b/docker/run_devenv.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +# error on unbound variable +set -u + +readonly red="\033[31m" +readonly normal="\033[0m" +readonly thisdir=$(realpath $(dirname ${BASH_SOURCE[0]})) + +# check if docker is installed unless ${CONTAINER_BUILDER} is already set +[[ -z "${CONTAINER_BUILDER:-}" ]] && CONTAINER_BUILDER=$(which docker 2>/dev/null) +# if docker is not installed check for podman +[[ -z ${CONTAINER_BUILDER:-} ]] && CONTAINER_BUILDER=$(which podman 2>/dev/null) +# cannot run without either podman or docker, so better exit now +[[ -z ${CONTAINER_BUILDER:-} ]] && { echo "⚠️ Need to have either docker or podman installed!"; exit 1; } + +readonly builder=$(basename ${CONTAINER_BUILDER}) + +# check if the image was built +[[ -z "$(${CONTAINER_BUILDER} images -q msrebirth:latest)" ]] && { echo "⚠️ Need to build the ${red}msrebirth${normal} image first!"; exit 1; } + + +# check if the container was never started before +if [[ -z "$(${CONTAINER_BUILDER} container inspect msrebirth --format '{{.Id}}' 2>/dev/null)" ]]; then + echo -e "⚔️ Launching clean ${red}msrebirth${normal} container...\n" + mkdir -p ${thisdir}/hlds + ${CONTAINER_BUILDER} run -it --name msrebirth --hostname msrebirth-debug --net=host -v $(dirname ${thisdir}):/workspace/msrebirth -v ${thisdir}/hlds:/workspace/server msrebirth:latest +else + echo -e "⚔️ Launching existing ${red}msrebirth${normal} container... \ + \n💡 Run '${builder} container rm msrebirth' before starting this script to start clean or to start a new version.\n" + + ${CONTAINER_BUILDER} start --attach --interactive msrebirth +fi diff --git a/docker/run_server.sh b/docker/run_server.sh new file mode 100644 index 00000000..b3e2efec --- /dev/null +++ b/docker/run_server.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +# error on unbound variable +set -u + +readonly red="\033[31m" +readonly normal="\033[0m" +readonly thisdir=$(realpath $(dirname ${BASH_SOURCE[0]})) + +readonly confdir="/workspace/server/msr" +readonly dlldir="/workspace/server/msr/dlls/" + +[[ ${DOCKER_RUNNING:-} != "true" ]] && { echo "⚠️ This script only runs inside the container."; exit 1; } + +echo -e "⚙️ Copying config files to ${red}msrebirth${normal} server directory <${confdir}>.\n" + +# need full binary path because of fedora alias +/usr/bin/cp -f ${thisdir}/*.cfg ${confdir} + +[[ -e /workspace/msrebirth/build/src/game/server/ms.so ]] && { + echo -e "⚙️ Copying built ms.so file to ${red}msrebirth${normal} server directory <${dlldir}>.\n"; + /usr/bin/cp -f /workspace/msrebirth/build/src/game/server/ms.so ${dlldir}/ms.so; +} + +echo -e "⚔️ Starting ${red}msrebirth${normal} server... \ + \n💡 If the error 'engine_i486.so: cannot enable executable stack' appears, run 'patchelf --clear-execstack /workspace/server/engine_i486.so'" + +cd /workspace/server +exec ./msr.sh diff --git a/docker/server.cfg b/docker/server.cfg new file mode 100644 index 00000000..4e39d683 --- /dev/null +++ b/docker/server.cfg @@ -0,0 +1,36 @@ +// Name of the server +hostname "Your Server Name Goes here" + +// Internet server (1 for LAN) +sv_lan 0 + +// Give players at least two minutes to connect +sv_timeout 120 + +// Cuts down on verbosness of console (saves some memory and CPU time) +developer 0 + +// Add your rcon password here (uncomment first) +//rcon_password "mypassword" + +// Voice comm settings (hiqh quality) +sv_voiceenable 1 +sv_voicequality 5 +sv_voicecodec voice_speex + +// Allow all players to hear one another, regardless of team +sv_alltalk 1 +sv_spectalk 1 + +// Custom Content Server for fast downloads, Feel free to make your own +//sv_downloadurl "http://www.example.org/stuff" + +// Disable clients' ability to pause the server +pausable 0 + +exec server_msr.cfg +exec server_bans.cfg +exec server_central.cfg +exec server_core.cfg + +heartbeat diff --git a/docker/server_central.cfg b/docker/server_central.cfg new file mode 100644 index 00000000..ae428bf1 --- /dev/null +++ b/docker/server_central.cfg @@ -0,0 +1,3 @@ +// If you have [FN] access, uncomment, and edit these lines accordingly: +//ms_central_enabled 1 +//ms_central_addr "example.org:5709" diff --git a/docker/server_core.cfg b/docker/server_core.cfg new file mode 100644 index 00000000..e00ef05c --- /dev/null +++ b/docker/server_core.cfg @@ -0,0 +1,8 @@ +sv_rehlds_movecmdrate_max_avg 99999 +sv_rehlds_movecmdrate_max_burst 99999 +sv_rehlds_stringcmdrate_max_avg 99999 +sv_rehlds_stringcmdrate_max_burst 9999 +sv_rehlds_stringcmdrate_burst_punish -1 +sv_rehlds_stringcmdrate_avg_punish -1 +sv_rehlds_movecmdrate_burst_punish -1 +sv_rehlds_movecmdrate_avg_punish -1 diff --git a/docker/server_msr.cfg b/docker/server_msr.cfg new file mode 100644 index 00000000..c6330726 --- /dev/null +++ b/docker/server_msr.cfg @@ -0,0 +1,49 @@ +// Player Vs. Player Settings (0 to disable, 1 enable) +//If you use AMX you should set this in the command line via +ms_pklevel 0 +//This way AMX will be able to enable player killing on the PvP maps. +ms_pklevel 0 + +// Number of characters that can be stored by each player on the server +// Set to 0 for client side characters +ms_serverchar 3 + +// Allow vote kicking (recommend disable, as is buggy - use new system) +ms_allowkickvote 0 + +// Allow voting for time +ms_allowtimevote 1 + +// Automatically reset server to edana if empty after a time in minutes. +ms_reset_time 10 + +// MAP VOTING +msvote_map_enable 1 // allow voting for maps +msvote_farm_all_day 1 // allow voting for the map the players are on +msvote_map_type "all" // (all|root) - allow voting for all maps (save hidden/gauntlet/maze) or restrict to only root towns + +// Allow votekick from chat +msvote_kick_enable 1 + +// Allow voteban from chat +msvote_ban_enable 1 + +// Time player initiated vote-bans last +msvote_ban_time 60 + +// Allow voting for PVP (votepvp at chat) +msvote_pvp_enable 1 + +// Admin Contact (appears when player is kicked/banned or players type contact in console) +ms_admin_contact "[none given]" + +// Write permanent bans to cfg (not required if you exec msc_bans.cfg) +ms_ban_to_cfg 0 + +// Log chat and various server events to monthly chat log +ms_chatlog 0 + +// Change map to Edana this many minutes after the last player leaves +ms_timelimit 10 + +// If this is set to 1, reset (quit) the server, after switching to edana via ms_timelimit +ms_reset_if_empty 0 From df6da889ac483bb7dfca282fb56822c30700f556 Mon Sep 17 00:00:00 2001 From: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> Date: Sun, 29 Mar 2026 15:27:45 +0200 Subject: [PATCH 5/6] stackstring.cpp: Made msstring::c_str() const The data is not modified in the function so it should be const Signed-off-by: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> --- src/game/shared/ms/stackstring.cpp | 2 +- src/game/shared/ms/stackstring.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/game/shared/ms/stackstring.cpp b/src/game/shared/ms/stackstring.cpp index 910a7670..3f64b025 100644 --- a/src/game/shared/ms/stackstring.cpp +++ b/src/game/shared/ms/stackstring.cpp @@ -55,7 +55,7 @@ bool msstring::operator==(const char *a) const { return !strcmp(data, a); } bool msstring::operator==(msstring a) const { return !strcmp(data, a.data); } msstring::operator char *() { return data; } msstring::operator const char *() { return data; } -const char *msstring::c_str() { return data; } +const char *msstring::c_str() const { return data; } char* msstring::str() { if (data[0] == 0) diff --git a/src/game/shared/ms/stackstring.h b/src/game/shared/ms/stackstring.h index a9e5377f..e6657485 100644 --- a/src/game/shared/ms/stackstring.h +++ b/src/game/shared/ms/stackstring.h @@ -190,7 +190,7 @@ class msstring operator char *(); operator const char *(); operator void *() { return operator char *(); } - const char *c_str(); + const char *c_str() const; char* str(); size_t len() const; void append(const char* a); From 85db73db65a303688774c3ce05bcc8be4f7c4c05 Mon Sep 17 00:00:00 2001 From: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> Date: Sat, 11 Apr 2026 15:00:37 +0200 Subject: [PATCH 6/6] Added CPM to build protobuf on windows Also committed the protoc generated files since BPM doesnt support a two stage build to build protoc before running 'cmake -B' Signed-off-by: Genesis <10389486+PuppetMasterHex@users.noreply.github.com> --- CMakeLists.txt | 2 - cmake/CPM.cmake | 1291 +++++++ cmake/protobuf.cmake | 20 + src/game/server/CMakeLists.txt | 20 +- src/game/server/proto/CMakeLists.txt | 5 +- src/game/server/proto/savedata.pb.cc | 4265 ++++++++++++++++++++++ src/game/server/proto/savedata.pb.h | 4937 ++++++++++++++++++++++++++ src/game/server/save/protosave.cpp | 2 +- 8 files changed, 10533 insertions(+), 9 deletions(-) create mode 100644 cmake/CPM.cmake create mode 100644 cmake/protobuf.cmake create mode 100644 src/game/server/proto/savedata.pb.cc create mode 100644 src/game/server/proto/savedata.pb.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 5142421c..6e163696 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -135,8 +135,6 @@ endfunction(set_common_properties) add_compile_definitions($<$:DEBUG> $<$:_DEBUG>) add_compile_definitions($<$:NDEBUG>) -find_package(Protobuf REQUIRED) - # Add Projects add_subdirectory(src/game/client) add_subdirectory(src/game/server) diff --git a/cmake/CPM.cmake b/cmake/CPM.cmake new file mode 100644 index 00000000..eea29211 --- /dev/null +++ b/cmake/CPM.cmake @@ -0,0 +1,1291 @@ +# CPM.cmake - CMake's missing package manager +# =========================================== +# See https://github.com/cpm-cmake/CPM.cmake for usage and update instructions. +# +# MIT License +# ----------- +#[[ + Copyright (c) 2019-2023 Lars Melchior and contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +]] + +cmake_minimum_required(VERSION 3.14 FATAL_ERROR) + +# Initialize logging prefix +if(NOT CPM_INDENT) + set(CPM_INDENT + "CPM:" + CACHE INTERNAL "" + ) +endif() + +if(NOT COMMAND cpm_message) + function(cpm_message) + message(${ARGV}) + endfunction() +endif() + +if(DEFINED EXTRACTED_CPM_VERSION) + set(CURRENT_CPM_VERSION "${EXTRACTED_CPM_VERSION}${CPM_DEVELOPMENT}") +else() + set(CURRENT_CPM_VERSION 0.40.8) +endif() + +get_filename_component(CPM_CURRENT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}" REALPATH) +if(CPM_DIRECTORY) + if(NOT CPM_DIRECTORY STREQUAL CPM_CURRENT_DIRECTORY) + if(CPM_VERSION VERSION_LESS CURRENT_CPM_VERSION) + message( + AUTHOR_WARNING + "${CPM_INDENT} \ +A dependency is using a more recent CPM version (${CURRENT_CPM_VERSION}) than the current project (${CPM_VERSION}). \ +It is recommended to upgrade CPM to the most recent version. \ +See https://github.com/cpm-cmake/CPM.cmake for more information." + ) + endif() + if(${CMAKE_VERSION} VERSION_LESS "3.17.0") + include(FetchContent) + endif() + return() + endif() + + get_property( + CPM_INITIALIZED GLOBAL "" + PROPERTY CPM_INITIALIZED + SET + ) + if(CPM_INITIALIZED) + return() + endif() +endif() + +if(CURRENT_CPM_VERSION MATCHES "development-version") + message( + WARNING "${CPM_INDENT} Your project is using an unstable development version of CPM.cmake. \ +Please update to a recent release if possible. \ +See https://github.com/cpm-cmake/CPM.cmake for details." + ) +endif() + +set_property(GLOBAL PROPERTY CPM_INITIALIZED true) + +macro(cpm_set_policies) + # the policy allows us to change options without caching + cmake_policy(SET CMP0077 NEW) + set(CMAKE_POLICY_DEFAULT_CMP0077 NEW) + + # the policy allows us to change set(CACHE) without caching + if(POLICY CMP0126) + cmake_policy(SET CMP0126 NEW) + set(CMAKE_POLICY_DEFAULT_CMP0126 NEW) + endif() + + # The policy uses the download time for timestamp, instead of the timestamp in the archive. This + # allows for proper rebuilds when a projects url changes + if(POLICY CMP0135) + cmake_policy(SET CMP0135 NEW) + set(CMAKE_POLICY_DEFAULT_CMP0135 NEW) + endif() + + # treat relative git repository paths as being relative to the parent project's remote + if(POLICY CMP0150) + cmake_policy(SET CMP0150 NEW) + set(CMAKE_POLICY_DEFAULT_CMP0150 NEW) + endif() +endmacro() +cpm_set_policies() + +option(CPM_USE_LOCAL_PACKAGES "Always try to use `find_package` to get dependencies" + $ENV{CPM_USE_LOCAL_PACKAGES} +) +option(CPM_LOCAL_PACKAGES_ONLY "Only use `find_package` to get dependencies" + $ENV{CPM_LOCAL_PACKAGES_ONLY} +) +option(CPM_DOWNLOAD_ALL "Always download dependencies from source" $ENV{CPM_DOWNLOAD_ALL}) +option(CPM_DONT_UPDATE_MODULE_PATH "Don't update the module path to allow using find_package" + $ENV{CPM_DONT_UPDATE_MODULE_PATH} +) +option(CPM_DONT_CREATE_PACKAGE_LOCK "Don't create a package lock file in the binary path" + $ENV{CPM_DONT_CREATE_PACKAGE_LOCK} +) +option(CPM_INCLUDE_ALL_IN_PACKAGE_LOCK + "Add all packages added through CPM.cmake to the package lock" + $ENV{CPM_INCLUDE_ALL_IN_PACKAGE_LOCK} +) +option(CPM_USE_NAMED_CACHE_DIRECTORIES + "Use additional directory of package name in cache on the most nested level." + $ENV{CPM_USE_NAMED_CACHE_DIRECTORIES} +) + +set(CPM_VERSION + ${CURRENT_CPM_VERSION} + CACHE INTERNAL "" +) +set(CPM_DIRECTORY + ${CPM_CURRENT_DIRECTORY} + CACHE INTERNAL "" +) +set(CPM_FILE + ${CMAKE_CURRENT_LIST_FILE} + CACHE INTERNAL "" +) +set(CPM_PACKAGES + "" + CACHE INTERNAL "" +) +set(CPM_DRY_RUN + OFF + CACHE INTERNAL "Don't download or configure dependencies (for testing)" +) + +if(DEFINED ENV{CPM_SOURCE_CACHE}) + set(CPM_SOURCE_CACHE_DEFAULT $ENV{CPM_SOURCE_CACHE}) +else() + set(CPM_SOURCE_CACHE_DEFAULT OFF) +endif() + +set(CPM_SOURCE_CACHE + ${CPM_SOURCE_CACHE_DEFAULT} + CACHE PATH "Directory to download CPM dependencies" +) + +if(NOT CPM_DONT_UPDATE_MODULE_PATH AND NOT DEFINED CMAKE_FIND_PACKAGE_REDIRECTS_DIR) + set(CPM_MODULE_PATH + "${CMAKE_BINARY_DIR}/CPM_modules" + CACHE INTERNAL "" + ) + # remove old modules + file(REMOVE_RECURSE ${CPM_MODULE_PATH}) + file(MAKE_DIRECTORY ${CPM_MODULE_PATH}) + # locally added CPM modules should override global packages + set(CMAKE_MODULE_PATH "${CPM_MODULE_PATH};${CMAKE_MODULE_PATH}") +endif() + +if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) + set(CPM_PACKAGE_LOCK_FILE + "${CMAKE_BINARY_DIR}/cpm-package-lock.cmake" + CACHE INTERNAL "" + ) + file(WRITE ${CPM_PACKAGE_LOCK_FILE} + "# CPM Package Lock\n# This file should be committed to version control\n\n" + ) +endif() + +include(FetchContent) + +# Try to infer package name from git repository uri (path or url) +function(cpm_package_name_from_git_uri URI RESULT) + if("${URI}" MATCHES "([^/:]+)/?.git/?$") + set(${RESULT} + ${CMAKE_MATCH_1} + PARENT_SCOPE + ) + else() + unset(${RESULT} PARENT_SCOPE) + endif() +endfunction() + +# Try to infer package name and version from a url +function(cpm_package_name_and_ver_from_url url outName outVer) + if(url MATCHES "[/\\?]([a-zA-Z0-9_\\.-]+)\\.(tar|tar\\.gz|tar\\.bz2|zip|ZIP)(\\?|/|$)") + # We matched an archive + set(filename "${CMAKE_MATCH_1}") + + if(filename MATCHES "([a-zA-Z0-9_\\.-]+)[_-]v?(([0-9]+\\.)*[0-9]+[a-zA-Z0-9]*)") + # We matched - (ie foo-1.2.3) + set(${outName} + "${CMAKE_MATCH_1}" + PARENT_SCOPE + ) + set(${outVer} + "${CMAKE_MATCH_2}" + PARENT_SCOPE + ) + elseif(filename MATCHES "(([0-9]+\\.)+[0-9]+[a-zA-Z0-9]*)") + # We couldn't find a name, but we found a version + # + # In many cases (which we don't handle here) the url would look something like + # `irrelevant/ACTUAL_PACKAGE_NAME/irrelevant/1.2.3.zip`. In such a case we can't possibly + # distinguish the package name from the irrelevant bits. Moreover if we try to match the + # package name from the filename, we'd get bogus at best. + unset(${outName} PARENT_SCOPE) + set(${outVer} + "${CMAKE_MATCH_1}" + PARENT_SCOPE + ) + else() + # Boldly assume that the file name is the package name. + # + # Yes, something like `irrelevant/ACTUAL_NAME/irrelevant/download.zip` will ruin our day, but + # such cases should be quite rare. No popular service does this... we think. + set(${outName} + "${filename}" + PARENT_SCOPE + ) + unset(${outVer} PARENT_SCOPE) + endif() + else() + # No ideas yet what to do with non-archives + unset(${outName} PARENT_SCOPE) + unset(${outVer} PARENT_SCOPE) + endif() +endfunction() + +function(cpm_find_package NAME VERSION) + string(REPLACE " " ";" EXTRA_ARGS "${ARGN}") + find_package(${NAME} ${VERSION} ${EXTRA_ARGS} QUIET) + if(${CPM_ARGS_NAME}_FOUND) + if(DEFINED ${CPM_ARGS_NAME}_VERSION) + set(VERSION ${${CPM_ARGS_NAME}_VERSION}) + endif() + cpm_message(STATUS "${CPM_INDENT} Using local package ${CPM_ARGS_NAME}@${VERSION}") + CPMRegisterPackage(${CPM_ARGS_NAME} "${VERSION}") + set(CPM_PACKAGE_FOUND + YES + PARENT_SCOPE + ) + else() + set(CPM_PACKAGE_FOUND + NO + PARENT_SCOPE + ) + endif() +endfunction() + +# Create a custom FindXXX.cmake module for a CPM package This prevents `find_package(NAME)` from +# finding the system library +function(cpm_create_module_file Name) + if(NOT CPM_DONT_UPDATE_MODULE_PATH) + if(DEFINED CMAKE_FIND_PACKAGE_REDIRECTS_DIR) + # Redirect find_package calls to the CPM package. This is what FetchContent does when you set + # OVERRIDE_FIND_PACKAGE. The CMAKE_FIND_PACKAGE_REDIRECTS_DIR works for find_package in CONFIG + # mode, unlike the Find${Name}.cmake fallback. CMAKE_FIND_PACKAGE_REDIRECTS_DIR is not defined + # in script mode, or in CMake < 3.24. + # https://cmake.org/cmake/help/latest/module/FetchContent.html#fetchcontent-find-package-integration-examples + string(TOLOWER ${Name} NameLower) + file(WRITE ${CMAKE_FIND_PACKAGE_REDIRECTS_DIR}/${NameLower}-config.cmake + "include(\"\${CMAKE_CURRENT_LIST_DIR}/${NameLower}-extra.cmake\" OPTIONAL)\n" + "include(\"\${CMAKE_CURRENT_LIST_DIR}/${Name}Extra.cmake\" OPTIONAL)\n" + ) + file(WRITE ${CMAKE_FIND_PACKAGE_REDIRECTS_DIR}/${NameLower}-config-version.cmake + "set(PACKAGE_VERSION_COMPATIBLE TRUE)\n" "set(PACKAGE_VERSION_EXACT TRUE)\n" + ) + else() + file(WRITE ${CPM_MODULE_PATH}/Find${Name}.cmake + "include(\"${CPM_FILE}\")\n${ARGN}\nset(${Name}_FOUND TRUE)" + ) + endif() + endif() +endfunction() + +# Find a package locally or fallback to CPMAddPackage +function(CPMFindPackage) + set(oneValueArgs NAME VERSION GIT_TAG FIND_PACKAGE_ARGUMENTS) + + cmake_parse_arguments(CPM_ARGS "" "${oneValueArgs}" "" ${ARGN}) + + if(NOT DEFINED CPM_ARGS_VERSION) + if(DEFINED CPM_ARGS_GIT_TAG) + cpm_get_version_from_git_tag("${CPM_ARGS_GIT_TAG}" CPM_ARGS_VERSION) + endif() + endif() + + set(downloadPackage ${CPM_DOWNLOAD_ALL}) + if(DEFINED CPM_DOWNLOAD_${CPM_ARGS_NAME}) + set(downloadPackage ${CPM_DOWNLOAD_${CPM_ARGS_NAME}}) + elseif(DEFINED ENV{CPM_DOWNLOAD_${CPM_ARGS_NAME}}) + set(downloadPackage $ENV{CPM_DOWNLOAD_${CPM_ARGS_NAME}}) + endif() + if(downloadPackage) + CPMAddPackage(${ARGN}) + cpm_export_variables(${CPM_ARGS_NAME}) + return() + endif() + + cpm_find_package(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}" ${CPM_ARGS_FIND_PACKAGE_ARGUMENTS}) + + if(NOT CPM_PACKAGE_FOUND) + CPMAddPackage(${ARGN}) + cpm_export_variables(${CPM_ARGS_NAME}) + endif() + +endfunction() + +# checks if a package has been added before +function(cpm_check_if_package_already_added CPM_ARGS_NAME CPM_ARGS_VERSION) + if("${CPM_ARGS_NAME}" IN_LIST CPM_PACKAGES) + CPMGetPackageVersion(${CPM_ARGS_NAME} CPM_PACKAGE_VERSION) + if("${CPM_PACKAGE_VERSION}" VERSION_LESS "${CPM_ARGS_VERSION}") + message( + WARNING + "${CPM_INDENT} Requires a newer version of ${CPM_ARGS_NAME} (${CPM_ARGS_VERSION}) than currently included (${CPM_PACKAGE_VERSION})." + ) + endif() + cpm_get_fetch_properties(${CPM_ARGS_NAME}) + set(${CPM_ARGS_NAME}_ADDED NO) + set(CPM_PACKAGE_ALREADY_ADDED + YES + PARENT_SCOPE + ) + cpm_export_variables(${CPM_ARGS_NAME}) + else() + set(CPM_PACKAGE_ALREADY_ADDED + NO + PARENT_SCOPE + ) + endif() +endfunction() + +# Parse the argument of CPMAddPackage in case a single one was provided and convert it to a list of +# arguments which can then be parsed idiomatically. For example gh:foo/bar@1.2.3 will be converted +# to: GITHUB_REPOSITORY;foo/bar;VERSION;1.2.3 +function(cpm_parse_add_package_single_arg arg outArgs) + # Look for a scheme + if("${arg}" MATCHES "^([a-zA-Z]+):(.+)$") + string(TOLOWER "${CMAKE_MATCH_1}" scheme) + set(uri "${CMAKE_MATCH_2}") + + # Check for CPM-specific schemes + if(scheme STREQUAL "gh") + set(out "GITHUB_REPOSITORY;${uri}") + set(packageType "git") + elseif(scheme STREQUAL "gl") + set(out "GITLAB_REPOSITORY;${uri}") + set(packageType "git") + elseif(scheme STREQUAL "bb") + set(out "BITBUCKET_REPOSITORY;${uri}") + set(packageType "git") + # A CPM-specific scheme was not found. Looks like this is a generic URL so try to determine + # type + elseif(arg MATCHES ".git/?(@|#|$)") + set(out "GIT_REPOSITORY;${arg}") + set(packageType "git") + else() + # Fall back to a URL + set(out "URL;${arg}") + set(packageType "archive") + + # We could also check for SVN since FetchContent supports it, but SVN is so rare these days. + # We just won't bother with the additional complexity it will induce in this function. SVN is + # done by multi-arg + endif() + else() + if(arg MATCHES ".git/?(@|#|$)") + set(out "GIT_REPOSITORY;${arg}") + set(packageType "git") + else() + # Give up + message(FATAL_ERROR "${CPM_INDENT} Can't determine package type of '${arg}'") + endif() + endif() + + # For all packages we interpret @... as version. Only replace the last occurrence. Thus URIs + # containing '@' can be used + string(REGEX REPLACE "@([^@]+)$" ";VERSION;\\1" out "${out}") + + # Parse the rest according to package type + if(packageType STREQUAL "git") + # For git repos we interpret #... as a tag or branch or commit hash + string(REGEX REPLACE "#([^#]+)$" ";GIT_TAG;\\1" out "${out}") + elseif(packageType STREQUAL "archive") + # For archives we interpret #... as a URL hash. + string(REGEX REPLACE "#([^#]+)$" ";URL_HASH;\\1" out "${out}") + # We don't try to parse the version if it's not provided explicitly. cpm_get_version_from_url + # should do this at a later point + else() + # We should never get here. This is an assertion and hitting it means there's a problem with the + # code above. A packageType was set, but not handled by this if-else. + message(FATAL_ERROR "${CPM_INDENT} Unsupported package type '${packageType}' of '${arg}'") + endif() + + set(${outArgs} + ${out} + PARENT_SCOPE + ) +endfunction() + +# Check that the working directory for a git repo is clean +function(cpm_check_git_working_dir_is_clean repoPath gitTag isClean) + + find_package(Git REQUIRED) + + if(NOT GIT_EXECUTABLE) + # No git executable, assume directory is clean + set(${isClean} + TRUE + PARENT_SCOPE + ) + return() + endif() + + # check for uncommitted changes + execute_process( + COMMAND ${GIT_EXECUTABLE} status --porcelain + RESULT_VARIABLE resultGitStatus + OUTPUT_VARIABLE repoStatus + OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET + WORKING_DIRECTORY ${repoPath} + ) + if(resultGitStatus) + # not supposed to happen, assume clean anyway + message(WARNING "${CPM_INDENT} Calling git status on folder ${repoPath} failed") + set(${isClean} + TRUE + PARENT_SCOPE + ) + return() + endif() + + if(NOT "${repoStatus}" STREQUAL "") + set(${isClean} + FALSE + PARENT_SCOPE + ) + return() + endif() + + # check for committed changes + execute_process( + COMMAND ${GIT_EXECUTABLE} diff -s --exit-code ${gitTag} + RESULT_VARIABLE resultGitDiff + OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_QUIET + WORKING_DIRECTORY ${repoPath} + ) + + if(${resultGitDiff} EQUAL 0) + set(${isClean} + TRUE + PARENT_SCOPE + ) + else() + set(${isClean} + FALSE + PARENT_SCOPE + ) + endif() + +endfunction() + +# Add PATCH_COMMAND to CPM_ARGS_UNPARSED_ARGUMENTS. This method consumes a list of files in ARGN +# then generates a `PATCH_COMMAND` appropriate for `ExternalProject_Add()`. This command is appended +# to the parent scope's `CPM_ARGS_UNPARSED_ARGUMENTS`. +function(cpm_add_patches) + # Return if no patch files are supplied. + if(NOT ARGN) + return() + endif() + + # Find the patch program. + find_program(PATCH_EXECUTABLE patch) + if(CMAKE_HOST_WIN32 AND NOT PATCH_EXECUTABLE) + # The Windows git executable is distributed with patch.exe. Find the path to the executable, if + # it exists, then search `../usr/bin` and `../../usr/bin` for patch.exe. + find_package(Git QUIET) + if(GIT_EXECUTABLE) + get_filename_component(extra_search_path ${GIT_EXECUTABLE} DIRECTORY) + get_filename_component(extra_search_path_1up ${extra_search_path} DIRECTORY) + get_filename_component(extra_search_path_2up ${extra_search_path_1up} DIRECTORY) + find_program( + PATCH_EXECUTABLE patch HINTS "${extra_search_path_1up}/usr/bin" + "${extra_search_path_2up}/usr/bin" + ) + endif() + endif() + if(NOT PATCH_EXECUTABLE) + message(FATAL_ERROR "Couldn't find `patch` executable to use with PATCHES keyword.") + endif() + + # Create a temporary + set(temp_list ${CPM_ARGS_UNPARSED_ARGUMENTS}) + + # Ensure each file exists (or error out) and add it to the list. + set(first_item True) + foreach(PATCH_FILE ${ARGN}) + # Make sure the patch file exists, if we can't find it, try again in the current directory. + if(NOT EXISTS "${PATCH_FILE}") + if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/${PATCH_FILE}") + message(FATAL_ERROR "Couldn't find patch file: '${PATCH_FILE}'") + endif() + set(PATCH_FILE "${CMAKE_CURRENT_LIST_DIR}/${PATCH_FILE}") + endif() + + # Convert to absolute path for use with patch file command. + get_filename_component(PATCH_FILE "${PATCH_FILE}" ABSOLUTE) + + # The first patch entry must be preceded by "PATCH_COMMAND" while the following items are + # preceded by "&&". + if(first_item) + set(first_item False) + list(APPEND temp_list "PATCH_COMMAND") + else() + list(APPEND temp_list "&&") + endif() + # Add the patch command to the list + list(APPEND temp_list "${PATCH_EXECUTABLE}" "-p1" "<" "${PATCH_FILE}") + endforeach() + + # Move temp out into parent scope. + set(CPM_ARGS_UNPARSED_ARGUMENTS + ${temp_list} + PARENT_SCOPE + ) + +endfunction() + +# method to overwrite internal FetchContent properties, to allow using CPM.cmake to overload +# FetchContent calls. As these are internal cmake properties, this method should be used carefully +# and may need modification in future CMake versions. Source: +# https://github.com/Kitware/CMake/blob/dc3d0b5a0a7d26d43d6cfeb511e224533b5d188f/Modules/FetchContent.cmake#L1152 +function(cpm_override_fetchcontent contentName) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "SOURCE_DIR;BINARY_DIR" "") + if(NOT "${arg_UNPARSED_ARGUMENTS}" STREQUAL "") + message(FATAL_ERROR "${CPM_INDENT} Unsupported arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + string(TOLOWER ${contentName} contentNameLower) + set(prefix "_FetchContent_${contentNameLower}") + + set(propertyName "${prefix}_sourceDir") + define_property( + GLOBAL + PROPERTY ${propertyName} + BRIEF_DOCS "Internal implementation detail of FetchContent_Populate()" + FULL_DOCS "Details used by FetchContent_Populate() for ${contentName}" + ) + set_property(GLOBAL PROPERTY ${propertyName} "${arg_SOURCE_DIR}") + + set(propertyName "${prefix}_binaryDir") + define_property( + GLOBAL + PROPERTY ${propertyName} + BRIEF_DOCS "Internal implementation detail of FetchContent_Populate()" + FULL_DOCS "Details used by FetchContent_Populate() for ${contentName}" + ) + set_property(GLOBAL PROPERTY ${propertyName} "${arg_BINARY_DIR}") + + set(propertyName "${prefix}_populated") + define_property( + GLOBAL + PROPERTY ${propertyName} + BRIEF_DOCS "Internal implementation detail of FetchContent_Populate()" + FULL_DOCS "Details used by FetchContent_Populate() for ${contentName}" + ) + set_property(GLOBAL PROPERTY ${propertyName} TRUE) +endfunction() + +# Download and add a package from source +function(CPMAddPackage) + cpm_set_policies() + + list(LENGTH ARGN argnLength) + if(argnLength EQUAL 1) + cpm_parse_add_package_single_arg("${ARGN}" ARGN) + + # The shorthand syntax implies EXCLUDE_FROM_ALL and SYSTEM + set(ARGN "${ARGN};EXCLUDE_FROM_ALL;YES;SYSTEM;YES;") + endif() + + set(oneValueArgs + NAME + FORCE + VERSION + GIT_TAG + DOWNLOAD_ONLY + GITHUB_REPOSITORY + GITLAB_REPOSITORY + BITBUCKET_REPOSITORY + GIT_REPOSITORY + SOURCE_DIR + FIND_PACKAGE_ARGUMENTS + NO_CACHE + SYSTEM + GIT_SHALLOW + EXCLUDE_FROM_ALL + SOURCE_SUBDIR + CUSTOM_CACHE_KEY + ) + + set(multiValueArgs URL OPTIONS DOWNLOAD_COMMAND PATCHES) + + cmake_parse_arguments(CPM_ARGS "" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}") + + # Set default values for arguments + + if(NOT DEFINED CPM_ARGS_VERSION) + if(DEFINED CPM_ARGS_GIT_TAG) + cpm_get_version_from_git_tag("${CPM_ARGS_GIT_TAG}" CPM_ARGS_VERSION) + endif() + endif() + + if(CPM_ARGS_DOWNLOAD_ONLY) + set(DOWNLOAD_ONLY ${CPM_ARGS_DOWNLOAD_ONLY}) + else() + set(DOWNLOAD_ONLY NO) + endif() + + if(DEFINED CPM_ARGS_GITHUB_REPOSITORY) + set(CPM_ARGS_GIT_REPOSITORY "https://github.com/${CPM_ARGS_GITHUB_REPOSITORY}.git") + elseif(DEFINED CPM_ARGS_GITLAB_REPOSITORY) + set(CPM_ARGS_GIT_REPOSITORY "https://gitlab.com/${CPM_ARGS_GITLAB_REPOSITORY}.git") + elseif(DEFINED CPM_ARGS_BITBUCKET_REPOSITORY) + set(CPM_ARGS_GIT_REPOSITORY "https://bitbucket.org/${CPM_ARGS_BITBUCKET_REPOSITORY}.git") + endif() + + if(DEFINED CPM_ARGS_GIT_REPOSITORY) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_REPOSITORY ${CPM_ARGS_GIT_REPOSITORY}) + if(NOT DEFINED CPM_ARGS_GIT_TAG) + set(CPM_ARGS_GIT_TAG v${CPM_ARGS_VERSION}) + endif() + + # If a name wasn't provided, try to infer it from the git repo + if(NOT DEFINED CPM_ARGS_NAME) + cpm_package_name_from_git_uri(${CPM_ARGS_GIT_REPOSITORY} CPM_ARGS_NAME) + endif() + endif() + + set(CPM_SKIP_FETCH FALSE) + + if(DEFINED CPM_ARGS_GIT_TAG) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_TAG ${CPM_ARGS_GIT_TAG}) + # If GIT_SHALLOW is explicitly specified, honor the value. + if(DEFINED CPM_ARGS_GIT_SHALLOW) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_SHALLOW ${CPM_ARGS_GIT_SHALLOW}) + endif() + endif() + + if(DEFINED CPM_ARGS_URL) + # If a name or version aren't provided, try to infer them from the URL + list(GET CPM_ARGS_URL 0 firstUrl) + cpm_package_name_and_ver_from_url(${firstUrl} nameFromUrl verFromUrl) + # If we fail to obtain name and version from the first URL, we could try other URLs if any. + # However multiple URLs are expected to be quite rare, so for now we won't bother. + + # If the caller provided their own name and version, they trump the inferred ones. + if(NOT DEFINED CPM_ARGS_NAME) + set(CPM_ARGS_NAME ${nameFromUrl}) + endif() + if(NOT DEFINED CPM_ARGS_VERSION) + set(CPM_ARGS_VERSION ${verFromUrl}) + endif() + + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS URL "${CPM_ARGS_URL}") + endif() + + # Check for required arguments + + if(NOT DEFINED CPM_ARGS_NAME) + message( + FATAL_ERROR + "${CPM_INDENT} 'NAME' was not provided and couldn't be automatically inferred for package added with arguments: '${ARGN}'" + ) + endif() + + # Check if package has been added before + cpm_check_if_package_already_added(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}") + if(CPM_PACKAGE_ALREADY_ADDED) + cpm_export_variables(${CPM_ARGS_NAME}) + return() + endif() + + # Check for manual overrides + if(NOT CPM_ARGS_FORCE AND NOT "${CPM_${CPM_ARGS_NAME}_SOURCE}" STREQUAL "") + set(PACKAGE_SOURCE ${CPM_${CPM_ARGS_NAME}_SOURCE}) + set(CPM_${CPM_ARGS_NAME}_SOURCE "") + CPMAddPackage( + NAME "${CPM_ARGS_NAME}" + SOURCE_DIR "${PACKAGE_SOURCE}" + EXCLUDE_FROM_ALL "${CPM_ARGS_EXCLUDE_FROM_ALL}" + SYSTEM "${CPM_ARGS_SYSTEM}" + PATCHES "${CPM_ARGS_PATCHES}" + OPTIONS "${CPM_ARGS_OPTIONS}" + SOURCE_SUBDIR "${CPM_ARGS_SOURCE_SUBDIR}" + DOWNLOAD_ONLY "${DOWNLOAD_ONLY}" + FORCE True + ) + cpm_export_variables(${CPM_ARGS_NAME}) + return() + endif() + + # Check for available declaration + if(NOT CPM_ARGS_FORCE AND NOT "${CPM_DECLARATION_${CPM_ARGS_NAME}}" STREQUAL "") + set(declaration ${CPM_DECLARATION_${CPM_ARGS_NAME}}) + set(CPM_DECLARATION_${CPM_ARGS_NAME} "") + CPMAddPackage(${declaration}) + cpm_export_variables(${CPM_ARGS_NAME}) + # checking again to ensure version and option compatibility + cpm_check_if_package_already_added(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}") + return() + endif() + + if(NOT CPM_ARGS_FORCE) + if(CPM_USE_LOCAL_PACKAGES OR CPM_LOCAL_PACKAGES_ONLY) + cpm_find_package(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}" ${CPM_ARGS_FIND_PACKAGE_ARGUMENTS}) + + if(CPM_PACKAGE_FOUND) + cpm_export_variables(${CPM_ARGS_NAME}) + return() + endif() + + if(CPM_LOCAL_PACKAGES_ONLY) + message( + SEND_ERROR + "${CPM_INDENT} ${CPM_ARGS_NAME} not found via find_package(${CPM_ARGS_NAME} ${CPM_ARGS_VERSION})" + ) + endif() + endif() + endif() + + CPMRegisterPackage("${CPM_ARGS_NAME}" "${CPM_ARGS_VERSION}") + + if(DEFINED CPM_ARGS_GIT_TAG) + set(PACKAGE_INFO "${CPM_ARGS_GIT_TAG}") + elseif(DEFINED CPM_ARGS_SOURCE_DIR) + set(PACKAGE_INFO "${CPM_ARGS_SOURCE_DIR}") + else() + set(PACKAGE_INFO "${CPM_ARGS_VERSION}") + endif() + + if(DEFINED FETCHCONTENT_BASE_DIR) + # respect user's FETCHCONTENT_BASE_DIR if set + set(CPM_FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR}) + else() + set(CPM_FETCHCONTENT_BASE_DIR ${CMAKE_BINARY_DIR}/_deps) + endif() + + cpm_add_patches(${CPM_ARGS_PATCHES}) + + if(DEFINED CPM_ARGS_DOWNLOAD_COMMAND) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS DOWNLOAD_COMMAND ${CPM_ARGS_DOWNLOAD_COMMAND}) + elseif(DEFINED CPM_ARGS_SOURCE_DIR) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS SOURCE_DIR ${CPM_ARGS_SOURCE_DIR}) + if(NOT IS_ABSOLUTE ${CPM_ARGS_SOURCE_DIR}) + # Expand `CPM_ARGS_SOURCE_DIR` relative path. This is important because EXISTS doesn't work + # for relative paths. + get_filename_component( + source_directory ${CPM_ARGS_SOURCE_DIR} REALPATH BASE_DIR ${CMAKE_CURRENT_BINARY_DIR} + ) + else() + set(source_directory ${CPM_ARGS_SOURCE_DIR}) + endif() + if(NOT EXISTS ${source_directory}) + string(TOLOWER ${CPM_ARGS_NAME} lower_case_name) + # remove timestamps so CMake will re-download the dependency + file(REMOVE_RECURSE "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-subbuild") + endif() + elseif(CPM_SOURCE_CACHE AND NOT CPM_ARGS_NO_CACHE) + string(TOLOWER ${CPM_ARGS_NAME} lower_case_name) + set(origin_parameters ${CPM_ARGS_UNPARSED_ARGUMENTS}) + list(SORT origin_parameters) + if(CPM_ARGS_CUSTOM_CACHE_KEY) + # Application set a custom unique directory name + set(download_directory ${CPM_SOURCE_CACHE}/${lower_case_name}/${CPM_ARGS_CUSTOM_CACHE_KEY}) + elseif(CPM_USE_NAMED_CACHE_DIRECTORIES) + string(SHA1 origin_hash "${origin_parameters};NEW_CACHE_STRUCTURE_TAG") + set(download_directory ${CPM_SOURCE_CACHE}/${lower_case_name}/${origin_hash}/${CPM_ARGS_NAME}) + else() + string(SHA1 origin_hash "${origin_parameters}") + set(download_directory ${CPM_SOURCE_CACHE}/${lower_case_name}/${origin_hash}) + endif() + # Expand `download_directory` relative path. This is important because EXISTS doesn't work for + # relative paths. + get_filename_component(download_directory ${download_directory} ABSOLUTE) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS SOURCE_DIR ${download_directory}) + + if(CPM_SOURCE_CACHE) + file(LOCK ${download_directory}/../cmake.lock) + endif() + + if(EXISTS ${download_directory}) + if(CPM_SOURCE_CACHE) + file(LOCK ${download_directory}/../cmake.lock RELEASE) + endif() + + cpm_store_fetch_properties( + ${CPM_ARGS_NAME} "${download_directory}" + "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-build" + ) + cpm_get_fetch_properties("${CPM_ARGS_NAME}") + + if(DEFINED CPM_ARGS_GIT_TAG AND NOT (PATCH_COMMAND IN_LIST CPM_ARGS_UNPARSED_ARGUMENTS)) + # warn if cache has been changed since checkout + cpm_check_git_working_dir_is_clean(${download_directory} ${CPM_ARGS_GIT_TAG} IS_CLEAN) + if(NOT ${IS_CLEAN}) + message( + WARNING "${CPM_INDENT} Cache for ${CPM_ARGS_NAME} (${download_directory}) is dirty" + ) + endif() + endif() + + cpm_add_subdirectory( + "${CPM_ARGS_NAME}" + "${DOWNLOAD_ONLY}" + "${${CPM_ARGS_NAME}_SOURCE_DIR}/${CPM_ARGS_SOURCE_SUBDIR}" + "${${CPM_ARGS_NAME}_BINARY_DIR}" + "${CPM_ARGS_EXCLUDE_FROM_ALL}" + "${CPM_ARGS_SYSTEM}" + "${CPM_ARGS_OPTIONS}" + ) + set(PACKAGE_INFO "${PACKAGE_INFO} at ${download_directory}") + + # As the source dir is already cached/populated, we override the call to FetchContent. + set(CPM_SKIP_FETCH TRUE) + cpm_override_fetchcontent( + "${lower_case_name}" SOURCE_DIR "${${CPM_ARGS_NAME}_SOURCE_DIR}/${CPM_ARGS_SOURCE_SUBDIR}" + BINARY_DIR "${${CPM_ARGS_NAME}_BINARY_DIR}" + ) + + else() + # Enable shallow clone when GIT_TAG is not a commit hash. Our guess may not be accurate, but + # it should guarantee no commit hash get mis-detected. + if(NOT DEFINED CPM_ARGS_GIT_SHALLOW) + cpm_is_git_tag_commit_hash("${CPM_ARGS_GIT_TAG}" IS_HASH) + if(NOT ${IS_HASH}) + list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_SHALLOW TRUE) + endif() + endif() + + # remove timestamps so CMake will re-download the dependency + file(REMOVE_RECURSE ${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-subbuild) + set(PACKAGE_INFO "${PACKAGE_INFO} to ${download_directory}") + endif() + endif() + + if(NOT "${DOWNLOAD_ONLY}") + cpm_create_module_file(${CPM_ARGS_NAME} "CPMAddPackage(\"${ARGN}\")") + endif() + + if(CPM_PACKAGE_LOCK_ENABLED) + if((CPM_ARGS_VERSION AND NOT CPM_ARGS_SOURCE_DIR) OR CPM_INCLUDE_ALL_IN_PACKAGE_LOCK) + cpm_add_to_package_lock(${CPM_ARGS_NAME} "${ARGN}") + elseif(CPM_ARGS_SOURCE_DIR) + cpm_add_comment_to_package_lock(${CPM_ARGS_NAME} "local directory") + else() + cpm_add_comment_to_package_lock(${CPM_ARGS_NAME} "${ARGN}") + endif() + endif() + + cpm_message( + STATUS "${CPM_INDENT} Adding package ${CPM_ARGS_NAME}@${CPM_ARGS_VERSION} (${PACKAGE_INFO})" + ) + + if(NOT CPM_SKIP_FETCH) + # CMake 3.28 added EXCLUDE, SYSTEM (3.25), and SOURCE_SUBDIR (3.18) to FetchContent_Declare. + # Calling FetchContent_MakeAvailable will then internally forward these options to + # add_subdirectory. Up until these changes, we had to call FetchContent_Populate and + # add_subdirectory separately, which is no longer necessary and has been deprecated as of 3.30. + # A Bug in CMake prevents us to use the non-deprecated functions until 3.30.3. + set(fetchContentDeclareExtraArgs "") + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.30.3") + if(${CPM_ARGS_EXCLUDE_FROM_ALL}) + list(APPEND fetchContentDeclareExtraArgs EXCLUDE_FROM_ALL) + endif() + if(${CPM_ARGS_SYSTEM}) + list(APPEND fetchContentDeclareExtraArgs SYSTEM) + endif() + if(DEFINED CPM_ARGS_SOURCE_SUBDIR) + list(APPEND fetchContentDeclareExtraArgs SOURCE_SUBDIR ${CPM_ARGS_SOURCE_SUBDIR}) + endif() + # For CMake version <3.28 OPTIONS are parsed in cpm_add_subdirectory + if(CPM_ARGS_OPTIONS AND NOT DOWNLOAD_ONLY) + foreach(OPTION ${CPM_ARGS_OPTIONS}) + cpm_parse_option("${OPTION}") + set(${OPTION_KEY} "${OPTION_VALUE}") + endforeach() + endif() + endif() + cpm_declare_fetch( + "${CPM_ARGS_NAME}" ${fetchContentDeclareExtraArgs} "${CPM_ARGS_UNPARSED_ARGUMENTS}" + ) + + cpm_fetch_package("${CPM_ARGS_NAME}" ${DOWNLOAD_ONLY} populated ${CPM_ARGS_UNPARSED_ARGUMENTS}) + if(CPM_SOURCE_CACHE AND download_directory) + file(LOCK ${download_directory}/../cmake.lock RELEASE) + endif() + if(${populated} AND ${CMAKE_VERSION} VERSION_LESS "3.30.3") + cpm_add_subdirectory( + "${CPM_ARGS_NAME}" + "${DOWNLOAD_ONLY}" + "${${CPM_ARGS_NAME}_SOURCE_DIR}/${CPM_ARGS_SOURCE_SUBDIR}" + "${${CPM_ARGS_NAME}_BINARY_DIR}" + "${CPM_ARGS_EXCLUDE_FROM_ALL}" + "${CPM_ARGS_SYSTEM}" + "${CPM_ARGS_OPTIONS}" + ) + endif() + cpm_get_fetch_properties("${CPM_ARGS_NAME}") + endif() + + set(${CPM_ARGS_NAME}_ADDED YES) + cpm_export_variables("${CPM_ARGS_NAME}") +endfunction() + +# Fetch a previously declared package +macro(CPMGetPackage Name) + if(DEFINED "CPM_DECLARATION_${Name}") + CPMAddPackage(NAME ${Name}) + else() + message(SEND_ERROR "${CPM_INDENT} Cannot retrieve package ${Name}: no declaration available") + endif() +endmacro() + +# export variables available to the caller to the parent scope expects ${CPM_ARGS_NAME} to be set +macro(cpm_export_variables name) + set(${name}_SOURCE_DIR + "${${name}_SOURCE_DIR}" + PARENT_SCOPE + ) + set(${name}_BINARY_DIR + "${${name}_BINARY_DIR}" + PARENT_SCOPE + ) + set(${name}_ADDED + "${${name}_ADDED}" + PARENT_SCOPE + ) + set(CPM_LAST_PACKAGE_NAME + "${name}" + PARENT_SCOPE + ) +endmacro() + +# declares a package, so that any call to CPMAddPackage for the package name will use these +# arguments instead. Previous declarations will not be overridden. +macro(CPMDeclarePackage Name) + if(NOT DEFINED "CPM_DECLARATION_${Name}") + set("CPM_DECLARATION_${Name}" "${ARGN}") + endif() +endmacro() + +function(cpm_add_to_package_lock Name) + if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) + cpm_prettify_package_arguments(PRETTY_ARGN false ${ARGN}) + file(APPEND ${CPM_PACKAGE_LOCK_FILE} "# ${Name}\nCPMDeclarePackage(${Name}\n${PRETTY_ARGN})\n") + endif() +endfunction() + +function(cpm_add_comment_to_package_lock Name) + if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) + cpm_prettify_package_arguments(PRETTY_ARGN true ${ARGN}) + file(APPEND ${CPM_PACKAGE_LOCK_FILE} + "# ${Name} (unversioned)\n# CPMDeclarePackage(${Name}\n${PRETTY_ARGN}#)\n" + ) + endif() +endfunction() + +# includes the package lock file if it exists and creates a target `cpm-update-package-lock` to +# update it +macro(CPMUsePackageLock file) + if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) + get_filename_component(CPM_ABSOLUTE_PACKAGE_LOCK_PATH ${file} ABSOLUTE) + if(EXISTS ${CPM_ABSOLUTE_PACKAGE_LOCK_PATH}) + include(${CPM_ABSOLUTE_PACKAGE_LOCK_PATH}) + endif() + if(NOT TARGET cpm-update-package-lock) + add_custom_target( + cpm-update-package-lock COMMAND ${CMAKE_COMMAND} -E copy ${CPM_PACKAGE_LOCK_FILE} + ${CPM_ABSOLUTE_PACKAGE_LOCK_PATH} + ) + endif() + set(CPM_PACKAGE_LOCK_ENABLED true) + endif() +endmacro() + +# registers a package that has been added to CPM +function(CPMRegisterPackage PACKAGE VERSION) + list(APPEND CPM_PACKAGES ${PACKAGE}) + set(CPM_PACKAGES + ${CPM_PACKAGES} + CACHE INTERNAL "" + ) + set("CPM_PACKAGE_${PACKAGE}_VERSION" + ${VERSION} + CACHE INTERNAL "" + ) +endfunction() + +# retrieve the current version of the package to ${OUTPUT} +function(CPMGetPackageVersion PACKAGE OUTPUT) + set(${OUTPUT} + "${CPM_PACKAGE_${PACKAGE}_VERSION}" + PARENT_SCOPE + ) +endfunction() + +# declares a package in FetchContent_Declare +function(cpm_declare_fetch PACKAGE) + if(${CPM_DRY_RUN}) + cpm_message(STATUS "${CPM_INDENT} Package not declared (dry run)") + return() + endif() + + FetchContent_Declare(${PACKAGE} ${ARGN}) +endfunction() + +# returns properties for a package previously defined by cpm_declare_fetch +function(cpm_get_fetch_properties PACKAGE) + if(${CPM_DRY_RUN}) + return() + endif() + + set(${PACKAGE}_SOURCE_DIR + "${CPM_PACKAGE_${PACKAGE}_SOURCE_DIR}" + PARENT_SCOPE + ) + set(${PACKAGE}_BINARY_DIR + "${CPM_PACKAGE_${PACKAGE}_BINARY_DIR}" + PARENT_SCOPE + ) +endfunction() + +function(cpm_store_fetch_properties PACKAGE source_dir binary_dir) + if(${CPM_DRY_RUN}) + return() + endif() + + set(CPM_PACKAGE_${PACKAGE}_SOURCE_DIR + "${source_dir}" + CACHE INTERNAL "" + ) + set(CPM_PACKAGE_${PACKAGE}_BINARY_DIR + "${binary_dir}" + CACHE INTERNAL "" + ) +endfunction() + +# adds a package as a subdirectory if viable, according to provided options +function( + cpm_add_subdirectory + PACKAGE + DOWNLOAD_ONLY + SOURCE_DIR + BINARY_DIR + EXCLUDE + SYSTEM + OPTIONS +) + + if(NOT DOWNLOAD_ONLY AND EXISTS ${SOURCE_DIR}/CMakeLists.txt) + set(addSubdirectoryExtraArgs "") + if(EXCLUDE) + list(APPEND addSubdirectoryExtraArgs EXCLUDE_FROM_ALL) + endif() + if("${SYSTEM}" AND "${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.25") + # https://cmake.org/cmake/help/latest/prop_dir/SYSTEM.html#prop_dir:SYSTEM + list(APPEND addSubdirectoryExtraArgs SYSTEM) + endif() + if(OPTIONS) + foreach(OPTION ${OPTIONS}) + cpm_parse_option("${OPTION}") + set(${OPTION_KEY} "${OPTION_VALUE}") + endforeach() + endif() + set(CPM_OLD_INDENT "${CPM_INDENT}") + set(CPM_INDENT "${CPM_INDENT} ${PACKAGE}:") + add_subdirectory(${SOURCE_DIR} ${BINARY_DIR} ${addSubdirectoryExtraArgs}) + set(CPM_INDENT "${CPM_OLD_INDENT}") + endif() +endfunction() + +# downloads a previously declared package via FetchContent and exports the variables +# `${PACKAGE}_SOURCE_DIR` and `${PACKAGE}_BINARY_DIR` to the parent scope +function(cpm_fetch_package PACKAGE DOWNLOAD_ONLY populated) + set(${populated} + FALSE + PARENT_SCOPE + ) + if(${CPM_DRY_RUN}) + cpm_message(STATUS "${CPM_INDENT} Package ${PACKAGE} not fetched (dry run)") + return() + endif() + + FetchContent_GetProperties(${PACKAGE}) + + string(TOLOWER "${PACKAGE}" lower_case_name) + + if(NOT ${lower_case_name}_POPULATED) + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.30.3") + if(DOWNLOAD_ONLY) + # MakeAvailable will call add_subdirectory internally which is not what we want when + # DOWNLOAD_ONLY is set. Populate will only download the dependency without adding it to the + # build + FetchContent_Populate( + ${PACKAGE} + SOURCE_DIR "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-src" + BINARY_DIR "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-build" + SUBBUILD_DIR "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-subbuild" + ${ARGN} + ) + else() + FetchContent_MakeAvailable(${PACKAGE}) + endif() + else() + FetchContent_Populate(${PACKAGE}) + endif() + set(${populated} + TRUE + PARENT_SCOPE + ) + endif() + + cpm_store_fetch_properties( + ${CPM_ARGS_NAME} ${${lower_case_name}_SOURCE_DIR} ${${lower_case_name}_BINARY_DIR} + ) + + set(${PACKAGE}_SOURCE_DIR + ${${lower_case_name}_SOURCE_DIR} + PARENT_SCOPE + ) + set(${PACKAGE}_BINARY_DIR + ${${lower_case_name}_BINARY_DIR} + PARENT_SCOPE + ) +endfunction() + +# splits a package option +function(cpm_parse_option OPTION) + string(REGEX MATCH "^[^ ]+" OPTION_KEY "${OPTION}") + string(LENGTH "${OPTION}" OPTION_LENGTH) + string(LENGTH "${OPTION_KEY}" OPTION_KEY_LENGTH) + if(OPTION_KEY_LENGTH STREQUAL OPTION_LENGTH) + # no value for key provided, assume user wants to set option to "ON" + set(OPTION_VALUE "ON") + else() + math(EXPR OPTION_KEY_LENGTH "${OPTION_KEY_LENGTH}+1") + string(SUBSTRING "${OPTION}" "${OPTION_KEY_LENGTH}" "-1" OPTION_VALUE) + endif() + set(OPTION_KEY + "${OPTION_KEY}" + PARENT_SCOPE + ) + set(OPTION_VALUE + "${OPTION_VALUE}" + PARENT_SCOPE + ) +endfunction() + +# guesses the package version from a git tag +function(cpm_get_version_from_git_tag GIT_TAG RESULT) + string(LENGTH ${GIT_TAG} length) + if(length EQUAL 40) + # GIT_TAG is probably a git hash + set(${RESULT} + 0 + PARENT_SCOPE + ) + else() + string(REGEX MATCH "v?([0123456789.]*).*" _ ${GIT_TAG}) + set(${RESULT} + ${CMAKE_MATCH_1} + PARENT_SCOPE + ) + endif() +endfunction() + +# guesses if the git tag is a commit hash or an actual tag or a branch name. +function(cpm_is_git_tag_commit_hash GIT_TAG RESULT) + string(LENGTH "${GIT_TAG}" length) + # full hash has 40 characters, and short hash has at least 7 characters. + if(length LESS 7 OR length GREATER 40) + set(${RESULT} + 0 + PARENT_SCOPE + ) + else() + if(${GIT_TAG} MATCHES "^[a-fA-F0-9]+$") + set(${RESULT} + 1 + PARENT_SCOPE + ) + else() + set(${RESULT} + 0 + PARENT_SCOPE + ) + endif() + endif() +endfunction() + +function(cpm_prettify_package_arguments OUT_VAR IS_IN_COMMENT) + set(oneValueArgs + NAME + FORCE + VERSION + GIT_TAG + DOWNLOAD_ONLY + GITHUB_REPOSITORY + GITLAB_REPOSITORY + BITBUCKET_REPOSITORY + GIT_REPOSITORY + SOURCE_DIR + FIND_PACKAGE_ARGUMENTS + NO_CACHE + SYSTEM + GIT_SHALLOW + EXCLUDE_FROM_ALL + SOURCE_SUBDIR + ) + set(multiValueArgs URL OPTIONS DOWNLOAD_COMMAND) + cmake_parse_arguments(CPM_ARGS "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + foreach(oneArgName ${oneValueArgs}) + if(DEFINED CPM_ARGS_${oneArgName}) + if(${IS_IN_COMMENT}) + string(APPEND PRETTY_OUT_VAR "#") + endif() + if(${oneArgName} STREQUAL "SOURCE_DIR") + string(REPLACE ${CMAKE_SOURCE_DIR} "\${CMAKE_SOURCE_DIR}" CPM_ARGS_${oneArgName} + ${CPM_ARGS_${oneArgName}} + ) + endif() + string(APPEND PRETTY_OUT_VAR " ${oneArgName} ${CPM_ARGS_${oneArgName}}\n") + endif() + endforeach() + foreach(multiArgName ${multiValueArgs}) + if(DEFINED CPM_ARGS_${multiArgName}) + if(${IS_IN_COMMENT}) + string(APPEND PRETTY_OUT_VAR "#") + endif() + string(APPEND PRETTY_OUT_VAR " ${multiArgName}\n") + foreach(singleOption ${CPM_ARGS_${multiArgName}}) + if(${IS_IN_COMMENT}) + string(APPEND PRETTY_OUT_VAR "#") + endif() + string(APPEND PRETTY_OUT_VAR " \"${singleOption}\"\n") + endforeach() + endif() + endforeach() + + if(NOT "${CPM_ARGS_UNPARSED_ARGUMENTS}" STREQUAL "") + if(${IS_IN_COMMENT}) + string(APPEND PRETTY_OUT_VAR "#") + endif() + string(APPEND PRETTY_OUT_VAR " ") + foreach(CPM_ARGS_UNPARSED_ARGUMENT ${CPM_ARGS_UNPARSED_ARGUMENTS}) + string(APPEND PRETTY_OUT_VAR " ${CPM_ARGS_UNPARSED_ARGUMENT}") + endforeach() + string(APPEND PRETTY_OUT_VAR "\n") + endif() + + set(${OUT_VAR} + ${PRETTY_OUT_VAR} + PARENT_SCOPE + ) + +endfunction() diff --git a/cmake/protobuf.cmake b/cmake/protobuf.cmake new file mode 100644 index 00000000..a422b5c6 --- /dev/null +++ b/cmake/protobuf.cmake @@ -0,0 +1,20 @@ +include(${CMAKE_CURRENT_LIST_DIR}/CPM.cmake) + +set(protobuf_BUILD_TESTS OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_CONFORMANCE OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_PROTOBUF_BINARIES OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_PROTOC_BINARIES OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_LIBPROTOC OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_LIBUPB OFF CACHE BOOL "" FORCE) +set(protobuf_BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE) +set(protobuf_WITH_ZLIB OFF CACHE BOOL "" FORCE) +set(protobuf_INSTALL OFF CACHE BOOL "" FORCE) + +CPMAddPackage( + NAME protobuf + VERSION 33.6 + GITHUB_REPOSITORY protocolbuffers/protobuf + GIT_TAG v33.6 + SOURCE_SUBDIR cmake +) diff --git a/src/game/server/CMakeLists.txt b/src/game/server/CMakeLists.txt index c98827b3..01823bca 100644 --- a/src/game/server/CMakeLists.txt +++ b/src/game/server/CMakeLists.txt @@ -2,7 +2,19 @@ set(ZLIB_USE_STATIC_LIBS "ON") set(ZLIB_ROOT "${BASEDIR}/lib/zlib") find_package(ZLIB REQUIRED) -add_subdirectory(proto) +if (WIN32) + include(${BASEDIR}/cmake/protobuf.cmake) + + # cannot regenerate savedata.pb.* here because that would require compiling protoc before running `cmake -B` and BPN has no support for multi step builds + # maybe adding protoc to the bins/debug and bins/release directory would solve that + if (TARGET protobuf::protoc) + add_subdirectory(proto) + endif() +else() + find_package(Protobuf REQUIRED) + + add_subdirectory(proto) +endif() add_library(server SHARED $<$:ms.def>) add_library(libcurl STATIC IMPORTED) @@ -30,8 +42,8 @@ target_link_libraries(server PRIVATE $<$:Normaliz> ${ZLIB_LIBRARIES} libcurl - savedata-protoc - ${Protobuf_LIBRARIES} + $<$:libprotobuf> + $<$:${Protobuf_LIBRARIES}> ) # Include directories @@ -415,6 +427,8 @@ set(ThirdParty_AngelScript source_group("ThirdParty\\AngelScript" FILES ${ThirdParty_AngelScript}) set(Shared_Save + "proto/savedata.pb.cc" + "proto/savedata.pb.h" "save/protosave.cpp" "save/protosave.h" ) diff --git a/src/game/server/proto/CMakeLists.txt b/src/game/server/proto/CMakeLists.txt index 7524a4e2..6c5cf598 100644 --- a/src/game/server/proto/CMakeLists.txt +++ b/src/game/server/proto/CMakeLists.txt @@ -1,11 +1,10 @@ add_library(savedata-protoc SHARED OBJECT "${CMAKE_CURRENT_LIST_DIR}/savedata.proto") target_link_libraries(savedata-protoc PRIVATE ${Protobuf_LIBRARIES}) -target_include_directories(savedata-protoc INTERFACE $) - +target_include_directories(savedata-protoc INTERFACE $) message("🏗️ Generating protobuf.") protobuf_generate( TARGET savedata-protoc IMPORT_DIRS "${CMAKE_CURRENT_LIST_DIR}" - PROTOC_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}" + PROTOC_OUT_DIR "${CMAKE_CURRENT_LIST_DIR}" ) diff --git a/src/game/server/proto/savedata.pb.cc b/src/game/server/proto/savedata.pb.cc new file mode 100644 index 00000000..dc496113 --- /dev/null +++ b/src/game/server/proto/savedata.pb.cc @@ -0,0 +1,4265 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: savedata.proto + +#include "savedata.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace MSRProto { +constexpr Stat_SubStat::Stat_SubStat( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : substatid_(0) + + , value_(0u) + , exp_(0u){} +struct Stat_SubStatDefaultTypeInternal { + constexpr Stat_SubStatDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Stat_SubStatDefaultTypeInternal() {} + union { + Stat_SubStat _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Stat_SubStatDefaultTypeInternal _Stat_SubStat_default_instance_; +constexpr Stat::Stat( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : substats_() + , statid_(0) +{} +struct StatDefaultTypeInternal { + constexpr StatDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~StatDefaultTypeInternal() {} + union { + Stat _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StatDefaultTypeInternal _Stat_default_instance_; +constexpr GenericItemFull_GenericItem::GenericItemFull_GenericItem( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , id_(0u) + , properties_(0u) + , quantity_(0u) + , quality_(0u) + , maxquality_(0u){} +struct GenericItemFull_GenericItemDefaultTypeInternal { + constexpr GenericItemFull_GenericItemDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~GenericItemFull_GenericItemDefaultTypeInternal() {} + union { + GenericItemFull_GenericItem _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GenericItemFull_GenericItemDefaultTypeInternal _GenericItemFull_GenericItem_default_instance_; +constexpr GenericItemFull::GenericItemFull( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : containeritems_() + , genericitem_(nullptr) + , location_(0u) + , hand_(0) +{} +struct GenericItemFullDefaultTypeInternal { + constexpr GenericItemFullDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~GenericItemFullDefaultTypeInternal() {} + union { + GenericItemFull _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GenericItemFullDefaultTypeInternal _GenericItemFull_default_instance_; +constexpr Storage::Storage( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : items_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct StorageDefaultTypeInternal { + constexpr StorageDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~StorageDefaultTypeInternal() {} + union { + Storage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StorageDefaultTypeInternal _Storage_default_instance_; +constexpr CharData_SaveData_Vector3::CharData_SaveData_Vector3( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : x_(0) + , y_(0) + , z_(0){} +struct CharData_SaveData_Vector3DefaultTypeInternal { + constexpr CharData_SaveData_Vector3DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharData_SaveData_Vector3DefaultTypeInternal() {} + union { + CharData_SaveData_Vector3 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharData_SaveData_Vector3DefaultTypeInternal _CharData_SaveData_Vector3_default_instance_; +constexpr CharData_SaveData::CharData_SaveData( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , steamid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , race_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , mapname_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , nextmap_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , oldtransition_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , newtransition_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , partyname_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , origin_(nullptr) + , angles_(nullptr) + , version_(0) + , gender_(0) + + , iselite_(false) + , gold_(0u) + , maxhp_(0u) + , maxmp_(0u) + , currenthp_(0u) + , currentmp_(0u) + , partyid_(0u) + , playerkills_(0u) + , timewaitedtoforgetkill_(0) + , timewaitedtoforgetsteal_(0){} +struct CharData_SaveDataDefaultTypeInternal { + constexpr CharData_SaveDataDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharData_SaveDataDefaultTypeInternal() {} + union { + CharData_SaveData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharData_SaveDataDefaultTypeInternal _CharData_SaveData_default_instance_; +constexpr CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct CharData_Companion_ScriptedSaveVariablesEntry_DoNotUseDefaultTypeInternal { + constexpr CharData_Companion_ScriptedSaveVariablesEntry_DoNotUseDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharData_Companion_ScriptedSaveVariablesEntry_DoNotUseDefaultTypeInternal() {} + union { + CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharData_Companion_ScriptedSaveVariablesEntry_DoNotUseDefaultTypeInternal _CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse_default_instance_; +constexpr CharData_Companion::CharData_Companion( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : scriptedsavevariables_(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) + , scriptname_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct CharData_CompanionDefaultTypeInternal { + constexpr CharData_CompanionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharData_CompanionDefaultTypeInternal() {} + union { + CharData_Companion _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharData_CompanionDefaultTypeInternal _CharData_Companion_default_instance_; +constexpr CharData_QuestsEntry_DoNotUse::CharData_QuestsEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct CharData_QuestsEntry_DoNotUseDefaultTypeInternal { + constexpr CharData_QuestsEntry_DoNotUseDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharData_QuestsEntry_DoNotUseDefaultTypeInternal() {} + union { + CharData_QuestsEntry_DoNotUse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharData_QuestsEntry_DoNotUseDefaultTypeInternal _CharData_QuestsEntry_DoNotUse_default_instance_; +constexpr CharData_QuickSlot::CharData_QuickSlot( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(0) + + , id_(0u){} +struct CharData_QuickSlotDefaultTypeInternal { + constexpr CharData_QuickSlotDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharData_QuickSlotDefaultTypeInternal() {} + union { + CharData_QuickSlot _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharData_QuickSlotDefaultTypeInternal _CharData_QuickSlot_default_instance_; +constexpr CharData::CharData( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : visitedmaps_() + , statlist_() + , knownspells_() + , items_() + , storages_() + , companions_() + , viewedhelptips_() + , quests_(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) + , quickslots_() + , savedata_(nullptr){} +struct CharDataDefaultTypeInternal { + constexpr CharDataDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CharDataDefaultTypeInternal() {} + union { + CharData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CharDataDefaultTypeInternal _CharData_default_instance_; +} // namespace MSRProto +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_savedata_2eproto[12]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_savedata_2eproto[5]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_savedata_2eproto = nullptr; + +const uint32_t TableStruct_savedata_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat_SubStat, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat_SubStat, substatid_), + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat_SubStat, value_), + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat_SubStat, exp_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat, statid_), + PROTOBUF_FIELD_OFFSET(::MSRProto::Stat, substats_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, id_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, name_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, properties_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, quantity_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, quality_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull_GenericItem, maxquality_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull, genericitem_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull, location_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull, hand_), + PROTOBUF_FIELD_OFFSET(::MSRProto::GenericItemFull, containeritems_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::Storage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::Storage, name_), + PROTOBUF_FIELD_OFFSET(::MSRProto::Storage, items_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData_Vector3, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData_Vector3, x_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData_Vector3, y_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData_Vector3, z_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, version_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, name_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, steamid_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, race_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, gender_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, mapname_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, nextmap_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, oldtransition_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, newtransition_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, origin_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, angles_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, iselite_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, gold_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, maxhp_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, maxmp_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, currenthp_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, currentmp_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, partyname_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, partyid_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, playerkills_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, timewaitedtoforgetkill_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_SaveData, timewaitedtoforgetsteal_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse, value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion, scriptname_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_Companion, scriptedsavevariables_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuestsEntry_DoNotUse, _has_bits_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuestsEntry_DoNotUse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuestsEntry_DoNotUse, key_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuestsEntry_DoNotUse, value_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuickSlot, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuickSlot, type_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData_QuickSlot, id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, savedata_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, visitedmaps_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, statlist_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, knownspells_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, items_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, storages_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, companions_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, viewedhelptips_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, quests_), + PROTOBUF_FIELD_OFFSET(::MSRProto::CharData, quickslots_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::MSRProto::Stat_SubStat)}, + { 9, -1, -1, sizeof(::MSRProto::Stat)}, + { 17, -1, -1, sizeof(::MSRProto::GenericItemFull_GenericItem)}, + { 29, -1, -1, sizeof(::MSRProto::GenericItemFull)}, + { 39, -1, -1, sizeof(::MSRProto::Storage)}, + { 47, -1, -1, sizeof(::MSRProto::CharData_SaveData_Vector3)}, + { 56, -1, -1, sizeof(::MSRProto::CharData_SaveData)}, + { 84, 92, -1, sizeof(::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse)}, + { 94, -1, -1, sizeof(::MSRProto::CharData_Companion)}, + { 102, 110, -1, sizeof(::MSRProto::CharData_QuestsEntry_DoNotUse)}, + { 112, -1, -1, sizeof(::MSRProto::CharData_QuickSlot)}, + { 120, -1, -1, sizeof(::MSRProto::CharData)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::MSRProto::_Stat_SubStat_default_instance_), + reinterpret_cast(&::MSRProto::_Stat_default_instance_), + reinterpret_cast(&::MSRProto::_GenericItemFull_GenericItem_default_instance_), + reinterpret_cast(&::MSRProto::_GenericItemFull_default_instance_), + reinterpret_cast(&::MSRProto::_Storage_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_SaveData_Vector3_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_SaveData_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_Companion_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_QuestsEntry_DoNotUse_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_QuickSlot_default_instance_), + reinterpret_cast(&::MSRProto::_CharData_default_instance_), +}; + +const char descriptor_table_protodef_savedata_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\016savedata.proto\022\010MSRProto\"\322\004\n\004Stat\022%\n\006s" + "tatId\030\001 \001(\0162\025.MSRProto.Stat.StatId\022(\n\010su" + "bStats\030\002 \003(\0132\026.MSRProto.Stat.SubStat\032\357\001\n" + "\007SubStat\0223\n\tsubstatId\030\001 \001(\0162 .MSRProto.S" + "tat.SubStat.SubStatId\022\r\n\005value\030\002 \001(\r\022\013\n\003" + "exp\030\003 \001(\r\"\222\001\n\tSubStatId\022\025\n\021SubStatId_UNK" + "NOWN\020\000\022\017\n\013Proficiency\020\001\022\013\n\007Balance\020\002\022\t\n\005" + "Power\020\003\022\t\n\004Fire\020\351\007\022\010\n\003Ice\020\352\007\022\016\n\tLightnin" + "g\020\353\007\022\017\n\nDivination\020\354\007\022\017\n\nAffliction\020\355\007\"\206" + "\002\n\006StatId\022\022\n\016StatId_UNKNOWN\020\000\022\014\n\010Strengt" + "h\020\001\022\013\n\007Agility\020\002\022\021\n\rConcentration\020\003\022\r\n\tA" + "wareness\020\004\022\013\n\007Fitness\020\005\022\n\n\006Wisdom\020\006\022\022\n\rS" + "wordsmanship\020\351\007\022\020\n\013MartialArts\020\352\007\022\016\n\tSma" + "llArms\020\353\007\022\020\n\013AxeHandling\020\354\007\022\016\n\tBluntArms" + "\020\355\007\022\014\n\007Archery\020\356\007\022\021\n\014SpellCasting\020\357\007\022\n\n\005" + "Parry\020\360\007\022\r\n\010PoleArms\020\361\007\"\247\003\n\017GenericItemF" + "ull\022:\n\013genericItem\030\001 \001(\0132%.MSRProto.Gene" + "ricItemFull.GenericItem\022\020\n\010Location\030\002 \001(" + "\r\022.\n\004Hand\030\003 \001(\0162 .MSRProto.GenericItemFu" + "ll.HandId\0221\n\016containerItems\030\004 \003(\0132\031.MSRP" + "roto.GenericItemFull\032r\n\013GenericItem\022\n\n\002i" + "d\030\001 \001(\r\022\014\n\004name\030\002 \001(\t\022\022\n\nproperties\030\003 \001(" + "\r\022\020\n\010quantity\030\004 \001(\r\022\017\n\007quality\030\005 \001(\r\022\022\n\n" + "maxQuality\030\006 \001(\r\"o\n\006HandId\022\022\n\016HandId_UNK" + "NOWN\020\000\022\r\n\tLEFT_HAND\020\001\022\016\n\nRIGHT_HAND\020\002\022\024\n" + "\020HAND_PLAYERHANDS\020\003\022\014\n\010ANY_HAND\020\004\022\016\n\nBOT" + "H_HANDS\020\005\"A\n\007Storage\022\014\n\004name\030\001 \001(\t\022(\n\005it" + "ems\030\002 \003(\0132\031.MSRProto.GenericItemFull\"\240\013\n" + "\010CharData\022-\n\010saveData\030\001 \001(\0132\033.MSRProto.C" + "harData.SaveData\022\023\n\013visitedMaps\030\002 \003(\t\022 \n" + "\010statList\030\003 \003(\0132\016.MSRProto.Stat\022\023\n\013known" + "Spells\030\004 \003(\t\022(\n\005items\030\005 \003(\0132\031.MSRProto.G" + "enericItemFull\022#\n\010storages\030\006 \003(\0132\021.MSRPr" + "oto.Storage\0220\n\ncompanions\030\007 \003(\0132\034.MSRPro" + "to.CharData.Companion\022\026\n\016viewedHelpTips\030" + "\010 \003(\t\022.\n\006quests\030\t \003(\0132\036.MSRProto.CharDat" + "a.QuestsEntry\0220\n\nquickslots\030\n \003(\0132\034.MSRP" + "roto.CharData.QuickSlot\032\371\004\n\010SaveData\022\017\n\007" + "version\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\022\017\n\007steamId\030\003" + " \001(\t\022\014\n\004race\030\004 \001(\t\0224\n\006gender\030\005 \001(\0162$.MSR" + "Proto.CharData.SaveData.GenderId\022\017\n\007mapN" + "ame\030\006 \001(\t\022\017\n\007nextMap\030\007 \001(\t\022\025\n\roldTransit" + "ion\030\010 \001(\t\022\025\n\rnewTransition\030\t \001(\t\0223\n\006orig" + "in\030\n \001(\0132#.MSRProto.CharData.SaveData.Ve" + "ctor3\0223\n\006angles\030\013 \001(\0132#.MSRProto.CharDat" + "a.SaveData.Vector3\022\017\n\007isElite\030\014 \001(\010\022\014\n\004g" + "old\030\r \001(\r\022\r\n\005maxHP\030\016 \001(\r\022\r\n\005maxMP\030\017 \001(\r\022" + "\021\n\tcurrentHP\030\020 \001(\r\022\021\n\tcurrentMP\030\021 \001(\r\022\021\n" + "\tpartyName\030\022 \001(\t\022\017\n\007partyId\030\023 \001(\r\022\023\n\013pla" + "yerKills\030\024 \001(\r\022\036\n\026timeWaitedToForgetKill" + "\030\025 \001(\001\022\037\n\027timeWaitedToForgetSteal\030\026 \001(\001\032" + "*\n\007Vector3\022\t\n\001x\030\001 \001(\001\022\t\n\001y\030\002 \001(\001\022\t\n\001z\030\003 " + "\001(\001\"6\n\010GenderId\022\024\n\020GenderId_UNKNOWN\020\000\022\010\n" + "\004Male\020\001\022\n\n\006Female\020\002\032\265\001\n\tCompanion\022\022\n\nscr" + "iptName\030\001 \001(\t\022V\n\025scriptedSaveVariables\030\002" + " \003(\01327.MSRProto.CharData.Companion.Scrip" + "tedSaveVariablesEntry\032<\n\032ScriptedSaveVar" + "iablesEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t:" + "\0028\001\032-\n\013QuestsEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value" + "\030\002 \001(\t:\0028\001\032\272\001\n\tQuickSlot\022:\n\004type\030\001 \001(\0162," + ".MSRProto.CharData.QuickSlot.QuickSlotTy" + "peId\022\n\n\002id\030\002 \001(\r\"e\n\017QuickSlotTypeId\022\033\n\027Q" + "uickSlotTypeId_UNKNOWN\020\000\022\014\n\010QS_EMPTY\020\001\022\013" + "\n\007QS_ITEM\020\002\022\014\n\010QS_SPELL\020\003\022\014\n\010QS_ARROW\020\004b" + "\006proto3" + ; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_savedata_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_savedata_2eproto = { + false, false, 2567, descriptor_table_protodef_savedata_2eproto, "savedata.proto", + &descriptor_table_savedata_2eproto_once, nullptr, 0, 12, + schemas, file_default_instances, TableStruct_savedata_2eproto::offsets, + file_level_metadata_savedata_2eproto, file_level_enum_descriptors_savedata_2eproto, file_level_service_descriptors_savedata_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_savedata_2eproto_getter() { + return &descriptor_table_savedata_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_savedata_2eproto(&descriptor_table_savedata_2eproto); +namespace MSRProto { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Stat_SubStat_SubStatId_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_savedata_2eproto); + return file_level_enum_descriptors_savedata_2eproto[0]; +} +bool Stat_SubStat_SubStatId_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 1001: + case 1002: + case 1003: + case 1004: + case 1005: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Stat_SubStat_SubStatId Stat_SubStat::SubStatId_UNKNOWN; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Proficiency; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Balance; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Power; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Fire; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Ice; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Lightning; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Divination; +constexpr Stat_SubStat_SubStatId Stat_SubStat::Affliction; +constexpr Stat_SubStat_SubStatId Stat_SubStat::SubStatId_MIN; +constexpr Stat_SubStat_SubStatId Stat_SubStat::SubStatId_MAX; +constexpr int Stat_SubStat::SubStatId_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Stat_StatId_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_savedata_2eproto); + return file_level_enum_descriptors_savedata_2eproto[1]; +} +bool Stat_StatId_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 1001: + case 1002: + case 1003: + case 1004: + case 1005: + case 1006: + case 1007: + case 1008: + case 1009: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Stat_StatId Stat::StatId_UNKNOWN; +constexpr Stat_StatId Stat::Strength; +constexpr Stat_StatId Stat::Agility; +constexpr Stat_StatId Stat::Concentration; +constexpr Stat_StatId Stat::Awareness; +constexpr Stat_StatId Stat::Fitness; +constexpr Stat_StatId Stat::Wisdom; +constexpr Stat_StatId Stat::Swordsmanship; +constexpr Stat_StatId Stat::MartialArts; +constexpr Stat_StatId Stat::SmallArms; +constexpr Stat_StatId Stat::AxeHandling; +constexpr Stat_StatId Stat::BluntArms; +constexpr Stat_StatId Stat::Archery; +constexpr Stat_StatId Stat::SpellCasting; +constexpr Stat_StatId Stat::Parry; +constexpr Stat_StatId Stat::PoleArms; +constexpr Stat_StatId Stat::StatId_MIN; +constexpr Stat_StatId Stat::StatId_MAX; +constexpr int Stat::StatId_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GenericItemFull_HandId_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_savedata_2eproto); + return file_level_enum_descriptors_savedata_2eproto[2]; +} +bool GenericItemFull_HandId_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr GenericItemFull_HandId GenericItemFull::HandId_UNKNOWN; +constexpr GenericItemFull_HandId GenericItemFull::LEFT_HAND; +constexpr GenericItemFull_HandId GenericItemFull::RIGHT_HAND; +constexpr GenericItemFull_HandId GenericItemFull::HAND_PLAYERHANDS; +constexpr GenericItemFull_HandId GenericItemFull::ANY_HAND; +constexpr GenericItemFull_HandId GenericItemFull::BOTH_HANDS; +constexpr GenericItemFull_HandId GenericItemFull::HandId_MIN; +constexpr GenericItemFull_HandId GenericItemFull::HandId_MAX; +constexpr int GenericItemFull::HandId_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CharData_SaveData_GenderId_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_savedata_2eproto); + return file_level_enum_descriptors_savedata_2eproto[3]; +} +bool CharData_SaveData_GenderId_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr CharData_SaveData_GenderId CharData_SaveData::GenderId_UNKNOWN; +constexpr CharData_SaveData_GenderId CharData_SaveData::Male; +constexpr CharData_SaveData_GenderId CharData_SaveData::Female; +constexpr CharData_SaveData_GenderId CharData_SaveData::GenderId_MIN; +constexpr CharData_SaveData_GenderId CharData_SaveData::GenderId_MAX; +constexpr int CharData_SaveData::GenderId_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CharData_QuickSlot_QuickSlotTypeId_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_savedata_2eproto); + return file_level_enum_descriptors_savedata_2eproto[4]; +} +bool CharData_QuickSlot_QuickSlotTypeId_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QuickSlotTypeId_UNKNOWN; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QS_EMPTY; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QS_ITEM; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QS_SPELL; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QS_ARROW; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QuickSlotTypeId_MIN; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::QuickSlotTypeId_MAX; +constexpr int CharData_QuickSlot::QuickSlotTypeId_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +// =================================================================== + +class Stat_SubStat::_Internal { + public: +}; + +Stat_SubStat::Stat_SubStat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.Stat.SubStat) +} +Stat_SubStat::Stat_SubStat(const Stat_SubStat& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&substatid_, &from.substatid_, + static_cast(reinterpret_cast(&exp_) - + reinterpret_cast(&substatid_)) + sizeof(exp_)); + // @@protoc_insertion_point(copy_constructor:MSRProto.Stat.SubStat) +} + +inline void Stat_SubStat::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&substatid_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&exp_) - + reinterpret_cast(&substatid_)) + sizeof(exp_)); +} + +Stat_SubStat::~Stat_SubStat() { + // @@protoc_insertion_point(destructor:MSRProto.Stat.SubStat) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void Stat_SubStat::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Stat_SubStat::ArenaDtor(void* object) { + Stat_SubStat* _this = reinterpret_cast< Stat_SubStat* >(object); + (void)_this; +} +void Stat_SubStat::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Stat_SubStat::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Stat_SubStat::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.Stat.SubStat) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&substatid_, 0, static_cast( + reinterpret_cast(&exp_) - + reinterpret_cast(&substatid_)) + sizeof(exp_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Stat_SubStat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .MSRProto.Stat.SubStat.SubStatId substatId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_substatid(static_cast<::MSRProto::Stat_SubStat_SubStatId>(val)); + } else + goto handle_unusual; + continue; + // uint32 value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 exp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + exp_ = ::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* Stat_SubStat::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.Stat.SubStat) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .MSRProto.Stat.SubStat.SubStatId substatId = 1; + if (this->_internal_substatid() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_substatid(), target); + } + + // uint32 value = 2; + if (this->_internal_value() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_value(), target); + } + + // uint32 exp = 3; + if (this->_internal_exp() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_exp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.Stat.SubStat) + return target; +} + +size_t Stat_SubStat::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.Stat.SubStat) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .MSRProto.Stat.SubStat.SubStatId substatId = 1; + if (this->_internal_substatid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_substatid()); + } + + // uint32 value = 2; + if (this->_internal_value() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_value()); + } + + // uint32 exp = 3; + if (this->_internal_exp() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_exp()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Stat_SubStat::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Stat_SubStat::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Stat_SubStat::GetClassData() const { return &_class_data_; } + +void Stat_SubStat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void Stat_SubStat::MergeFrom(const Stat_SubStat& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.Stat.SubStat) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_substatid() != 0) { + _internal_set_substatid(from._internal_substatid()); + } + if (from._internal_value() != 0) { + _internal_set_value(from._internal_value()); + } + if (from._internal_exp() != 0) { + _internal_set_exp(from._internal_exp()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Stat_SubStat::CopyFrom(const Stat_SubStat& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.Stat.SubStat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Stat_SubStat::IsInitialized() const { + return true; +} + +void Stat_SubStat::InternalSwap(Stat_SubStat* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Stat_SubStat, exp_) + + sizeof(Stat_SubStat::exp_) + - PROTOBUF_FIELD_OFFSET(Stat_SubStat, substatid_)>( + reinterpret_cast(&substatid_), + reinterpret_cast(&other->substatid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Stat_SubStat::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[0]); +} + +// =================================================================== + +class Stat::_Internal { + public: +}; + +Stat::Stat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + substats_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.Stat) +} +Stat::Stat(const Stat& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + substats_(from.substats_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + statid_ = from.statid_; + // @@protoc_insertion_point(copy_constructor:MSRProto.Stat) +} + +inline void Stat::SharedCtor() { +statid_ = 0; +} + +Stat::~Stat() { + // @@protoc_insertion_point(destructor:MSRProto.Stat) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void Stat::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Stat::ArenaDtor(void* object) { + Stat* _this = reinterpret_cast< Stat* >(object); + (void)_this; +} +void Stat::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Stat::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Stat::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.Stat) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + substats_.Clear(); + statid_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Stat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .MSRProto.Stat.StatId statId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_statid(static_cast<::MSRProto::Stat_StatId>(val)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.Stat.SubStat subStats = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_substats(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Stat::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.Stat) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .MSRProto.Stat.StatId statId = 1; + if (this->_internal_statid() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_statid(), target); + } + + // repeated .MSRProto.Stat.SubStat subStats = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_substats_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_substats(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.Stat) + return target; +} + +size_t Stat::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.Stat) + 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 .MSRProto.Stat.SubStat subStats = 2; + total_size += 1UL * this->_internal_substats_size(); + for (const auto& msg : this->substats_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .MSRProto.Stat.StatId statId = 1; + if (this->_internal_statid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_statid()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Stat::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Stat::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Stat::GetClassData() const { return &_class_data_; } + +void Stat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void Stat::MergeFrom(const Stat& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.Stat) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + substats_.MergeFrom(from.substats_); + if (from._internal_statid() != 0) { + _internal_set_statid(from._internal_statid()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Stat::CopyFrom(const Stat& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.Stat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Stat::IsInitialized() const { + return true; +} + +void Stat::InternalSwap(Stat* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + substats_.InternalSwap(&other->substats_); + swap(statid_, other->statid_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Stat::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[1]); +} + +// =================================================================== + +class GenericItemFull_GenericItem::_Internal { + public: +}; + +GenericItemFull_GenericItem::GenericItemFull_GenericItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.GenericItemFull.GenericItem) +} +GenericItemFull_GenericItem::GenericItemFull_GenericItem(const GenericItemFull_GenericItem& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + ::memcpy(&id_, &from.id_, + static_cast(reinterpret_cast(&maxquality_) - + reinterpret_cast(&id_)) + sizeof(maxquality_)); + // @@protoc_insertion_point(copy_constructor:MSRProto.GenericItemFull.GenericItem) +} + +inline void GenericItemFull_GenericItem::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&maxquality_) - + reinterpret_cast(&id_)) + sizeof(maxquality_)); +} + +GenericItemFull_GenericItem::~GenericItemFull_GenericItem() { + // @@protoc_insertion_point(destructor:MSRProto.GenericItemFull.GenericItem) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void GenericItemFull_GenericItem::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void GenericItemFull_GenericItem::ArenaDtor(void* object) { + GenericItemFull_GenericItem* _this = reinterpret_cast< GenericItemFull_GenericItem* >(object); + (void)_this; +} +void GenericItemFull_GenericItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void GenericItemFull_GenericItem::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void GenericItemFull_GenericItem::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.GenericItemFull.GenericItem) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + ::memset(&id_, 0, static_cast( + reinterpret_cast(&maxquality_) - + reinterpret_cast(&id_)) + sizeof(maxquality_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* GenericItemFull_GenericItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.GenericItemFull.GenericItem.name")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 properties = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + properties_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 quantity = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + quantity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 quality = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + quality_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 maxQuality = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + maxquality_ = ::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* GenericItemFull_GenericItem::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.GenericItemFull.GenericItem) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // uint32 id = 1; + if (this->_internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); + } + + // string name = 2; + if (!this->_internal_name().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.GenericItemFull.GenericItem.name"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_name(), target); + } + + // uint32 properties = 3; + if (this->_internal_properties() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_properties(), target); + } + + // uint32 quantity = 4; + if (this->_internal_quantity() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quantity(), target); + } + + // uint32 quality = 5; + if (this->_internal_quality() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quality(), target); + } + + // uint32 maxQuality = 6; + if (this->_internal_maxquality() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_maxquality(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.GenericItemFull.GenericItem) + return target; +} + +size_t GenericItemFull_GenericItem::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.GenericItemFull.GenericItem) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 2; + if (!this->_internal_name().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // uint32 id = 1; + if (this->_internal_id() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_id()); + } + + // uint32 properties = 3; + if (this->_internal_properties() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_properties()); + } + + // uint32 quantity = 4; + if (this->_internal_quantity() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_quantity()); + } + + // uint32 quality = 5; + if (this->_internal_quality() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_quality()); + } + + // uint32 maxQuality = 6; + if (this->_internal_maxquality() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_maxquality()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GenericItemFull_GenericItem::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + GenericItemFull_GenericItem::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GenericItemFull_GenericItem::GetClassData() const { return &_class_data_; } + +void GenericItemFull_GenericItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void GenericItemFull_GenericItem::MergeFrom(const GenericItemFull_GenericItem& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.GenericItemFull.GenericItem) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _internal_set_name(from._internal_name()); + } + if (from._internal_id() != 0) { + _internal_set_id(from._internal_id()); + } + if (from._internal_properties() != 0) { + _internal_set_properties(from._internal_properties()); + } + if (from._internal_quantity() != 0) { + _internal_set_quantity(from._internal_quantity()); + } + if (from._internal_quality() != 0) { + _internal_set_quality(from._internal_quality()); + } + if (from._internal_maxquality() != 0) { + _internal_set_maxquality(from._internal_maxquality()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void GenericItemFull_GenericItem::CopyFrom(const GenericItemFull_GenericItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.GenericItemFull.GenericItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenericItemFull_GenericItem::IsInitialized() const { + return true; +} + +void GenericItemFull_GenericItem::InternalSwap(GenericItemFull_GenericItem* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(GenericItemFull_GenericItem, maxquality_) + + sizeof(GenericItemFull_GenericItem::maxquality_) + - PROTOBUF_FIELD_OFFSET(GenericItemFull_GenericItem, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GenericItemFull_GenericItem::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[2]); +} + +// =================================================================== + +class GenericItemFull::_Internal { + public: + static const ::MSRProto::GenericItemFull_GenericItem& genericitem(const GenericItemFull* msg); +}; + +const ::MSRProto::GenericItemFull_GenericItem& +GenericItemFull::_Internal::genericitem(const GenericItemFull* msg) { + return *msg->genericitem_; +} +GenericItemFull::GenericItemFull(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + containeritems_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.GenericItemFull) +} +GenericItemFull::GenericItemFull(const GenericItemFull& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + containeritems_(from.containeritems_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_genericitem()) { + genericitem_ = new ::MSRProto::GenericItemFull_GenericItem(*from.genericitem_); + } else { + genericitem_ = nullptr; + } + ::memcpy(&location_, &from.location_, + static_cast(reinterpret_cast(&hand_) - + reinterpret_cast(&location_)) + sizeof(hand_)); + // @@protoc_insertion_point(copy_constructor:MSRProto.GenericItemFull) +} + +inline void GenericItemFull::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&genericitem_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&hand_) - + reinterpret_cast(&genericitem_)) + sizeof(hand_)); +} + +GenericItemFull::~GenericItemFull() { + // @@protoc_insertion_point(destructor:MSRProto.GenericItemFull) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void GenericItemFull::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete genericitem_; +} + +void GenericItemFull::ArenaDtor(void* object) { + GenericItemFull* _this = reinterpret_cast< GenericItemFull* >(object); + (void)_this; +} +void GenericItemFull::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void GenericItemFull::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void GenericItemFull::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.GenericItemFull) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + containeritems_.Clear(); + if (GetArenaForAllocation() == nullptr && genericitem_ != nullptr) { + delete genericitem_; + } + genericitem_ = nullptr; + ::memset(&location_, 0, static_cast( + reinterpret_cast(&hand_) - + reinterpret_cast(&location_)) + sizeof(hand_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* GenericItemFull::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .MSRProto.GenericItemFull.GenericItem genericItem = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_genericitem(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 Location = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + location_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .MSRProto.GenericItemFull.HandId Hand = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_hand(static_cast<::MSRProto::GenericItemFull_HandId>(val)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.GenericItemFull containerItems = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_containeritems(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(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* GenericItemFull::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.GenericItemFull) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .MSRProto.GenericItemFull.GenericItem genericItem = 1; + if (this->_internal_has_genericitem()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::genericitem(this), target, stream); + } + + // uint32 Location = 2; + if (this->_internal_location() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_location(), target); + } + + // .MSRProto.GenericItemFull.HandId Hand = 3; + if (this->_internal_hand() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_hand(), target); + } + + // repeated .MSRProto.GenericItemFull containerItems = 4; + for (unsigned int i = 0, + n = static_cast(this->_internal_containeritems_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_containeritems(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.GenericItemFull) + return target; +} + +size_t GenericItemFull::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.GenericItemFull) + 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 .MSRProto.GenericItemFull containerItems = 4; + total_size += 1UL * this->_internal_containeritems_size(); + for (const auto& msg : this->containeritems_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .MSRProto.GenericItemFull.GenericItem genericItem = 1; + if (this->_internal_has_genericitem()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *genericitem_); + } + + // uint32 Location = 2; + if (this->_internal_location() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_location()); + } + + // .MSRProto.GenericItemFull.HandId Hand = 3; + if (this->_internal_hand() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_hand()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GenericItemFull::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + GenericItemFull::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GenericItemFull::GetClassData() const { return &_class_data_; } + +void GenericItemFull::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void GenericItemFull::MergeFrom(const GenericItemFull& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.GenericItemFull) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + containeritems_.MergeFrom(from.containeritems_); + if (from._internal_has_genericitem()) { + _internal_mutable_genericitem()->::MSRProto::GenericItemFull_GenericItem::MergeFrom(from._internal_genericitem()); + } + if (from._internal_location() != 0) { + _internal_set_location(from._internal_location()); + } + if (from._internal_hand() != 0) { + _internal_set_hand(from._internal_hand()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void GenericItemFull::CopyFrom(const GenericItemFull& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.GenericItemFull) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GenericItemFull::IsInitialized() const { + return true; +} + +void GenericItemFull::InternalSwap(GenericItemFull* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + containeritems_.InternalSwap(&other->containeritems_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(GenericItemFull, hand_) + + sizeof(GenericItemFull::hand_) + - PROTOBUF_FIELD_OFFSET(GenericItemFull, genericitem_)>( + reinterpret_cast(&genericitem_), + reinterpret_cast(&other->genericitem_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GenericItemFull::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[3]); +} + +// =================================================================== + +class Storage::_Internal { + public: +}; + +Storage::Storage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + items_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.Storage) +} +Storage::Storage(const Storage& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + items_(from.items_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:MSRProto.Storage) +} + +inline void Storage::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Storage::~Storage() { + // @@protoc_insertion_point(destructor:MSRProto.Storage) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void Storage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Storage::ArenaDtor(void* object) { + Storage* _this = reinterpret_cast< Storage* >(object); + (void)_this; +} +void Storage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Storage::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Storage::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.Storage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + items_.Clear(); + name_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Storage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.Storage.name")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.GenericItemFull items = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_items(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Storage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.Storage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (!this->_internal_name().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.Storage.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // repeated .MSRProto.GenericItemFull items = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_items_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_items(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.Storage) + return target; +} + +size_t Storage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.Storage) + 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 .MSRProto.GenericItemFull items = 2; + total_size += 1UL * this->_internal_items_size(); + for (const auto& msg : this->items_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // string name = 1; + if (!this->_internal_name().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Storage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Storage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Storage::GetClassData() const { return &_class_data_; } + +void Storage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void Storage::MergeFrom(const Storage& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.Storage) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + items_.MergeFrom(from.items_); + if (!from._internal_name().empty()) { + _internal_set_name(from._internal_name()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Storage::CopyFrom(const Storage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.Storage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Storage::IsInitialized() const { + return true; +} + +void Storage::InternalSwap(Storage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + items_.InternalSwap(&other->items_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Storage::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[4]); +} + +// =================================================================== + +class CharData_SaveData_Vector3::_Internal { + public: +}; + +CharData_SaveData_Vector3::CharData_SaveData_Vector3(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.CharData.SaveData.Vector3) +} +CharData_SaveData_Vector3::CharData_SaveData_Vector3(const CharData_SaveData_Vector3& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&x_, &from.x_, + static_cast(reinterpret_cast(&z_) - + reinterpret_cast(&x_)) + sizeof(z_)); + // @@protoc_insertion_point(copy_constructor:MSRProto.CharData.SaveData.Vector3) +} + +inline void CharData_SaveData_Vector3::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&x_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&z_) - + reinterpret_cast(&x_)) + sizeof(z_)); +} + +CharData_SaveData_Vector3::~CharData_SaveData_Vector3() { + // @@protoc_insertion_point(destructor:MSRProto.CharData.SaveData.Vector3) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void CharData_SaveData_Vector3::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void CharData_SaveData_Vector3::ArenaDtor(void* object) { + CharData_SaveData_Vector3* _this = reinterpret_cast< CharData_SaveData_Vector3* >(object); + (void)_this; +} +void CharData_SaveData_Vector3::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CharData_SaveData_Vector3::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CharData_SaveData_Vector3::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.CharData.SaveData.Vector3) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&x_, 0, static_cast( + reinterpret_cast(&z_) - + reinterpret_cast(&x_)) + sizeof(z_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CharData_SaveData_Vector3::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // double x = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { + x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // double y = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // double z = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 25)) { + z_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } 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* CharData_SaveData_Vector3::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.CharData.SaveData.Vector3) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // double x = 1; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_x = this->_internal_x(); + uint64_t raw_x; + memcpy(&raw_x, &tmp_x, sizeof(tmp_x)); + if (raw_x != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_x(), target); + } + + // double y = 2; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_y = this->_internal_y(); + uint64_t raw_y; + memcpy(&raw_y, &tmp_y, sizeof(tmp_y)); + if (raw_y != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_y(), target); + } + + // double z = 3; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_z = this->_internal_z(); + uint64_t raw_z; + memcpy(&raw_z, &tmp_z, sizeof(tmp_z)); + if (raw_z != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_z(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.CharData.SaveData.Vector3) + return target; +} + +size_t CharData_SaveData_Vector3::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.CharData.SaveData.Vector3) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double x = 1; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_x = this->_internal_x(); + uint64_t raw_x; + memcpy(&raw_x, &tmp_x, sizeof(tmp_x)); + if (raw_x != 0) { + total_size += 1 + 8; + } + + // double y = 2; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_y = this->_internal_y(); + uint64_t raw_y; + memcpy(&raw_y, &tmp_y, sizeof(tmp_y)); + if (raw_y != 0) { + total_size += 1 + 8; + } + + // double z = 3; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_z = this->_internal_z(); + uint64_t raw_z; + memcpy(&raw_z, &tmp_z, sizeof(tmp_z)); + if (raw_z != 0) { + total_size += 1 + 8; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CharData_SaveData_Vector3::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + CharData_SaveData_Vector3::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CharData_SaveData_Vector3::GetClassData() const { return &_class_data_; } + +void CharData_SaveData_Vector3::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void CharData_SaveData_Vector3::MergeFrom(const CharData_SaveData_Vector3& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.CharData.SaveData.Vector3) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_x = from._internal_x(); + uint64_t raw_x; + memcpy(&raw_x, &tmp_x, sizeof(tmp_x)); + if (raw_x != 0) { + _internal_set_x(from._internal_x()); + } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_y = from._internal_y(); + uint64_t raw_y; + memcpy(&raw_y, &tmp_y, sizeof(tmp_y)); + if (raw_y != 0) { + _internal_set_y(from._internal_y()); + } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_z = from._internal_z(); + uint64_t raw_z; + memcpy(&raw_z, &tmp_z, sizeof(tmp_z)); + if (raw_z != 0) { + _internal_set_z(from._internal_z()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CharData_SaveData_Vector3::CopyFrom(const CharData_SaveData_Vector3& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.CharData.SaveData.Vector3) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CharData_SaveData_Vector3::IsInitialized() const { + return true; +} + +void CharData_SaveData_Vector3::InternalSwap(CharData_SaveData_Vector3* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CharData_SaveData_Vector3, z_) + + sizeof(CharData_SaveData_Vector3::z_) + - PROTOBUF_FIELD_OFFSET(CharData_SaveData_Vector3, x_)>( + reinterpret_cast(&x_), + reinterpret_cast(&other->x_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CharData_SaveData_Vector3::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[5]); +} + +// =================================================================== + +class CharData_SaveData::_Internal { + public: + static const ::MSRProto::CharData_SaveData_Vector3& origin(const CharData_SaveData* msg); + static const ::MSRProto::CharData_SaveData_Vector3& angles(const CharData_SaveData* msg); +}; + +const ::MSRProto::CharData_SaveData_Vector3& +CharData_SaveData::_Internal::origin(const CharData_SaveData* msg) { + return *msg->origin_; +} +const ::MSRProto::CharData_SaveData_Vector3& +CharData_SaveData::_Internal::angles(const CharData_SaveData* msg) { + return *msg->angles_; +} +CharData_SaveData::CharData_SaveData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.CharData.SaveData) +} +CharData_SaveData::CharData_SaveData(const CharData_SaveData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArenaForAllocation()); + } + steamid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + steamid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_steamid().empty()) { + steamid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_steamid(), + GetArenaForAllocation()); + } + race_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + race_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_race().empty()) { + race_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_race(), + GetArenaForAllocation()); + } + mapname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mapname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_mapname().empty()) { + mapname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mapname(), + GetArenaForAllocation()); + } + nextmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + nextmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_nextmap().empty()) { + nextmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_nextmap(), + GetArenaForAllocation()); + } + oldtransition_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + oldtransition_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_oldtransition().empty()) { + oldtransition_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_oldtransition(), + GetArenaForAllocation()); + } + newtransition_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + newtransition_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_newtransition().empty()) { + newtransition_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_newtransition(), + GetArenaForAllocation()); + } + partyname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + partyname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_partyname().empty()) { + partyname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_partyname(), + GetArenaForAllocation()); + } + if (from._internal_has_origin()) { + origin_ = new ::MSRProto::CharData_SaveData_Vector3(*from.origin_); + } else { + origin_ = nullptr; + } + if (from._internal_has_angles()) { + angles_ = new ::MSRProto::CharData_SaveData_Vector3(*from.angles_); + } else { + angles_ = nullptr; + } + ::memcpy(&version_, &from.version_, + static_cast(reinterpret_cast(&timewaitedtoforgetsteal_) - + reinterpret_cast(&version_)) + sizeof(timewaitedtoforgetsteal_)); + // @@protoc_insertion_point(copy_constructor:MSRProto.CharData.SaveData) +} + +inline void CharData_SaveData::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +steamid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + steamid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +race_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + race_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +mapname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mapname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +nextmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + nextmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +oldtransition_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + oldtransition_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +newtransition_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + newtransition_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +partyname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + partyname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&origin_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&timewaitedtoforgetsteal_) - + reinterpret_cast(&origin_)) + sizeof(timewaitedtoforgetsteal_)); +} + +CharData_SaveData::~CharData_SaveData() { + // @@protoc_insertion_point(destructor:MSRProto.CharData.SaveData) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void CharData_SaveData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + steamid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + race_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mapname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + nextmap_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + oldtransition_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + newtransition_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partyname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete origin_; + if (this != internal_default_instance()) delete angles_; +} + +void CharData_SaveData::ArenaDtor(void* object) { + CharData_SaveData* _this = reinterpret_cast< CharData_SaveData* >(object); + (void)_this; +} +void CharData_SaveData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CharData_SaveData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CharData_SaveData::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.CharData.SaveData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + steamid_.ClearToEmpty(); + race_.ClearToEmpty(); + mapname_.ClearToEmpty(); + nextmap_.ClearToEmpty(); + oldtransition_.ClearToEmpty(); + newtransition_.ClearToEmpty(); + partyname_.ClearToEmpty(); + if (GetArenaForAllocation() == nullptr && origin_ != nullptr) { + delete origin_; + } + origin_ = nullptr; + if (GetArenaForAllocation() == nullptr && angles_ != nullptr) { + delete angles_; + } + angles_ = nullptr; + ::memset(&version_, 0, static_cast( + reinterpret_cast(&timewaitedtoforgetsteal_) - + reinterpret_cast(&version_)) + sizeof(timewaitedtoforgetsteal_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CharData_SaveData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.name")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string steamId = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_steamid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.steamId")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string race = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_race(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.race")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .MSRProto.CharData.SaveData.GenderId gender = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_gender(static_cast<::MSRProto::CharData_SaveData_GenderId>(val)); + } else + goto handle_unusual; + continue; + // string mapName = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_mapname(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.mapName")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string nextMap = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_nextmap(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.nextMap")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string oldTransition = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_oldtransition(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.oldTransition")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string newTransition = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_newtransition(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.newTransition")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .MSRProto.CharData.SaveData.Vector3 origin = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_origin(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .MSRProto.CharData.SaveData.Vector3 angles = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_angles(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // bool isElite = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + iselite_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 gold = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + gold_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 maxHP = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + maxhp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 maxMP = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + maxmp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 currentHP = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + currenthp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 currentMP = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { + currentmp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string partyName = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + auto str = _internal_mutable_partyname(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.SaveData.partyName")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 partyId = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + partyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // uint32 playerKills = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + playerkills_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // double timeWaitedToForgetKill = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 169)) { + timewaitedtoforgetkill_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // double timeWaitedToForgetSteal = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 177)) { + timewaitedtoforgetsteal_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } 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* CharData_SaveData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.CharData.SaveData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // int32 version = 1; + if (this->_internal_version() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_version(), target); + } + + // string name = 2; + if (!this->_internal_name().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.name"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_name(), target); + } + + // string steamId = 3; + if (!this->_internal_steamid().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_steamid().data(), static_cast(this->_internal_steamid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.steamId"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_steamid(), target); + } + + // string race = 4; + if (!this->_internal_race().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_race().data(), static_cast(this->_internal_race().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.race"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_race(), target); + } + + // .MSRProto.CharData.SaveData.GenderId gender = 5; + if (this->_internal_gender() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_gender(), target); + } + + // string mapName = 6; + if (!this->_internal_mapname().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_mapname().data(), static_cast(this->_internal_mapname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.mapName"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_mapname(), target); + } + + // string nextMap = 7; + if (!this->_internal_nextmap().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_nextmap().data(), static_cast(this->_internal_nextmap().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.nextMap"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_nextmap(), target); + } + + // string oldTransition = 8; + if (!this->_internal_oldtransition().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_oldtransition().data(), static_cast(this->_internal_oldtransition().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.oldTransition"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_oldtransition(), target); + } + + // string newTransition = 9; + if (!this->_internal_newtransition().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_newtransition().data(), static_cast(this->_internal_newtransition().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.newTransition"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_newtransition(), target); + } + + // .MSRProto.CharData.SaveData.Vector3 origin = 10; + if (this->_internal_has_origin()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::origin(this), target, stream); + } + + // .MSRProto.CharData.SaveData.Vector3 angles = 11; + if (this->_internal_has_angles()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::angles(this), target, stream); + } + + // bool isElite = 12; + if (this->_internal_iselite() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(12, this->_internal_iselite(), target); + } + + // uint32 gold = 13; + if (this->_internal_gold() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(13, this->_internal_gold(), target); + } + + // uint32 maxHP = 14; + if (this->_internal_maxhp() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(14, this->_internal_maxhp(), target); + } + + // uint32 maxMP = 15; + if (this->_internal_maxmp() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(15, this->_internal_maxmp(), target); + } + + // uint32 currentHP = 16; + if (this->_internal_currenthp() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(16, this->_internal_currenthp(), target); + } + + // uint32 currentMP = 17; + if (this->_internal_currentmp() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(17, this->_internal_currentmp(), target); + } + + // string partyName = 18; + if (!this->_internal_partyname().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_partyname().data(), static_cast(this->_internal_partyname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.SaveData.partyName"); + target = stream->WriteStringMaybeAliased( + 18, this->_internal_partyname(), target); + } + + // uint32 partyId = 19; + if (this->_internal_partyid() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(19, this->_internal_partyid(), target); + } + + // uint32 playerKills = 20; + if (this->_internal_playerkills() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(20, this->_internal_playerkills(), target); + } + + // double timeWaitedToForgetKill = 21; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_timewaitedtoforgetkill = this->_internal_timewaitedtoforgetkill(); + uint64_t raw_timewaitedtoforgetkill; + memcpy(&raw_timewaitedtoforgetkill, &tmp_timewaitedtoforgetkill, sizeof(tmp_timewaitedtoforgetkill)); + if (raw_timewaitedtoforgetkill != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(21, this->_internal_timewaitedtoforgetkill(), target); + } + + // double timeWaitedToForgetSteal = 22; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_timewaitedtoforgetsteal = this->_internal_timewaitedtoforgetsteal(); + uint64_t raw_timewaitedtoforgetsteal; + memcpy(&raw_timewaitedtoforgetsteal, &tmp_timewaitedtoforgetsteal, sizeof(tmp_timewaitedtoforgetsteal)); + if (raw_timewaitedtoforgetsteal != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(22, this->_internal_timewaitedtoforgetsteal(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.CharData.SaveData) + return target; +} + +size_t CharData_SaveData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.CharData.SaveData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 2; + if (!this->_internal_name().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // string steamId = 3; + if (!this->_internal_steamid().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_steamid()); + } + + // string race = 4; + if (!this->_internal_race().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_race()); + } + + // string mapName = 6; + if (!this->_internal_mapname().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mapname()); + } + + // string nextMap = 7; + if (!this->_internal_nextmap().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_nextmap()); + } + + // string oldTransition = 8; + if (!this->_internal_oldtransition().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_oldtransition()); + } + + // string newTransition = 9; + if (!this->_internal_newtransition().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_newtransition()); + } + + // string partyName = 18; + if (!this->_internal_partyname().empty()) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_partyname()); + } + + // .MSRProto.CharData.SaveData.Vector3 origin = 10; + if (this->_internal_has_origin()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *origin_); + } + + // .MSRProto.CharData.SaveData.Vector3 angles = 11; + if (this->_internal_has_angles()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *angles_); + } + + // int32 version = 1; + if (this->_internal_version() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_version()); + } + + // .MSRProto.CharData.SaveData.GenderId gender = 5; + if (this->_internal_gender() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_gender()); + } + + // bool isElite = 12; + if (this->_internal_iselite() != 0) { + total_size += 1 + 1; + } + + // uint32 gold = 13; + if (this->_internal_gold() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_gold()); + } + + // uint32 maxHP = 14; + if (this->_internal_maxhp() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_maxhp()); + } + + // uint32 maxMP = 15; + if (this->_internal_maxmp() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_maxmp()); + } + + // uint32 currentHP = 16; + if (this->_internal_currenthp() != 0) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_currenthp()); + } + + // uint32 currentMP = 17; + if (this->_internal_currentmp() != 0) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_currentmp()); + } + + // uint32 partyId = 19; + if (this->_internal_partyid() != 0) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_partyid()); + } + + // uint32 playerKills = 20; + if (this->_internal_playerkills() != 0) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_playerkills()); + } + + // double timeWaitedToForgetKill = 21; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_timewaitedtoforgetkill = this->_internal_timewaitedtoforgetkill(); + uint64_t raw_timewaitedtoforgetkill; + memcpy(&raw_timewaitedtoforgetkill, &tmp_timewaitedtoforgetkill, sizeof(tmp_timewaitedtoforgetkill)); + if (raw_timewaitedtoforgetkill != 0) { + total_size += 2 + 8; + } + + // double timeWaitedToForgetSteal = 22; + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_timewaitedtoforgetsteal = this->_internal_timewaitedtoforgetsteal(); + uint64_t raw_timewaitedtoforgetsteal; + memcpy(&raw_timewaitedtoforgetsteal, &tmp_timewaitedtoforgetsteal, sizeof(tmp_timewaitedtoforgetsteal)); + if (raw_timewaitedtoforgetsteal != 0) { + total_size += 2 + 8; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CharData_SaveData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + CharData_SaveData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CharData_SaveData::GetClassData() const { return &_class_data_; } + +void CharData_SaveData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void CharData_SaveData::MergeFrom(const CharData_SaveData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.CharData.SaveData) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _internal_set_name(from._internal_name()); + } + if (!from._internal_steamid().empty()) { + _internal_set_steamid(from._internal_steamid()); + } + if (!from._internal_race().empty()) { + _internal_set_race(from._internal_race()); + } + if (!from._internal_mapname().empty()) { + _internal_set_mapname(from._internal_mapname()); + } + if (!from._internal_nextmap().empty()) { + _internal_set_nextmap(from._internal_nextmap()); + } + if (!from._internal_oldtransition().empty()) { + _internal_set_oldtransition(from._internal_oldtransition()); + } + if (!from._internal_newtransition().empty()) { + _internal_set_newtransition(from._internal_newtransition()); + } + if (!from._internal_partyname().empty()) { + _internal_set_partyname(from._internal_partyname()); + } + if (from._internal_has_origin()) { + _internal_mutable_origin()->::MSRProto::CharData_SaveData_Vector3::MergeFrom(from._internal_origin()); + } + if (from._internal_has_angles()) { + _internal_mutable_angles()->::MSRProto::CharData_SaveData_Vector3::MergeFrom(from._internal_angles()); + } + if (from._internal_version() != 0) { + _internal_set_version(from._internal_version()); + } + if (from._internal_gender() != 0) { + _internal_set_gender(from._internal_gender()); + } + if (from._internal_iselite() != 0) { + _internal_set_iselite(from._internal_iselite()); + } + if (from._internal_gold() != 0) { + _internal_set_gold(from._internal_gold()); + } + if (from._internal_maxhp() != 0) { + _internal_set_maxhp(from._internal_maxhp()); + } + if (from._internal_maxmp() != 0) { + _internal_set_maxmp(from._internal_maxmp()); + } + if (from._internal_currenthp() != 0) { + _internal_set_currenthp(from._internal_currenthp()); + } + if (from._internal_currentmp() != 0) { + _internal_set_currentmp(from._internal_currentmp()); + } + if (from._internal_partyid() != 0) { + _internal_set_partyid(from._internal_partyid()); + } + if (from._internal_playerkills() != 0) { + _internal_set_playerkills(from._internal_playerkills()); + } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_timewaitedtoforgetkill = from._internal_timewaitedtoforgetkill(); + uint64_t raw_timewaitedtoforgetkill; + memcpy(&raw_timewaitedtoforgetkill, &tmp_timewaitedtoforgetkill, sizeof(tmp_timewaitedtoforgetkill)); + if (raw_timewaitedtoforgetkill != 0) { + _internal_set_timewaitedtoforgetkill(from._internal_timewaitedtoforgetkill()); + } + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_timewaitedtoforgetsteal = from._internal_timewaitedtoforgetsteal(); + uint64_t raw_timewaitedtoforgetsteal; + memcpy(&raw_timewaitedtoforgetsteal, &tmp_timewaitedtoforgetsteal, sizeof(tmp_timewaitedtoforgetsteal)); + if (raw_timewaitedtoforgetsteal != 0) { + _internal_set_timewaitedtoforgetsteal(from._internal_timewaitedtoforgetsteal()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CharData_SaveData::CopyFrom(const CharData_SaveData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.CharData.SaveData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CharData_SaveData::IsInitialized() const { + return true; +} + +void CharData_SaveData::InternalSwap(CharData_SaveData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &steamid_, lhs_arena, + &other->steamid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &race_, lhs_arena, + &other->race_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &mapname_, lhs_arena, + &other->mapname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &nextmap_, lhs_arena, + &other->nextmap_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &oldtransition_, lhs_arena, + &other->oldtransition_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &newtransition_, lhs_arena, + &other->newtransition_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &partyname_, lhs_arena, + &other->partyname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CharData_SaveData, timewaitedtoforgetsteal_) + + sizeof(CharData_SaveData::timewaitedtoforgetsteal_) + - PROTOBUF_FIELD_OFFSET(CharData_SaveData, origin_)>( + reinterpret_cast(&origin_), + reinterpret_cast(&other->origin_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CharData_SaveData::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[6]); +} + +// =================================================================== + +CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse() {} +CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::MergeFrom(const CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[7]); +} + +// =================================================================== + +class CharData_Companion::_Internal { + public: +}; + +CharData_Companion::CharData_Companion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + scriptedsavevariables_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.CharData.Companion) +} +CharData_Companion::CharData_Companion(const CharData_Companion& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + scriptedsavevariables_.MergeFrom(from.scriptedsavevariables_); + scriptname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + scriptname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (!from._internal_scriptname().empty()) { + scriptname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_scriptname(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:MSRProto.CharData.Companion) +} + +inline void CharData_Companion::SharedCtor() { +scriptname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + scriptname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +CharData_Companion::~CharData_Companion() { + // @@protoc_insertion_point(destructor:MSRProto.CharData.Companion) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void CharData_Companion::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + scriptname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CharData_Companion::ArenaDtor(void* object) { + CharData_Companion* _this = reinterpret_cast< CharData_Companion* >(object); + (void)_this; + _this->scriptedsavevariables_. ~MapField(); +} +inline void CharData_Companion::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena) { + if (arena != nullptr) { + arena->OwnCustomDestructor(this, &CharData_Companion::ArenaDtor); + } +} +void CharData_Companion::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CharData_Companion::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.CharData.Companion) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + scriptedsavevariables_.Clear(); + scriptname_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CharData_Companion::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string scriptName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_scriptname(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.Companion.scriptName")); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // map scriptedSaveVariables = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&scriptedsavevariables_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* CharData_Companion::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.CharData.Companion) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // string scriptName = 1; + if (!this->_internal_scriptname().empty()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_scriptname().data(), static_cast(this->_internal_scriptname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.Companion.scriptName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_scriptname(), target); + } + + // map scriptedSaveVariables = 2; + if (!this->_internal_scriptedsavevariables().empty()) { + typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + (void)p; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), static_cast(p->first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.Companion.ScriptedSaveVariablesEntry.key"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + p->second.data(), static_cast(p->second.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.Companion.ScriptedSaveVariablesEntry.value"); + } + }; + + if (stream->IsSerializationDeterministic() && + this->_internal_scriptedsavevariables().size() > 1) { + ::std::unique_ptr items( + new SortItem[this->_internal_scriptedsavevariables().size()]); + typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::size_type size_type; + size_type n = 0; + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator + it = this->_internal_scriptedsavevariables().begin(); + it != this->_internal_scriptedsavevariables().end(); ++it, ++n) { + items[static_cast(n)] = SortItem(&*it); + } + ::std::sort(&items[0], &items[static_cast(n)], Less()); + for (size_type i = 0; i < n; i++) { + target = CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::Funcs::InternalSerialize(2, items[static_cast(i)]->first, items[static_cast(i)]->second, target, stream); + Utf8Check::Check(&(*items[static_cast(i)])); + } + } else { + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator + it = this->_internal_scriptedsavevariables().begin(); + it != this->_internal_scriptedsavevariables().end(); ++it) { + target = CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::Funcs::InternalSerialize(2, it->first, it->second, target, stream); + Utf8Check::Check(&(*it)); + } + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.CharData.Companion) + return target; +} + +size_t CharData_Companion::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.CharData.Companion) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // map scriptedSaveVariables = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_scriptedsavevariables_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator + it = this->_internal_scriptedsavevariables().begin(); + it != this->_internal_scriptedsavevariables().end(); ++it) { + total_size += CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // string scriptName = 1; + if (!this->_internal_scriptname().empty()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_scriptname()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CharData_Companion::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + CharData_Companion::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CharData_Companion::GetClassData() const { return &_class_data_; } + +void CharData_Companion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void CharData_Companion::MergeFrom(const CharData_Companion& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.CharData.Companion) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + scriptedsavevariables_.MergeFrom(from.scriptedsavevariables_); + if (!from._internal_scriptname().empty()) { + _internal_set_scriptname(from._internal_scriptname()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CharData_Companion::CopyFrom(const CharData_Companion& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.CharData.Companion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CharData_Companion::IsInitialized() const { + return true; +} + +void CharData_Companion::InternalSwap(CharData_Companion* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + scriptedsavevariables_.InternalSwap(&other->scriptedsavevariables_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &scriptname_, lhs_arena, + &other->scriptname_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CharData_Companion::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[8]); +} + +// =================================================================== + +CharData_QuestsEntry_DoNotUse::CharData_QuestsEntry_DoNotUse() {} +CharData_QuestsEntry_DoNotUse::CharData_QuestsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : SuperType(arena) {} +void CharData_QuestsEntry_DoNotUse::MergeFrom(const CharData_QuestsEntry_DoNotUse& other) { + MergeFromInternal(other); +} +::PROTOBUF_NAMESPACE_ID::Metadata CharData_QuestsEntry_DoNotUse::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[9]); +} + +// =================================================================== + +class CharData_QuickSlot::_Internal { + public: +}; + +CharData_QuickSlot::CharData_QuickSlot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.CharData.QuickSlot) +} +CharData_QuickSlot::CharData_QuickSlot(const CharData_QuickSlot& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&type_, &from.type_, + static_cast(reinterpret_cast(&id_) - + reinterpret_cast(&type_)) + sizeof(id_)); + // @@protoc_insertion_point(copy_constructor:MSRProto.CharData.QuickSlot) +} + +inline void CharData_QuickSlot::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&id_) - + reinterpret_cast(&type_)) + sizeof(id_)); +} + +CharData_QuickSlot::~CharData_QuickSlot() { + // @@protoc_insertion_point(destructor:MSRProto.CharData.QuickSlot) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void CharData_QuickSlot::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void CharData_QuickSlot::ArenaDtor(void* object) { + CharData_QuickSlot* _this = reinterpret_cast< CharData_QuickSlot* >(object); + (void)_this; +} +void CharData_QuickSlot::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CharData_QuickSlot::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CharData_QuickSlot::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.CharData.QuickSlot) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&type_, 0, static_cast( + reinterpret_cast(&id_) - + reinterpret_cast(&type_)) + sizeof(id_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CharData_QuickSlot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .MSRProto.CharData.QuickSlot.QuickSlotTypeId type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_type(static_cast<::MSRProto::CharData_QuickSlot_QuickSlotTypeId>(val)); + } else + goto handle_unusual; + continue; + // uint32 id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + 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* CharData_QuickSlot::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.CharData.QuickSlot) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .MSRProto.CharData.QuickSlot.QuickSlotTypeId type = 1; + if (this->_internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // uint32 id = 2; + if (this->_internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.CharData.QuickSlot) + return target; +} + +size_t CharData_QuickSlot::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.CharData.QuickSlot) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .MSRProto.CharData.QuickSlot.QuickSlotTypeId type = 1; + if (this->_internal_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + // uint32 id = 2; + if (this->_internal_id() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_id()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CharData_QuickSlot::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + CharData_QuickSlot::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CharData_QuickSlot::GetClassData() const { return &_class_data_; } + +void CharData_QuickSlot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void CharData_QuickSlot::MergeFrom(const CharData_QuickSlot& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.CharData.QuickSlot) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_type() != 0) { + _internal_set_type(from._internal_type()); + } + if (from._internal_id() != 0) { + _internal_set_id(from._internal_id()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CharData_QuickSlot::CopyFrom(const CharData_QuickSlot& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.CharData.QuickSlot) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CharData_QuickSlot::IsInitialized() const { + return true; +} + +void CharData_QuickSlot::InternalSwap(CharData_QuickSlot* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CharData_QuickSlot, id_) + + sizeof(CharData_QuickSlot::id_) + - PROTOBUF_FIELD_OFFSET(CharData_QuickSlot, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CharData_QuickSlot::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[10]); +} + +// =================================================================== + +class CharData::_Internal { + public: + static const ::MSRProto::CharData_SaveData& savedata(const CharData* msg); +}; + +const ::MSRProto::CharData_SaveData& +CharData::_Internal::savedata(const CharData* msg) { + return *msg->savedata_; +} +CharData::CharData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), + visitedmaps_(arena), + statlist_(arena), + knownspells_(arena), + items_(arena), + storages_(arena), + companions_(arena), + viewedhelptips_(arena), + quests_(arena), + quickslots_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:MSRProto.CharData) +} +CharData::CharData(const CharData& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + visitedmaps_(from.visitedmaps_), + statlist_(from.statlist_), + knownspells_(from.knownspells_), + items_(from.items_), + storages_(from.storages_), + companions_(from.companions_), + viewedhelptips_(from.viewedhelptips_), + quickslots_(from.quickslots_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + quests_.MergeFrom(from.quests_); + if (from._internal_has_savedata()) { + savedata_ = new ::MSRProto::CharData_SaveData(*from.savedata_); + } else { + savedata_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:MSRProto.CharData) +} + +inline void CharData::SharedCtor() { +savedata_ = nullptr; +} + +CharData::~CharData() { + // @@protoc_insertion_point(destructor:MSRProto.CharData) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +inline void CharData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete savedata_; +} + +void CharData::ArenaDtor(void* object) { + CharData* _this = reinterpret_cast< CharData* >(object); + (void)_this; + _this->quests_. ~MapField(); +} +inline void CharData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena) { + if (arena != nullptr) { + arena->OwnCustomDestructor(this, &CharData::ArenaDtor); + } +} +void CharData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CharData::Clear() { +// @@protoc_insertion_point(message_clear_start:MSRProto.CharData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + visitedmaps_.Clear(); + statlist_.Clear(); + knownspells_.Clear(); + items_.Clear(); + storages_.Clear(); + companions_.Clear(); + viewedhelptips_.Clear(); + quests_.Clear(); + quickslots_.Clear(); + if (GetArenaForAllocation() == nullptr && savedata_ != nullptr) { + delete savedata_; + } + savedata_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CharData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .MSRProto.CharData.SaveData saveData = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_savedata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string visitedMaps = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_visitedmaps(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.visitedMaps")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.Stat statList = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_statlist(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string knownSpells = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_knownspells(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.knownSpells")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.GenericItemFull items = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_items(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.Storage storages = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_storages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.CharData.Companion companions = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_companions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string viewedHelpTips = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_viewedhelptips(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MSRProto.CharData.viewedHelpTips")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + // map quests = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(&quests_, ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .MSRProto.CharData.QuickSlot quickslots = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_quickslots(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(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* CharData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:MSRProto.CharData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .MSRProto.CharData.SaveData saveData = 1; + if (this->_internal_has_savedata()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::savedata(this), target, stream); + } + + // repeated string visitedMaps = 2; + for (int i = 0, n = this->_internal_visitedmaps_size(); i < n; i++) { + const auto& s = this->_internal_visitedmaps(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.visitedMaps"); + target = stream->WriteString(2, s, target); + } + + // repeated .MSRProto.Stat statList = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_statlist_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_statlist(i), target, stream); + } + + // repeated string knownSpells = 4; + for (int i = 0, n = this->_internal_knownspells_size(); i < n; i++) { + const auto& s = this->_internal_knownspells(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.knownSpells"); + target = stream->WriteString(4, s, target); + } + + // repeated .MSRProto.GenericItemFull items = 5; + for (unsigned int i = 0, + n = static_cast(this->_internal_items_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, this->_internal_items(i), target, stream); + } + + // repeated .MSRProto.Storage storages = 6; + for (unsigned int i = 0, + n = static_cast(this->_internal_storages_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, this->_internal_storages(i), target, stream); + } + + // repeated .MSRProto.CharData.Companion companions = 7; + for (unsigned int i = 0, + n = static_cast(this->_internal_companions_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, this->_internal_companions(i), target, stream); + } + + // repeated string viewedHelpTips = 8; + for (int i = 0, n = this->_internal_viewedhelptips_size(); i < n; i++) { + const auto& s = this->_internal_viewedhelptips(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.viewedHelpTips"); + target = stream->WriteString(8, s, target); + } + + // map quests = 9; + if (!this->_internal_quests().empty()) { + typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_pointer + ConstPtr; + typedef ConstPtr SortItem; + typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst Less; + struct Utf8Check { + static void Check(ConstPtr p) { + (void)p; + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + p->first.data(), static_cast(p->first.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.QuestsEntry.key"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + p->second.data(), static_cast(p->second.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "MSRProto.CharData.QuestsEntry.value"); + } + }; + + if (stream->IsSerializationDeterministic() && + this->_internal_quests().size() > 1) { + ::std::unique_ptr items( + new SortItem[this->_internal_quests().size()]); + typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::size_type size_type; + size_type n = 0; + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator + it = this->_internal_quests().begin(); + it != this->_internal_quests().end(); ++it, ++n) { + items[static_cast(n)] = SortItem(&*it); + } + ::std::sort(&items[0], &items[static_cast(n)], Less()); + for (size_type i = 0; i < n; i++) { + target = CharData_QuestsEntry_DoNotUse::Funcs::InternalSerialize(9, items[static_cast(i)]->first, items[static_cast(i)]->second, target, stream); + Utf8Check::Check(&(*items[static_cast(i)])); + } + } else { + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator + it = this->_internal_quests().begin(); + it != this->_internal_quests().end(); ++it) { + target = CharData_QuestsEntry_DoNotUse::Funcs::InternalSerialize(9, it->first, it->second, target, stream); + Utf8Check::Check(&(*it)); + } + } + } + + // repeated .MSRProto.CharData.QuickSlot quickslots = 10; + for (unsigned int i = 0, + n = static_cast(this->_internal_quickslots_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(10, this->_internal_quickslots(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:MSRProto.CharData) + return target; +} + +size_t CharData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:MSRProto.CharData) + 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 string visitedMaps = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(visitedmaps_.size()); + for (int i = 0, n = visitedmaps_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + visitedmaps_.Get(i)); + } + + // repeated .MSRProto.Stat statList = 3; + total_size += 1UL * this->_internal_statlist_size(); + for (const auto& msg : this->statlist_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string knownSpells = 4; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(knownspells_.size()); + for (int i = 0, n = knownspells_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + knownspells_.Get(i)); + } + + // repeated .MSRProto.GenericItemFull items = 5; + total_size += 1UL * this->_internal_items_size(); + for (const auto& msg : this->items_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .MSRProto.Storage storages = 6; + total_size += 1UL * this->_internal_storages_size(); + for (const auto& msg : this->storages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .MSRProto.CharData.Companion companions = 7; + total_size += 1UL * this->_internal_companions_size(); + for (const auto& msg : this->companions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string viewedHelpTips = 8; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(viewedhelptips_.size()); + for (int i = 0, n = viewedhelptips_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + viewedhelptips_.Get(i)); + } + + // map quests = 9; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_quests_size()); + for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator + it = this->_internal_quests().begin(); + it != this->_internal_quests().end(); ++it) { + total_size += CharData_QuestsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second); + } + + // repeated .MSRProto.CharData.QuickSlot quickslots = 10; + total_size += 1UL * this->_internal_quickslots_size(); + for (const auto& msg : this->quickslots_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .MSRProto.CharData.SaveData saveData = 1; + if (this->_internal_has_savedata()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *savedata_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CharData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + CharData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CharData::GetClassData() const { return &_class_data_; } + +void CharData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); +} + + +void CharData::MergeFrom(const CharData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:MSRProto.CharData) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + visitedmaps_.MergeFrom(from.visitedmaps_); + statlist_.MergeFrom(from.statlist_); + knownspells_.MergeFrom(from.knownspells_); + items_.MergeFrom(from.items_); + storages_.MergeFrom(from.storages_); + companions_.MergeFrom(from.companions_); + viewedhelptips_.MergeFrom(from.viewedhelptips_); + quests_.MergeFrom(from.quests_); + quickslots_.MergeFrom(from.quickslots_); + if (from._internal_has_savedata()) { + _internal_mutable_savedata()->::MSRProto::CharData_SaveData::MergeFrom(from._internal_savedata()); + } + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CharData::CopyFrom(const CharData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:MSRProto.CharData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CharData::IsInitialized() const { + return true; +} + +void CharData::InternalSwap(CharData* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + visitedmaps_.InternalSwap(&other->visitedmaps_); + statlist_.InternalSwap(&other->statlist_); + knownspells_.InternalSwap(&other->knownspells_); + items_.InternalSwap(&other->items_); + storages_.InternalSwap(&other->storages_); + companions_.InternalSwap(&other->companions_); + viewedhelptips_.InternalSwap(&other->viewedhelptips_); + quests_.InternalSwap(&other->quests_); + quickslots_.InternalSwap(&other->quickslots_); + swap(savedata_, other->savedata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CharData::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_savedata_2eproto_getter, &descriptor_table_savedata_2eproto_once, + file_level_metadata_savedata_2eproto[11]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace MSRProto +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::MSRProto::Stat_SubStat* Arena::CreateMaybeMessage< ::MSRProto::Stat_SubStat >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::Stat_SubStat >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::Stat* Arena::CreateMaybeMessage< ::MSRProto::Stat >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::Stat >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::GenericItemFull_GenericItem* Arena::CreateMaybeMessage< ::MSRProto::GenericItemFull_GenericItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::GenericItemFull_GenericItem >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::GenericItemFull* Arena::CreateMaybeMessage< ::MSRProto::GenericItemFull >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::GenericItemFull >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::Storage* Arena::CreateMaybeMessage< ::MSRProto::Storage >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::Storage >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData_SaveData_Vector3* Arena::CreateMaybeMessage< ::MSRProto::CharData_SaveData_Vector3 >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData_SaveData_Vector3 >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData_SaveData* Arena::CreateMaybeMessage< ::MSRProto::CharData_SaveData >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData_SaveData >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse* Arena::CreateMaybeMessage< ::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData_Companion* Arena::CreateMaybeMessage< ::MSRProto::CharData_Companion >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData_Companion >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData_QuestsEntry_DoNotUse* Arena::CreateMaybeMessage< ::MSRProto::CharData_QuestsEntry_DoNotUse >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData_QuestsEntry_DoNotUse >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData_QuickSlot* Arena::CreateMaybeMessage< ::MSRProto::CharData_QuickSlot >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData_QuickSlot >(arena); +} +template<> PROTOBUF_NOINLINE ::MSRProto::CharData* Arena::CreateMaybeMessage< ::MSRProto::CharData >(Arena* arena) { + return Arena::CreateMessageInternal< ::MSRProto::CharData >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/src/game/server/proto/savedata.pb.h b/src/game/server/proto/savedata.pb.h new file mode 100644 index 00000000..61449e8c --- /dev/null +++ b/src/game/server/proto/savedata.pb.h @@ -0,0 +1,4937 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: savedata.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_savedata_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_savedata_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3019000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3019006 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_savedata_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_savedata_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_savedata_2eproto; +namespace MSRProto { +class CharData; +struct CharDataDefaultTypeInternal; +extern CharDataDefaultTypeInternal _CharData_default_instance_; +class CharData_Companion; +struct CharData_CompanionDefaultTypeInternal; +extern CharData_CompanionDefaultTypeInternal _CharData_Companion_default_instance_; +class CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse; +struct CharData_Companion_ScriptedSaveVariablesEntry_DoNotUseDefaultTypeInternal; +extern CharData_Companion_ScriptedSaveVariablesEntry_DoNotUseDefaultTypeInternal _CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse_default_instance_; +class CharData_QuestsEntry_DoNotUse; +struct CharData_QuestsEntry_DoNotUseDefaultTypeInternal; +extern CharData_QuestsEntry_DoNotUseDefaultTypeInternal _CharData_QuestsEntry_DoNotUse_default_instance_; +class CharData_QuickSlot; +struct CharData_QuickSlotDefaultTypeInternal; +extern CharData_QuickSlotDefaultTypeInternal _CharData_QuickSlot_default_instance_; +class CharData_SaveData; +struct CharData_SaveDataDefaultTypeInternal; +extern CharData_SaveDataDefaultTypeInternal _CharData_SaveData_default_instance_; +class CharData_SaveData_Vector3; +struct CharData_SaveData_Vector3DefaultTypeInternal; +extern CharData_SaveData_Vector3DefaultTypeInternal _CharData_SaveData_Vector3_default_instance_; +class GenericItemFull; +struct GenericItemFullDefaultTypeInternal; +extern GenericItemFullDefaultTypeInternal _GenericItemFull_default_instance_; +class GenericItemFull_GenericItem; +struct GenericItemFull_GenericItemDefaultTypeInternal; +extern GenericItemFull_GenericItemDefaultTypeInternal _GenericItemFull_GenericItem_default_instance_; +class Stat; +struct StatDefaultTypeInternal; +extern StatDefaultTypeInternal _Stat_default_instance_; +class Stat_SubStat; +struct Stat_SubStatDefaultTypeInternal; +extern Stat_SubStatDefaultTypeInternal _Stat_SubStat_default_instance_; +class Storage; +struct StorageDefaultTypeInternal; +extern StorageDefaultTypeInternal _Storage_default_instance_; +} // namespace MSRProto +PROTOBUF_NAMESPACE_OPEN +template<> ::MSRProto::CharData* Arena::CreateMaybeMessage<::MSRProto::CharData>(Arena*); +template<> ::MSRProto::CharData_Companion* Arena::CreateMaybeMessage<::MSRProto::CharData_Companion>(Arena*); +template<> ::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse* Arena::CreateMaybeMessage<::MSRProto::CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse>(Arena*); +template<> ::MSRProto::CharData_QuestsEntry_DoNotUse* Arena::CreateMaybeMessage<::MSRProto::CharData_QuestsEntry_DoNotUse>(Arena*); +template<> ::MSRProto::CharData_QuickSlot* Arena::CreateMaybeMessage<::MSRProto::CharData_QuickSlot>(Arena*); +template<> ::MSRProto::CharData_SaveData* Arena::CreateMaybeMessage<::MSRProto::CharData_SaveData>(Arena*); +template<> ::MSRProto::CharData_SaveData_Vector3* Arena::CreateMaybeMessage<::MSRProto::CharData_SaveData_Vector3>(Arena*); +template<> ::MSRProto::GenericItemFull* Arena::CreateMaybeMessage<::MSRProto::GenericItemFull>(Arena*); +template<> ::MSRProto::GenericItemFull_GenericItem* Arena::CreateMaybeMessage<::MSRProto::GenericItemFull_GenericItem>(Arena*); +template<> ::MSRProto::Stat* Arena::CreateMaybeMessage<::MSRProto::Stat>(Arena*); +template<> ::MSRProto::Stat_SubStat* Arena::CreateMaybeMessage<::MSRProto::Stat_SubStat>(Arena*); +template<> ::MSRProto::Storage* Arena::CreateMaybeMessage<::MSRProto::Storage>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace MSRProto { + +enum Stat_SubStat_SubStatId : int { + Stat_SubStat_SubStatId_SubStatId_UNKNOWN = 0, + Stat_SubStat_SubStatId_Proficiency = 1, + Stat_SubStat_SubStatId_Balance = 2, + Stat_SubStat_SubStatId_Power = 3, + Stat_SubStat_SubStatId_Fire = 1001, + Stat_SubStat_SubStatId_Ice = 1002, + Stat_SubStat_SubStatId_Lightning = 1003, + Stat_SubStat_SubStatId_Divination = 1004, + Stat_SubStat_SubStatId_Affliction = 1005, + Stat_SubStat_SubStatId_Stat_SubStat_SubStatId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + Stat_SubStat_SubStatId_Stat_SubStat_SubStatId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() +}; +bool Stat_SubStat_SubStatId_IsValid(int value); +constexpr Stat_SubStat_SubStatId Stat_SubStat_SubStatId_SubStatId_MIN = Stat_SubStat_SubStatId_SubStatId_UNKNOWN; +constexpr Stat_SubStat_SubStatId Stat_SubStat_SubStatId_SubStatId_MAX = Stat_SubStat_SubStatId_Affliction; +constexpr int Stat_SubStat_SubStatId_SubStatId_ARRAYSIZE = Stat_SubStat_SubStatId_SubStatId_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Stat_SubStat_SubStatId_descriptor(); +template +inline const std::string& Stat_SubStat_SubStatId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Stat_SubStat_SubStatId_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Stat_SubStat_SubStatId_descriptor(), enum_t_value); +} +inline bool Stat_SubStat_SubStatId_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Stat_SubStat_SubStatId* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Stat_SubStat_SubStatId_descriptor(), name, value); +} +enum Stat_StatId : int { + Stat_StatId_StatId_UNKNOWN = 0, + Stat_StatId_Strength = 1, + Stat_StatId_Agility = 2, + Stat_StatId_Concentration = 3, + Stat_StatId_Awareness = 4, + Stat_StatId_Fitness = 5, + Stat_StatId_Wisdom = 6, + Stat_StatId_Swordsmanship = 1001, + Stat_StatId_MartialArts = 1002, + Stat_StatId_SmallArms = 1003, + Stat_StatId_AxeHandling = 1004, + Stat_StatId_BluntArms = 1005, + Stat_StatId_Archery = 1006, + Stat_StatId_SpellCasting = 1007, + Stat_StatId_Parry = 1008, + Stat_StatId_PoleArms = 1009, + Stat_StatId_Stat_StatId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + Stat_StatId_Stat_StatId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() +}; +bool Stat_StatId_IsValid(int value); +constexpr Stat_StatId Stat_StatId_StatId_MIN = Stat_StatId_StatId_UNKNOWN; +constexpr Stat_StatId Stat_StatId_StatId_MAX = Stat_StatId_PoleArms; +constexpr int Stat_StatId_StatId_ARRAYSIZE = Stat_StatId_StatId_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Stat_StatId_descriptor(); +template +inline const std::string& Stat_StatId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Stat_StatId_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Stat_StatId_descriptor(), enum_t_value); +} +inline bool Stat_StatId_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Stat_StatId* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Stat_StatId_descriptor(), name, value); +} +enum GenericItemFull_HandId : int { + GenericItemFull_HandId_HandId_UNKNOWN = 0, + GenericItemFull_HandId_LEFT_HAND = 1, + GenericItemFull_HandId_RIGHT_HAND = 2, + GenericItemFull_HandId_HAND_PLAYERHANDS = 3, + GenericItemFull_HandId_ANY_HAND = 4, + GenericItemFull_HandId_BOTH_HANDS = 5, + GenericItemFull_HandId_GenericItemFull_HandId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + GenericItemFull_HandId_GenericItemFull_HandId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() +}; +bool GenericItemFull_HandId_IsValid(int value); +constexpr GenericItemFull_HandId GenericItemFull_HandId_HandId_MIN = GenericItemFull_HandId_HandId_UNKNOWN; +constexpr GenericItemFull_HandId GenericItemFull_HandId_HandId_MAX = GenericItemFull_HandId_BOTH_HANDS; +constexpr int GenericItemFull_HandId_HandId_ARRAYSIZE = GenericItemFull_HandId_HandId_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GenericItemFull_HandId_descriptor(); +template +inline const std::string& GenericItemFull_HandId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function GenericItemFull_HandId_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + GenericItemFull_HandId_descriptor(), enum_t_value); +} +inline bool GenericItemFull_HandId_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GenericItemFull_HandId* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + GenericItemFull_HandId_descriptor(), name, value); +} +enum CharData_SaveData_GenderId : int { + CharData_SaveData_GenderId_GenderId_UNKNOWN = 0, + CharData_SaveData_GenderId_Male = 1, + CharData_SaveData_GenderId_Female = 2, + CharData_SaveData_GenderId_CharData_SaveData_GenderId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + CharData_SaveData_GenderId_CharData_SaveData_GenderId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() +}; +bool CharData_SaveData_GenderId_IsValid(int value); +constexpr CharData_SaveData_GenderId CharData_SaveData_GenderId_GenderId_MIN = CharData_SaveData_GenderId_GenderId_UNKNOWN; +constexpr CharData_SaveData_GenderId CharData_SaveData_GenderId_GenderId_MAX = CharData_SaveData_GenderId_Female; +constexpr int CharData_SaveData_GenderId_GenderId_ARRAYSIZE = CharData_SaveData_GenderId_GenderId_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CharData_SaveData_GenderId_descriptor(); +template +inline const std::string& CharData_SaveData_GenderId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CharData_SaveData_GenderId_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + CharData_SaveData_GenderId_descriptor(), enum_t_value); +} +inline bool CharData_SaveData_GenderId_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CharData_SaveData_GenderId* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + CharData_SaveData_GenderId_descriptor(), name, value); +} +enum CharData_QuickSlot_QuickSlotTypeId : int { + CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_UNKNOWN = 0, + CharData_QuickSlot_QuickSlotTypeId_QS_EMPTY = 1, + CharData_QuickSlot_QuickSlotTypeId_QS_ITEM = 2, + CharData_QuickSlot_QuickSlotTypeId_QS_SPELL = 3, + CharData_QuickSlot_QuickSlotTypeId_QS_ARROW = 4, + CharData_QuickSlot_QuickSlotTypeId_CharData_QuickSlot_QuickSlotTypeId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + CharData_QuickSlot_QuickSlotTypeId_CharData_QuickSlot_QuickSlotTypeId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() +}; +bool CharData_QuickSlot_QuickSlotTypeId_IsValid(int value); +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_MIN = CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_UNKNOWN; +constexpr CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_MAX = CharData_QuickSlot_QuickSlotTypeId_QS_ARROW; +constexpr int CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_ARRAYSIZE = CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CharData_QuickSlot_QuickSlotTypeId_descriptor(); +template +inline const std::string& CharData_QuickSlot_QuickSlotTypeId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CharData_QuickSlot_QuickSlotTypeId_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + CharData_QuickSlot_QuickSlotTypeId_descriptor(), enum_t_value); +} +inline bool CharData_QuickSlot_QuickSlotTypeId_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CharData_QuickSlot_QuickSlotTypeId* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + CharData_QuickSlot_QuickSlotTypeId_descriptor(), name, value); +} +// =================================================================== + +class Stat_SubStat final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.Stat.SubStat) */ { + public: + inline Stat_SubStat() : Stat_SubStat(nullptr) {} + ~Stat_SubStat() override; + explicit constexpr Stat_SubStat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Stat_SubStat(const Stat_SubStat& from); + Stat_SubStat(Stat_SubStat&& from) noexcept + : Stat_SubStat() { + *this = ::std::move(from); + } + + inline Stat_SubStat& operator=(const Stat_SubStat& from) { + CopyFrom(from); + return *this; + } + inline Stat_SubStat& operator=(Stat_SubStat&& 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 Stat_SubStat& default_instance() { + return *internal_default_instance(); + } + static inline const Stat_SubStat* internal_default_instance() { + return reinterpret_cast( + &_Stat_SubStat_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Stat_SubStat& a, Stat_SubStat& b) { + a.Swap(&b); + } + inline void Swap(Stat_SubStat* 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(Stat_SubStat* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Stat_SubStat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Stat_SubStat& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const Stat_SubStat& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Stat_SubStat* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.Stat.SubStat"; + } + protected: + explicit Stat_SubStat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Stat_SubStat_SubStatId SubStatId; + static constexpr SubStatId SubStatId_UNKNOWN = + Stat_SubStat_SubStatId_SubStatId_UNKNOWN; + static constexpr SubStatId Proficiency = + Stat_SubStat_SubStatId_Proficiency; + static constexpr SubStatId Balance = + Stat_SubStat_SubStatId_Balance; + static constexpr SubStatId Power = + Stat_SubStat_SubStatId_Power; + static constexpr SubStatId Fire = + Stat_SubStat_SubStatId_Fire; + static constexpr SubStatId Ice = + Stat_SubStat_SubStatId_Ice; + static constexpr SubStatId Lightning = + Stat_SubStat_SubStatId_Lightning; + static constexpr SubStatId Divination = + Stat_SubStat_SubStatId_Divination; + static constexpr SubStatId Affliction = + Stat_SubStat_SubStatId_Affliction; + static inline bool SubStatId_IsValid(int value) { + return Stat_SubStat_SubStatId_IsValid(value); + } + static constexpr SubStatId SubStatId_MIN = + Stat_SubStat_SubStatId_SubStatId_MIN; + static constexpr SubStatId SubStatId_MAX = + Stat_SubStat_SubStatId_SubStatId_MAX; + static constexpr int SubStatId_ARRAYSIZE = + Stat_SubStat_SubStatId_SubStatId_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SubStatId_descriptor() { + return Stat_SubStat_SubStatId_descriptor(); + } + template + static inline const std::string& SubStatId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SubStatId_Name."); + return Stat_SubStat_SubStatId_Name(enum_t_value); + } + static inline bool SubStatId_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SubStatId* value) { + return Stat_SubStat_SubStatId_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kSubstatIdFieldNumber = 1, + kValueFieldNumber = 2, + kExpFieldNumber = 3, + }; + // .MSRProto.Stat.SubStat.SubStatId substatId = 1; + void clear_substatid(); + ::MSRProto::Stat_SubStat_SubStatId substatid() const; + void set_substatid(::MSRProto::Stat_SubStat_SubStatId value); + private: + ::MSRProto::Stat_SubStat_SubStatId _internal_substatid() const; + void _internal_set_substatid(::MSRProto::Stat_SubStat_SubStatId value); + public: + + // uint32 value = 2; + void clear_value(); + uint32_t value() const; + void set_value(uint32_t value); + private: + uint32_t _internal_value() const; + void _internal_set_value(uint32_t value); + public: + + // uint32 exp = 3; + void clear_exp(); + uint32_t exp() const; + void set_exp(uint32_t value); + private: + uint32_t _internal_exp() const; + void _internal_set_exp(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.Stat.SubStat) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + int substatid_; + uint32_t value_; + uint32_t exp_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class Stat final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.Stat) */ { + public: + inline Stat() : Stat(nullptr) {} + ~Stat() override; + explicit constexpr Stat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Stat(const Stat& from); + Stat(Stat&& from) noexcept + : Stat() { + *this = ::std::move(from); + } + + inline Stat& operator=(const Stat& from) { + CopyFrom(from); + return *this; + } + inline Stat& operator=(Stat&& 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 Stat& default_instance() { + return *internal_default_instance(); + } + static inline const Stat* internal_default_instance() { + return reinterpret_cast( + &_Stat_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Stat& a, Stat& b) { + a.Swap(&b); + } + inline void Swap(Stat* 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(Stat* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Stat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Stat& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const Stat& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Stat* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.Stat"; + } + protected: + explicit Stat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Stat_SubStat SubStat; + + typedef Stat_StatId StatId; + static constexpr StatId StatId_UNKNOWN = + Stat_StatId_StatId_UNKNOWN; + static constexpr StatId Strength = + Stat_StatId_Strength; + static constexpr StatId Agility = + Stat_StatId_Agility; + static constexpr StatId Concentration = + Stat_StatId_Concentration; + static constexpr StatId Awareness = + Stat_StatId_Awareness; + static constexpr StatId Fitness = + Stat_StatId_Fitness; + static constexpr StatId Wisdom = + Stat_StatId_Wisdom; + static constexpr StatId Swordsmanship = + Stat_StatId_Swordsmanship; + static constexpr StatId MartialArts = + Stat_StatId_MartialArts; + static constexpr StatId SmallArms = + Stat_StatId_SmallArms; + static constexpr StatId AxeHandling = + Stat_StatId_AxeHandling; + static constexpr StatId BluntArms = + Stat_StatId_BluntArms; + static constexpr StatId Archery = + Stat_StatId_Archery; + static constexpr StatId SpellCasting = + Stat_StatId_SpellCasting; + static constexpr StatId Parry = + Stat_StatId_Parry; + static constexpr StatId PoleArms = + Stat_StatId_PoleArms; + static inline bool StatId_IsValid(int value) { + return Stat_StatId_IsValid(value); + } + static constexpr StatId StatId_MIN = + Stat_StatId_StatId_MIN; + static constexpr StatId StatId_MAX = + Stat_StatId_StatId_MAX; + static constexpr int StatId_ARRAYSIZE = + Stat_StatId_StatId_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + StatId_descriptor() { + return Stat_StatId_descriptor(); + } + template + static inline const std::string& StatId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function StatId_Name."); + return Stat_StatId_Name(enum_t_value); + } + static inline bool StatId_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + StatId* value) { + return Stat_StatId_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kSubStatsFieldNumber = 2, + kStatIdFieldNumber = 1, + }; + // repeated .MSRProto.Stat.SubStat subStats = 2; + int substats_size() const; + private: + int _internal_substats_size() const; + public: + void clear_substats(); + ::MSRProto::Stat_SubStat* mutable_substats(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat_SubStat >* + mutable_substats(); + private: + const ::MSRProto::Stat_SubStat& _internal_substats(int index) const; + ::MSRProto::Stat_SubStat* _internal_add_substats(); + public: + const ::MSRProto::Stat_SubStat& substats(int index) const; + ::MSRProto::Stat_SubStat* add_substats(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat_SubStat >& + substats() const; + + // .MSRProto.Stat.StatId statId = 1; + void clear_statid(); + ::MSRProto::Stat_StatId statid() const; + void set_statid(::MSRProto::Stat_StatId value); + private: + ::MSRProto::Stat_StatId _internal_statid() const; + void _internal_set_statid(::MSRProto::Stat_StatId value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.Stat) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat_SubStat > substats_; + int statid_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class GenericItemFull_GenericItem final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.GenericItemFull.GenericItem) */ { + public: + inline GenericItemFull_GenericItem() : GenericItemFull_GenericItem(nullptr) {} + ~GenericItemFull_GenericItem() override; + explicit constexpr GenericItemFull_GenericItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + GenericItemFull_GenericItem(const GenericItemFull_GenericItem& from); + GenericItemFull_GenericItem(GenericItemFull_GenericItem&& from) noexcept + : GenericItemFull_GenericItem() { + *this = ::std::move(from); + } + + inline GenericItemFull_GenericItem& operator=(const GenericItemFull_GenericItem& from) { + CopyFrom(from); + return *this; + } + inline GenericItemFull_GenericItem& operator=(GenericItemFull_GenericItem&& 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 GenericItemFull_GenericItem& default_instance() { + return *internal_default_instance(); + } + static inline const GenericItemFull_GenericItem* internal_default_instance() { + return reinterpret_cast( + &_GenericItemFull_GenericItem_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(GenericItemFull_GenericItem& a, GenericItemFull_GenericItem& b) { + a.Swap(&b); + } + inline void Swap(GenericItemFull_GenericItem* 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(GenericItemFull_GenericItem* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GenericItemFull_GenericItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const GenericItemFull_GenericItem& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const GenericItemFull_GenericItem& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(GenericItemFull_GenericItem* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.GenericItemFull.GenericItem"; + } + protected: + explicit GenericItemFull_GenericItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 2, + kIdFieldNumber = 1, + kPropertiesFieldNumber = 3, + kQuantityFieldNumber = 4, + kQualityFieldNumber = 5, + kMaxQualityFieldNumber = 6, + }; + // string name = 2; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // uint32 id = 1; + void clear_id(); + uint32_t id() const; + void set_id(uint32_t value); + private: + uint32_t _internal_id() const; + void _internal_set_id(uint32_t value); + public: + + // uint32 properties = 3; + void clear_properties(); + uint32_t properties() const; + void set_properties(uint32_t value); + private: + uint32_t _internal_properties() const; + void _internal_set_properties(uint32_t value); + public: + + // uint32 quantity = 4; + void clear_quantity(); + uint32_t quantity() const; + void set_quantity(uint32_t value); + private: + uint32_t _internal_quantity() const; + void _internal_set_quantity(uint32_t value); + public: + + // uint32 quality = 5; + void clear_quality(); + uint32_t quality() const; + void set_quality(uint32_t value); + private: + uint32_t _internal_quality() const; + void _internal_set_quality(uint32_t value); + public: + + // uint32 maxQuality = 6; + void clear_maxquality(); + uint32_t maxquality() const; + void set_maxquality(uint32_t value); + private: + uint32_t _internal_maxquality() const; + void _internal_set_maxquality(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.GenericItemFull.GenericItem) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + uint32_t id_; + uint32_t properties_; + uint32_t quantity_; + uint32_t quality_; + uint32_t maxquality_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class GenericItemFull final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.GenericItemFull) */ { + public: + inline GenericItemFull() : GenericItemFull(nullptr) {} + ~GenericItemFull() override; + explicit constexpr GenericItemFull(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + GenericItemFull(const GenericItemFull& from); + GenericItemFull(GenericItemFull&& from) noexcept + : GenericItemFull() { + *this = ::std::move(from); + } + + inline GenericItemFull& operator=(const GenericItemFull& from) { + CopyFrom(from); + return *this; + } + inline GenericItemFull& operator=(GenericItemFull&& 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 GenericItemFull& default_instance() { + return *internal_default_instance(); + } + static inline const GenericItemFull* internal_default_instance() { + return reinterpret_cast( + &_GenericItemFull_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(GenericItemFull& a, GenericItemFull& b) { + a.Swap(&b); + } + inline void Swap(GenericItemFull* 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(GenericItemFull* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GenericItemFull* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const GenericItemFull& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const GenericItemFull& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(GenericItemFull* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.GenericItemFull"; + } + protected: + explicit GenericItemFull(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef GenericItemFull_GenericItem GenericItem; + + typedef GenericItemFull_HandId HandId; + static constexpr HandId HandId_UNKNOWN = + GenericItemFull_HandId_HandId_UNKNOWN; + static constexpr HandId LEFT_HAND = + GenericItemFull_HandId_LEFT_HAND; + static constexpr HandId RIGHT_HAND = + GenericItemFull_HandId_RIGHT_HAND; + static constexpr HandId HAND_PLAYERHANDS = + GenericItemFull_HandId_HAND_PLAYERHANDS; + static constexpr HandId ANY_HAND = + GenericItemFull_HandId_ANY_HAND; + static constexpr HandId BOTH_HANDS = + GenericItemFull_HandId_BOTH_HANDS; + static inline bool HandId_IsValid(int value) { + return GenericItemFull_HandId_IsValid(value); + } + static constexpr HandId HandId_MIN = + GenericItemFull_HandId_HandId_MIN; + static constexpr HandId HandId_MAX = + GenericItemFull_HandId_HandId_MAX; + static constexpr int HandId_ARRAYSIZE = + GenericItemFull_HandId_HandId_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + HandId_descriptor() { + return GenericItemFull_HandId_descriptor(); + } + template + static inline const std::string& HandId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HandId_Name."); + return GenericItemFull_HandId_Name(enum_t_value); + } + static inline bool HandId_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + HandId* value) { + return GenericItemFull_HandId_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kContainerItemsFieldNumber = 4, + kGenericItemFieldNumber = 1, + kLocationFieldNumber = 2, + kHandFieldNumber = 3, + }; + // repeated .MSRProto.GenericItemFull containerItems = 4; + int containeritems_size() const; + private: + int _internal_containeritems_size() const; + public: + void clear_containeritems(); + ::MSRProto::GenericItemFull* mutable_containeritems(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >* + mutable_containeritems(); + private: + const ::MSRProto::GenericItemFull& _internal_containeritems(int index) const; + ::MSRProto::GenericItemFull* _internal_add_containeritems(); + public: + const ::MSRProto::GenericItemFull& containeritems(int index) const; + ::MSRProto::GenericItemFull* add_containeritems(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >& + containeritems() const; + + // .MSRProto.GenericItemFull.GenericItem genericItem = 1; + bool has_genericitem() const; + private: + bool _internal_has_genericitem() const; + public: + void clear_genericitem(); + const ::MSRProto::GenericItemFull_GenericItem& genericitem() const; + PROTOBUF_NODISCARD ::MSRProto::GenericItemFull_GenericItem* release_genericitem(); + ::MSRProto::GenericItemFull_GenericItem* mutable_genericitem(); + void set_allocated_genericitem(::MSRProto::GenericItemFull_GenericItem* genericitem); + private: + const ::MSRProto::GenericItemFull_GenericItem& _internal_genericitem() const; + ::MSRProto::GenericItemFull_GenericItem* _internal_mutable_genericitem(); + public: + void unsafe_arena_set_allocated_genericitem( + ::MSRProto::GenericItemFull_GenericItem* genericitem); + ::MSRProto::GenericItemFull_GenericItem* unsafe_arena_release_genericitem(); + + // uint32 Location = 2; + void clear_location(); + uint32_t location() const; + void set_location(uint32_t value); + private: + uint32_t _internal_location() const; + void _internal_set_location(uint32_t value); + public: + + // .MSRProto.GenericItemFull.HandId Hand = 3; + void clear_hand(); + ::MSRProto::GenericItemFull_HandId hand() const; + void set_hand(::MSRProto::GenericItemFull_HandId value); + private: + ::MSRProto::GenericItemFull_HandId _internal_hand() const; + void _internal_set_hand(::MSRProto::GenericItemFull_HandId value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.GenericItemFull) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull > containeritems_; + ::MSRProto::GenericItemFull_GenericItem* genericitem_; + uint32_t location_; + int hand_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class Storage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.Storage) */ { + public: + inline Storage() : Storage(nullptr) {} + ~Storage() override; + explicit constexpr Storage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Storage(const Storage& from); + Storage(Storage&& from) noexcept + : Storage() { + *this = ::std::move(from); + } + + inline Storage& operator=(const Storage& from) { + CopyFrom(from); + return *this; + } + inline Storage& operator=(Storage&& 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 Storage& default_instance() { + return *internal_default_instance(); + } + static inline const Storage* internal_default_instance() { + return reinterpret_cast( + &_Storage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Storage& a, Storage& b) { + a.Swap(&b); + } + inline void Swap(Storage* 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(Storage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Storage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Storage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const Storage& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Storage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.Storage"; + } + protected: + explicit Storage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kItemsFieldNumber = 2, + kNameFieldNumber = 1, + }; + // repeated .MSRProto.GenericItemFull items = 2; + int items_size() const; + private: + int _internal_items_size() const; + public: + void clear_items(); + ::MSRProto::GenericItemFull* mutable_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >* + mutable_items(); + private: + const ::MSRProto::GenericItemFull& _internal_items(int index) const; + ::MSRProto::GenericItemFull* _internal_add_items(); + public: + const ::MSRProto::GenericItemFull& items(int index) const; + ::MSRProto::GenericItemFull* add_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >& + items() const; + + // string name = 1; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.Storage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull > items_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class CharData_SaveData_Vector3 final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.CharData.SaveData.Vector3) */ { + public: + inline CharData_SaveData_Vector3() : CharData_SaveData_Vector3(nullptr) {} + ~CharData_SaveData_Vector3() override; + explicit constexpr CharData_SaveData_Vector3(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CharData_SaveData_Vector3(const CharData_SaveData_Vector3& from); + CharData_SaveData_Vector3(CharData_SaveData_Vector3&& from) noexcept + : CharData_SaveData_Vector3() { + *this = ::std::move(from); + } + + inline CharData_SaveData_Vector3& operator=(const CharData_SaveData_Vector3& from) { + CopyFrom(from); + return *this; + } + inline CharData_SaveData_Vector3& operator=(CharData_SaveData_Vector3&& 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 CharData_SaveData_Vector3& default_instance() { + return *internal_default_instance(); + } + static inline const CharData_SaveData_Vector3* internal_default_instance() { + return reinterpret_cast( + &_CharData_SaveData_Vector3_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(CharData_SaveData_Vector3& a, CharData_SaveData_Vector3& b) { + a.Swap(&b); + } + inline void Swap(CharData_SaveData_Vector3* 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(CharData_SaveData_Vector3* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CharData_SaveData_Vector3* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CharData_SaveData_Vector3& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const CharData_SaveData_Vector3& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CharData_SaveData_Vector3* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.CharData.SaveData.Vector3"; + } + protected: + explicit CharData_SaveData_Vector3(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + kZFieldNumber = 3, + }; + // double x = 1; + void clear_x(); + double x() const; + void set_x(double value); + private: + double _internal_x() const; + void _internal_set_x(double value); + public: + + // double y = 2; + void clear_y(); + double y() const; + void set_y(double value); + private: + double _internal_y() const; + void _internal_set_y(double value); + public: + + // double z = 3; + void clear_z(); + double z() const; + void set_z(double value); + private: + double _internal_z() const; + void _internal_set_z(double value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.CharData.SaveData.Vector3) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + double x_; + double y_; + double z_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class CharData_SaveData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.CharData.SaveData) */ { + public: + inline CharData_SaveData() : CharData_SaveData(nullptr) {} + ~CharData_SaveData() override; + explicit constexpr CharData_SaveData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CharData_SaveData(const CharData_SaveData& from); + CharData_SaveData(CharData_SaveData&& from) noexcept + : CharData_SaveData() { + *this = ::std::move(from); + } + + inline CharData_SaveData& operator=(const CharData_SaveData& from) { + CopyFrom(from); + return *this; + } + inline CharData_SaveData& operator=(CharData_SaveData&& 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 CharData_SaveData& default_instance() { + return *internal_default_instance(); + } + static inline const CharData_SaveData* internal_default_instance() { + return reinterpret_cast( + &_CharData_SaveData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(CharData_SaveData& a, CharData_SaveData& b) { + a.Swap(&b); + } + inline void Swap(CharData_SaveData* 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(CharData_SaveData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CharData_SaveData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CharData_SaveData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const CharData_SaveData& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CharData_SaveData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.CharData.SaveData"; + } + protected: + explicit CharData_SaveData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef CharData_SaveData_Vector3 Vector3; + + typedef CharData_SaveData_GenderId GenderId; + static constexpr GenderId GenderId_UNKNOWN = + CharData_SaveData_GenderId_GenderId_UNKNOWN; + static constexpr GenderId Male = + CharData_SaveData_GenderId_Male; + static constexpr GenderId Female = + CharData_SaveData_GenderId_Female; + static inline bool GenderId_IsValid(int value) { + return CharData_SaveData_GenderId_IsValid(value); + } + static constexpr GenderId GenderId_MIN = + CharData_SaveData_GenderId_GenderId_MIN; + static constexpr GenderId GenderId_MAX = + CharData_SaveData_GenderId_GenderId_MAX; + static constexpr int GenderId_ARRAYSIZE = + CharData_SaveData_GenderId_GenderId_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + GenderId_descriptor() { + return CharData_SaveData_GenderId_descriptor(); + } + template + static inline const std::string& GenderId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function GenderId_Name."); + return CharData_SaveData_GenderId_Name(enum_t_value); + } + static inline bool GenderId_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + GenderId* value) { + return CharData_SaveData_GenderId_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 2, + kSteamIdFieldNumber = 3, + kRaceFieldNumber = 4, + kMapNameFieldNumber = 6, + kNextMapFieldNumber = 7, + kOldTransitionFieldNumber = 8, + kNewTransitionFieldNumber = 9, + kPartyNameFieldNumber = 18, + kOriginFieldNumber = 10, + kAnglesFieldNumber = 11, + kVersionFieldNumber = 1, + kGenderFieldNumber = 5, + kIsEliteFieldNumber = 12, + kGoldFieldNumber = 13, + kMaxHPFieldNumber = 14, + kMaxMPFieldNumber = 15, + kCurrentHPFieldNumber = 16, + kCurrentMPFieldNumber = 17, + kPartyIdFieldNumber = 19, + kPlayerKillsFieldNumber = 20, + kTimeWaitedToForgetKillFieldNumber = 21, + kTimeWaitedToForgetStealFieldNumber = 22, + }; + // string name = 2; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // string steamId = 3; + void clear_steamid(); + const std::string& steamid() const; + template + void set_steamid(ArgT0&& arg0, ArgT... args); + std::string* mutable_steamid(); + PROTOBUF_NODISCARD std::string* release_steamid(); + void set_allocated_steamid(std::string* steamid); + private: + const std::string& _internal_steamid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_steamid(const std::string& value); + std::string* _internal_mutable_steamid(); + public: + + // string race = 4; + void clear_race(); + const std::string& race() const; + template + void set_race(ArgT0&& arg0, ArgT... args); + std::string* mutable_race(); + PROTOBUF_NODISCARD std::string* release_race(); + void set_allocated_race(std::string* race); + private: + const std::string& _internal_race() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_race(const std::string& value); + std::string* _internal_mutable_race(); + public: + + // string mapName = 6; + void clear_mapname(); + const std::string& mapname() const; + template + void set_mapname(ArgT0&& arg0, ArgT... args); + std::string* mutable_mapname(); + PROTOBUF_NODISCARD std::string* release_mapname(); + void set_allocated_mapname(std::string* mapname); + private: + const std::string& _internal_mapname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mapname(const std::string& value); + std::string* _internal_mutable_mapname(); + public: + + // string nextMap = 7; + void clear_nextmap(); + const std::string& nextmap() const; + template + void set_nextmap(ArgT0&& arg0, ArgT... args); + std::string* mutable_nextmap(); + PROTOBUF_NODISCARD std::string* release_nextmap(); + void set_allocated_nextmap(std::string* nextmap); + private: + const std::string& _internal_nextmap() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_nextmap(const std::string& value); + std::string* _internal_mutable_nextmap(); + public: + + // string oldTransition = 8; + void clear_oldtransition(); + const std::string& oldtransition() const; + template + void set_oldtransition(ArgT0&& arg0, ArgT... args); + std::string* mutable_oldtransition(); + PROTOBUF_NODISCARD std::string* release_oldtransition(); + void set_allocated_oldtransition(std::string* oldtransition); + private: + const std::string& _internal_oldtransition() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldtransition(const std::string& value); + std::string* _internal_mutable_oldtransition(); + public: + + // string newTransition = 9; + void clear_newtransition(); + const std::string& newtransition() const; + template + void set_newtransition(ArgT0&& arg0, ArgT... args); + std::string* mutable_newtransition(); + PROTOBUF_NODISCARD std::string* release_newtransition(); + void set_allocated_newtransition(std::string* newtransition); + private: + const std::string& _internal_newtransition() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_newtransition(const std::string& value); + std::string* _internal_mutable_newtransition(); + public: + + // string partyName = 18; + void clear_partyname(); + const std::string& partyname() const; + template + void set_partyname(ArgT0&& arg0, ArgT... args); + std::string* mutable_partyname(); + PROTOBUF_NODISCARD std::string* release_partyname(); + void set_allocated_partyname(std::string* partyname); + private: + const std::string& _internal_partyname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_partyname(const std::string& value); + std::string* _internal_mutable_partyname(); + public: + + // .MSRProto.CharData.SaveData.Vector3 origin = 10; + bool has_origin() const; + private: + bool _internal_has_origin() const; + public: + void clear_origin(); + const ::MSRProto::CharData_SaveData_Vector3& origin() const; + PROTOBUF_NODISCARD ::MSRProto::CharData_SaveData_Vector3* release_origin(); + ::MSRProto::CharData_SaveData_Vector3* mutable_origin(); + void set_allocated_origin(::MSRProto::CharData_SaveData_Vector3* origin); + private: + const ::MSRProto::CharData_SaveData_Vector3& _internal_origin() const; + ::MSRProto::CharData_SaveData_Vector3* _internal_mutable_origin(); + public: + void unsafe_arena_set_allocated_origin( + ::MSRProto::CharData_SaveData_Vector3* origin); + ::MSRProto::CharData_SaveData_Vector3* unsafe_arena_release_origin(); + + // .MSRProto.CharData.SaveData.Vector3 angles = 11; + bool has_angles() const; + private: + bool _internal_has_angles() const; + public: + void clear_angles(); + const ::MSRProto::CharData_SaveData_Vector3& angles() const; + PROTOBUF_NODISCARD ::MSRProto::CharData_SaveData_Vector3* release_angles(); + ::MSRProto::CharData_SaveData_Vector3* mutable_angles(); + void set_allocated_angles(::MSRProto::CharData_SaveData_Vector3* angles); + private: + const ::MSRProto::CharData_SaveData_Vector3& _internal_angles() const; + ::MSRProto::CharData_SaveData_Vector3* _internal_mutable_angles(); + public: + void unsafe_arena_set_allocated_angles( + ::MSRProto::CharData_SaveData_Vector3* angles); + ::MSRProto::CharData_SaveData_Vector3* unsafe_arena_release_angles(); + + // int32 version = 1; + void clear_version(); + int32_t version() const; + void set_version(int32_t value); + private: + int32_t _internal_version() const; + void _internal_set_version(int32_t value); + public: + + // .MSRProto.CharData.SaveData.GenderId gender = 5; + void clear_gender(); + ::MSRProto::CharData_SaveData_GenderId gender() const; + void set_gender(::MSRProto::CharData_SaveData_GenderId value); + private: + ::MSRProto::CharData_SaveData_GenderId _internal_gender() const; + void _internal_set_gender(::MSRProto::CharData_SaveData_GenderId value); + public: + + // bool isElite = 12; + void clear_iselite(); + bool iselite() const; + void set_iselite(bool value); + private: + bool _internal_iselite() const; + void _internal_set_iselite(bool value); + public: + + // uint32 gold = 13; + void clear_gold(); + uint32_t gold() const; + void set_gold(uint32_t value); + private: + uint32_t _internal_gold() const; + void _internal_set_gold(uint32_t value); + public: + + // uint32 maxHP = 14; + void clear_maxhp(); + uint32_t maxhp() const; + void set_maxhp(uint32_t value); + private: + uint32_t _internal_maxhp() const; + void _internal_set_maxhp(uint32_t value); + public: + + // uint32 maxMP = 15; + void clear_maxmp(); + uint32_t maxmp() const; + void set_maxmp(uint32_t value); + private: + uint32_t _internal_maxmp() const; + void _internal_set_maxmp(uint32_t value); + public: + + // uint32 currentHP = 16; + void clear_currenthp(); + uint32_t currenthp() const; + void set_currenthp(uint32_t value); + private: + uint32_t _internal_currenthp() const; + void _internal_set_currenthp(uint32_t value); + public: + + // uint32 currentMP = 17; + void clear_currentmp(); + uint32_t currentmp() const; + void set_currentmp(uint32_t value); + private: + uint32_t _internal_currentmp() const; + void _internal_set_currentmp(uint32_t value); + public: + + // uint32 partyId = 19; + void clear_partyid(); + uint32_t partyid() const; + void set_partyid(uint32_t value); + private: + uint32_t _internal_partyid() const; + void _internal_set_partyid(uint32_t value); + public: + + // uint32 playerKills = 20; + void clear_playerkills(); + uint32_t playerkills() const; + void set_playerkills(uint32_t value); + private: + uint32_t _internal_playerkills() const; + void _internal_set_playerkills(uint32_t value); + public: + + // double timeWaitedToForgetKill = 21; + void clear_timewaitedtoforgetkill(); + double timewaitedtoforgetkill() const; + void set_timewaitedtoforgetkill(double value); + private: + double _internal_timewaitedtoforgetkill() const; + void _internal_set_timewaitedtoforgetkill(double value); + public: + + // double timeWaitedToForgetSteal = 22; + void clear_timewaitedtoforgetsteal(); + double timewaitedtoforgetsteal() const; + void set_timewaitedtoforgetsteal(double value); + private: + double _internal_timewaitedtoforgetsteal() const; + void _internal_set_timewaitedtoforgetsteal(double value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.CharData.SaveData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr steamid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr race_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mapname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nextmap_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldtransition_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newtransition_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partyname_; + ::MSRProto::CharData_SaveData_Vector3* origin_; + ::MSRProto::CharData_SaveData_Vector3* angles_; + int32_t version_; + int gender_; + bool iselite_; + uint32_t gold_; + uint32_t maxhp_; + uint32_t maxmp_; + uint32_t currenthp_; + uint32_t currentmp_; + uint32_t partyid_; + uint32_t playerkills_; + double timewaitedtoforgetkill_; + double timewaitedtoforgetsteal_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse(); + explicit constexpr CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse& other); + static const CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "MSRProto.CharData.Companion.ScriptedSaveVariablesEntry.key"); + } + static bool ValidateValue(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "MSRProto.CharData.Companion.ScriptedSaveVariablesEntry.value"); + } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; +}; + +// ------------------------------------------------------------------- + +class CharData_Companion final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.CharData.Companion) */ { + public: + inline CharData_Companion() : CharData_Companion(nullptr) {} + ~CharData_Companion() override; + explicit constexpr CharData_Companion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CharData_Companion(const CharData_Companion& from); + CharData_Companion(CharData_Companion&& from) noexcept + : CharData_Companion() { + *this = ::std::move(from); + } + + inline CharData_Companion& operator=(const CharData_Companion& from) { + CopyFrom(from); + return *this; + } + inline CharData_Companion& operator=(CharData_Companion&& 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 CharData_Companion& default_instance() { + return *internal_default_instance(); + } + static inline const CharData_Companion* internal_default_instance() { + return reinterpret_cast( + &_CharData_Companion_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(CharData_Companion& a, CharData_Companion& b) { + a.Swap(&b); + } + inline void Swap(CharData_Companion* 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(CharData_Companion* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CharData_Companion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CharData_Companion& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const CharData_Companion& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CharData_Companion* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.CharData.Companion"; + } + protected: + explicit CharData_Companion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + + // accessors ------------------------------------------------------- + + enum : int { + kScriptedSaveVariablesFieldNumber = 2, + kScriptNameFieldNumber = 1, + }; + // map scriptedSaveVariables = 2; + int scriptedsavevariables_size() const; + private: + int _internal_scriptedsavevariables_size() const; + public: + void clear_scriptedsavevariables(); + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& + _internal_scriptedsavevariables() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* + _internal_mutable_scriptedsavevariables(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& + scriptedsavevariables() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* + mutable_scriptedsavevariables(); + + // string scriptName = 1; + void clear_scriptname(); + const std::string& scriptname() const; + template + void set_scriptname(ArgT0&& arg0, ArgT... args); + std::string* mutable_scriptname(); + PROTOBUF_NODISCARD std::string* release_scriptname(); + void set_allocated_scriptname(std::string* scriptname); + private: + const std::string& _internal_scriptname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_scriptname(const std::string& value); + std::string* _internal_mutable_scriptname(); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.CharData.Companion) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + CharData_Companion_ScriptedSaveVariablesEntry_DoNotUse, + std::string, std::string, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> scriptedsavevariables_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scriptname_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class CharData_QuestsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { +public: + typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; + CharData_QuestsEntry_DoNotUse(); + explicit constexpr CharData_QuestsEntry_DoNotUse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + explicit CharData_QuestsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + void MergeFrom(const CharData_QuestsEntry_DoNotUse& other); + static const CharData_QuestsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_CharData_QuestsEntry_DoNotUse_default_instance_); } + static bool ValidateKey(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "MSRProto.CharData.QuestsEntry.key"); + } + static bool ValidateValue(std::string* s) { + return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "MSRProto.CharData.QuestsEntry.value"); + } + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; +}; + +// ------------------------------------------------------------------- + +class CharData_QuickSlot final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.CharData.QuickSlot) */ { + public: + inline CharData_QuickSlot() : CharData_QuickSlot(nullptr) {} + ~CharData_QuickSlot() override; + explicit constexpr CharData_QuickSlot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CharData_QuickSlot(const CharData_QuickSlot& from); + CharData_QuickSlot(CharData_QuickSlot&& from) noexcept + : CharData_QuickSlot() { + *this = ::std::move(from); + } + + inline CharData_QuickSlot& operator=(const CharData_QuickSlot& from) { + CopyFrom(from); + return *this; + } + inline CharData_QuickSlot& operator=(CharData_QuickSlot&& 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 CharData_QuickSlot& default_instance() { + return *internal_default_instance(); + } + static inline const CharData_QuickSlot* internal_default_instance() { + return reinterpret_cast( + &_CharData_QuickSlot_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(CharData_QuickSlot& a, CharData_QuickSlot& b) { + a.Swap(&b); + } + inline void Swap(CharData_QuickSlot* 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(CharData_QuickSlot* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CharData_QuickSlot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CharData_QuickSlot& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const CharData_QuickSlot& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CharData_QuickSlot* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.CharData.QuickSlot"; + } + protected: + explicit CharData_QuickSlot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef CharData_QuickSlot_QuickSlotTypeId QuickSlotTypeId; + static constexpr QuickSlotTypeId QuickSlotTypeId_UNKNOWN = + CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_UNKNOWN; + static constexpr QuickSlotTypeId QS_EMPTY = + CharData_QuickSlot_QuickSlotTypeId_QS_EMPTY; + static constexpr QuickSlotTypeId QS_ITEM = + CharData_QuickSlot_QuickSlotTypeId_QS_ITEM; + static constexpr QuickSlotTypeId QS_SPELL = + CharData_QuickSlot_QuickSlotTypeId_QS_SPELL; + static constexpr QuickSlotTypeId QS_ARROW = + CharData_QuickSlot_QuickSlotTypeId_QS_ARROW; + static inline bool QuickSlotTypeId_IsValid(int value) { + return CharData_QuickSlot_QuickSlotTypeId_IsValid(value); + } + static constexpr QuickSlotTypeId QuickSlotTypeId_MIN = + CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_MIN; + static constexpr QuickSlotTypeId QuickSlotTypeId_MAX = + CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_MAX; + static constexpr int QuickSlotTypeId_ARRAYSIZE = + CharData_QuickSlot_QuickSlotTypeId_QuickSlotTypeId_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + QuickSlotTypeId_descriptor() { + return CharData_QuickSlot_QuickSlotTypeId_descriptor(); + } + template + static inline const std::string& QuickSlotTypeId_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function QuickSlotTypeId_Name."); + return CharData_QuickSlot_QuickSlotTypeId_Name(enum_t_value); + } + static inline bool QuickSlotTypeId_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + QuickSlotTypeId* value) { + return CharData_QuickSlot_QuickSlotTypeId_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + kIdFieldNumber = 2, + }; + // .MSRProto.CharData.QuickSlot.QuickSlotTypeId type = 1; + void clear_type(); + ::MSRProto::CharData_QuickSlot_QuickSlotTypeId type() const; + void set_type(::MSRProto::CharData_QuickSlot_QuickSlotTypeId value); + private: + ::MSRProto::CharData_QuickSlot_QuickSlotTypeId _internal_type() const; + void _internal_set_type(::MSRProto::CharData_QuickSlot_QuickSlotTypeId value); + public: + + // uint32 id = 2; + void clear_id(); + uint32_t id() const; + void set_id(uint32_t value); + private: + uint32_t _internal_id() const; + void _internal_set_id(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:MSRProto.CharData.QuickSlot) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + int type_; + uint32_t id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// ------------------------------------------------------------------- + +class CharData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MSRProto.CharData) */ { + public: + inline CharData() : CharData(nullptr) {} + ~CharData() override; + explicit constexpr CharData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CharData(const CharData& from); + CharData(CharData&& from) noexcept + : CharData() { + *this = ::std::move(from); + } + + inline CharData& operator=(const CharData& from) { + CopyFrom(from); + return *this; + } + inline CharData& operator=(CharData&& 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 CharData& default_instance() { + return *internal_default_instance(); + } + static inline const CharData* internal_default_instance() { + return reinterpret_cast( + &_CharData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(CharData& a, CharData& b) { + a.Swap(&b); + } + inline void Swap(CharData* 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(CharData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CharData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CharData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom(const CharData& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CharData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "MSRProto.CharData"; + } + protected: + explicit CharData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef CharData_SaveData SaveData; + typedef CharData_Companion Companion; + typedef CharData_QuickSlot QuickSlot; + + // accessors ------------------------------------------------------- + + enum : int { + kVisitedMapsFieldNumber = 2, + kStatListFieldNumber = 3, + kKnownSpellsFieldNumber = 4, + kItemsFieldNumber = 5, + kStoragesFieldNumber = 6, + kCompanionsFieldNumber = 7, + kViewedHelpTipsFieldNumber = 8, + kQuestsFieldNumber = 9, + kQuickslotsFieldNumber = 10, + kSaveDataFieldNumber = 1, + }; + // repeated string visitedMaps = 2; + int visitedmaps_size() const; + private: + int _internal_visitedmaps_size() const; + public: + void clear_visitedmaps(); + const std::string& visitedmaps(int index) const; + std::string* mutable_visitedmaps(int index); + void set_visitedmaps(int index, const std::string& value); + void set_visitedmaps(int index, std::string&& value); + void set_visitedmaps(int index, const char* value); + void set_visitedmaps(int index, const char* value, size_t size); + std::string* add_visitedmaps(); + void add_visitedmaps(const std::string& value); + void add_visitedmaps(std::string&& value); + void add_visitedmaps(const char* value); + void add_visitedmaps(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& visitedmaps() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_visitedmaps(); + private: + const std::string& _internal_visitedmaps(int index) const; + std::string* _internal_add_visitedmaps(); + public: + + // repeated .MSRProto.Stat statList = 3; + int statlist_size() const; + private: + int _internal_statlist_size() const; + public: + void clear_statlist(); + ::MSRProto::Stat* mutable_statlist(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat >* + mutable_statlist(); + private: + const ::MSRProto::Stat& _internal_statlist(int index) const; + ::MSRProto::Stat* _internal_add_statlist(); + public: + const ::MSRProto::Stat& statlist(int index) const; + ::MSRProto::Stat* add_statlist(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat >& + statlist() const; + + // repeated string knownSpells = 4; + int knownspells_size() const; + private: + int _internal_knownspells_size() const; + public: + void clear_knownspells(); + const std::string& knownspells(int index) const; + std::string* mutable_knownspells(int index); + void set_knownspells(int index, const std::string& value); + void set_knownspells(int index, std::string&& value); + void set_knownspells(int index, const char* value); + void set_knownspells(int index, const char* value, size_t size); + std::string* add_knownspells(); + void add_knownspells(const std::string& value); + void add_knownspells(std::string&& value); + void add_knownspells(const char* value); + void add_knownspells(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& knownspells() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_knownspells(); + private: + const std::string& _internal_knownspells(int index) const; + std::string* _internal_add_knownspells(); + public: + + // repeated .MSRProto.GenericItemFull items = 5; + int items_size() const; + private: + int _internal_items_size() const; + public: + void clear_items(); + ::MSRProto::GenericItemFull* mutable_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >* + mutable_items(); + private: + const ::MSRProto::GenericItemFull& _internal_items(int index) const; + ::MSRProto::GenericItemFull* _internal_add_items(); + public: + const ::MSRProto::GenericItemFull& items(int index) const; + ::MSRProto::GenericItemFull* add_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >& + items() const; + + // repeated .MSRProto.Storage storages = 6; + int storages_size() const; + private: + int _internal_storages_size() const; + public: + void clear_storages(); + ::MSRProto::Storage* mutable_storages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Storage >* + mutable_storages(); + private: + const ::MSRProto::Storage& _internal_storages(int index) const; + ::MSRProto::Storage* _internal_add_storages(); + public: + const ::MSRProto::Storage& storages(int index) const; + ::MSRProto::Storage* add_storages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Storage >& + storages() const; + + // repeated .MSRProto.CharData.Companion companions = 7; + int companions_size() const; + private: + int _internal_companions_size() const; + public: + void clear_companions(); + ::MSRProto::CharData_Companion* mutable_companions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_Companion >* + mutable_companions(); + private: + const ::MSRProto::CharData_Companion& _internal_companions(int index) const; + ::MSRProto::CharData_Companion* _internal_add_companions(); + public: + const ::MSRProto::CharData_Companion& companions(int index) const; + ::MSRProto::CharData_Companion* add_companions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_Companion >& + companions() const; + + // repeated string viewedHelpTips = 8; + int viewedhelptips_size() const; + private: + int _internal_viewedhelptips_size() const; + public: + void clear_viewedhelptips(); + const std::string& viewedhelptips(int index) const; + std::string* mutable_viewedhelptips(int index); + void set_viewedhelptips(int index, const std::string& value); + void set_viewedhelptips(int index, std::string&& value); + void set_viewedhelptips(int index, const char* value); + void set_viewedhelptips(int index, const char* value, size_t size); + std::string* add_viewedhelptips(); + void add_viewedhelptips(const std::string& value); + void add_viewedhelptips(std::string&& value); + void add_viewedhelptips(const char* value); + void add_viewedhelptips(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& viewedhelptips() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_viewedhelptips(); + private: + const std::string& _internal_viewedhelptips(int index) const; + std::string* _internal_add_viewedhelptips(); + public: + + // map quests = 9; + int quests_size() const; + private: + int _internal_quests_size() const; + public: + void clear_quests(); + private: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& + _internal_quests() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* + _internal_mutable_quests(); + public: + const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& + quests() const; + ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* + mutable_quests(); + + // repeated .MSRProto.CharData.QuickSlot quickslots = 10; + int quickslots_size() const; + private: + int _internal_quickslots_size() const; + public: + void clear_quickslots(); + ::MSRProto::CharData_QuickSlot* mutable_quickslots(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_QuickSlot >* + mutable_quickslots(); + private: + const ::MSRProto::CharData_QuickSlot& _internal_quickslots(int index) const; + ::MSRProto::CharData_QuickSlot* _internal_add_quickslots(); + public: + const ::MSRProto::CharData_QuickSlot& quickslots(int index) const; + ::MSRProto::CharData_QuickSlot* add_quickslots(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_QuickSlot >& + quickslots() const; + + // .MSRProto.CharData.SaveData saveData = 1; + bool has_savedata() const; + private: + bool _internal_has_savedata() const; + public: + void clear_savedata(); + const ::MSRProto::CharData_SaveData& savedata() const; + PROTOBUF_NODISCARD ::MSRProto::CharData_SaveData* release_savedata(); + ::MSRProto::CharData_SaveData* mutable_savedata(); + void set_allocated_savedata(::MSRProto::CharData_SaveData* savedata); + private: + const ::MSRProto::CharData_SaveData& _internal_savedata() const; + ::MSRProto::CharData_SaveData* _internal_mutable_savedata(); + public: + void unsafe_arena_set_allocated_savedata( + ::MSRProto::CharData_SaveData* savedata); + ::MSRProto::CharData_SaveData* unsafe_arena_release_savedata(); + + // @@protoc_insertion_point(class_scope:MSRProto.CharData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField visitedmaps_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat > statlist_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField knownspells_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull > items_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Storage > storages_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_Companion > companions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField viewedhelptips_; + ::PROTOBUF_NAMESPACE_ID::internal::MapField< + CharData_QuestsEntry_DoNotUse, + std::string, std::string, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> quests_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_QuickSlot > quickslots_; + ::MSRProto::CharData_SaveData* savedata_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_savedata_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Stat_SubStat + +// .MSRProto.Stat.SubStat.SubStatId substatId = 1; +inline void Stat_SubStat::clear_substatid() { + substatid_ = 0; +} +inline ::MSRProto::Stat_SubStat_SubStatId Stat_SubStat::_internal_substatid() const { + return static_cast< ::MSRProto::Stat_SubStat_SubStatId >(substatid_); +} +inline ::MSRProto::Stat_SubStat_SubStatId Stat_SubStat::substatid() const { + // @@protoc_insertion_point(field_get:MSRProto.Stat.SubStat.substatId) + return _internal_substatid(); +} +inline void Stat_SubStat::_internal_set_substatid(::MSRProto::Stat_SubStat_SubStatId value) { + + substatid_ = value; +} +inline void Stat_SubStat::set_substatid(::MSRProto::Stat_SubStat_SubStatId value) { + _internal_set_substatid(value); + // @@protoc_insertion_point(field_set:MSRProto.Stat.SubStat.substatId) +} + +// uint32 value = 2; +inline void Stat_SubStat::clear_value() { + value_ = 0u; +} +inline uint32_t Stat_SubStat::_internal_value() const { + return value_; +} +inline uint32_t Stat_SubStat::value() const { + // @@protoc_insertion_point(field_get:MSRProto.Stat.SubStat.value) + return _internal_value(); +} +inline void Stat_SubStat::_internal_set_value(uint32_t value) { + + value_ = value; +} +inline void Stat_SubStat::set_value(uint32_t value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:MSRProto.Stat.SubStat.value) +} + +// uint32 exp = 3; +inline void Stat_SubStat::clear_exp() { + exp_ = 0u; +} +inline uint32_t Stat_SubStat::_internal_exp() const { + return exp_; +} +inline uint32_t Stat_SubStat::exp() const { + // @@protoc_insertion_point(field_get:MSRProto.Stat.SubStat.exp) + return _internal_exp(); +} +inline void Stat_SubStat::_internal_set_exp(uint32_t value) { + + exp_ = value; +} +inline void Stat_SubStat::set_exp(uint32_t value) { + _internal_set_exp(value); + // @@protoc_insertion_point(field_set:MSRProto.Stat.SubStat.exp) +} + +// ------------------------------------------------------------------- + +// Stat + +// .MSRProto.Stat.StatId statId = 1; +inline void Stat::clear_statid() { + statid_ = 0; +} +inline ::MSRProto::Stat_StatId Stat::_internal_statid() const { + return static_cast< ::MSRProto::Stat_StatId >(statid_); +} +inline ::MSRProto::Stat_StatId Stat::statid() const { + // @@protoc_insertion_point(field_get:MSRProto.Stat.statId) + return _internal_statid(); +} +inline void Stat::_internal_set_statid(::MSRProto::Stat_StatId value) { + + statid_ = value; +} +inline void Stat::set_statid(::MSRProto::Stat_StatId value) { + _internal_set_statid(value); + // @@protoc_insertion_point(field_set:MSRProto.Stat.statId) +} + +// repeated .MSRProto.Stat.SubStat subStats = 2; +inline int Stat::_internal_substats_size() const { + return substats_.size(); +} +inline int Stat::substats_size() const { + return _internal_substats_size(); +} +inline void Stat::clear_substats() { + substats_.Clear(); +} +inline ::MSRProto::Stat_SubStat* Stat::mutable_substats(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.Stat.subStats) + return substats_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat_SubStat >* +Stat::mutable_substats() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.Stat.subStats) + return &substats_; +} +inline const ::MSRProto::Stat_SubStat& Stat::_internal_substats(int index) const { + return substats_.Get(index); +} +inline const ::MSRProto::Stat_SubStat& Stat::substats(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.Stat.subStats) + return _internal_substats(index); +} +inline ::MSRProto::Stat_SubStat* Stat::_internal_add_substats() { + return substats_.Add(); +} +inline ::MSRProto::Stat_SubStat* Stat::add_substats() { + ::MSRProto::Stat_SubStat* _add = _internal_add_substats(); + // @@protoc_insertion_point(field_add:MSRProto.Stat.subStats) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat_SubStat >& +Stat::substats() const { + // @@protoc_insertion_point(field_list:MSRProto.Stat.subStats) + return substats_; +} + +// ------------------------------------------------------------------- + +// GenericItemFull_GenericItem + +// uint32 id = 1; +inline void GenericItemFull_GenericItem::clear_id() { + id_ = 0u; +} +inline uint32_t GenericItemFull_GenericItem::_internal_id() const { + return id_; +} +inline uint32_t GenericItemFull_GenericItem::id() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.GenericItem.id) + return _internal_id(); +} +inline void GenericItemFull_GenericItem::_internal_set_id(uint32_t value) { + + id_ = value; +} +inline void GenericItemFull_GenericItem::set_id(uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.GenericItem.id) +} + +// string name = 2; +inline void GenericItemFull_GenericItem::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& GenericItemFull_GenericItem::name() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.GenericItem.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void GenericItemFull_GenericItem::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.GenericItem.name) +} +inline std::string* GenericItemFull_GenericItem::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:MSRProto.GenericItemFull.GenericItem.name) + return _s; +} +inline const std::string& GenericItemFull_GenericItem::_internal_name() const { + return name_.Get(); +} +inline void GenericItemFull_GenericItem::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* GenericItemFull_GenericItem::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* GenericItemFull_GenericItem::release_name() { + // @@protoc_insertion_point(field_release:MSRProto.GenericItemFull.GenericItem.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void GenericItemFull_GenericItem::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.GenericItemFull.GenericItem.name) +} + +// uint32 properties = 3; +inline void GenericItemFull_GenericItem::clear_properties() { + properties_ = 0u; +} +inline uint32_t GenericItemFull_GenericItem::_internal_properties() const { + return properties_; +} +inline uint32_t GenericItemFull_GenericItem::properties() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.GenericItem.properties) + return _internal_properties(); +} +inline void GenericItemFull_GenericItem::_internal_set_properties(uint32_t value) { + + properties_ = value; +} +inline void GenericItemFull_GenericItem::set_properties(uint32_t value) { + _internal_set_properties(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.GenericItem.properties) +} + +// uint32 quantity = 4; +inline void GenericItemFull_GenericItem::clear_quantity() { + quantity_ = 0u; +} +inline uint32_t GenericItemFull_GenericItem::_internal_quantity() const { + return quantity_; +} +inline uint32_t GenericItemFull_GenericItem::quantity() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.GenericItem.quantity) + return _internal_quantity(); +} +inline void GenericItemFull_GenericItem::_internal_set_quantity(uint32_t value) { + + quantity_ = value; +} +inline void GenericItemFull_GenericItem::set_quantity(uint32_t value) { + _internal_set_quantity(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.GenericItem.quantity) +} + +// uint32 quality = 5; +inline void GenericItemFull_GenericItem::clear_quality() { + quality_ = 0u; +} +inline uint32_t GenericItemFull_GenericItem::_internal_quality() const { + return quality_; +} +inline uint32_t GenericItemFull_GenericItem::quality() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.GenericItem.quality) + return _internal_quality(); +} +inline void GenericItemFull_GenericItem::_internal_set_quality(uint32_t value) { + + quality_ = value; +} +inline void GenericItemFull_GenericItem::set_quality(uint32_t value) { + _internal_set_quality(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.GenericItem.quality) +} + +// uint32 maxQuality = 6; +inline void GenericItemFull_GenericItem::clear_maxquality() { + maxquality_ = 0u; +} +inline uint32_t GenericItemFull_GenericItem::_internal_maxquality() const { + return maxquality_; +} +inline uint32_t GenericItemFull_GenericItem::maxquality() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.GenericItem.maxQuality) + return _internal_maxquality(); +} +inline void GenericItemFull_GenericItem::_internal_set_maxquality(uint32_t value) { + + maxquality_ = value; +} +inline void GenericItemFull_GenericItem::set_maxquality(uint32_t value) { + _internal_set_maxquality(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.GenericItem.maxQuality) +} + +// ------------------------------------------------------------------- + +// GenericItemFull + +// .MSRProto.GenericItemFull.GenericItem genericItem = 1; +inline bool GenericItemFull::_internal_has_genericitem() const { + return this != internal_default_instance() && genericitem_ != nullptr; +} +inline bool GenericItemFull::has_genericitem() const { + return _internal_has_genericitem(); +} +inline void GenericItemFull::clear_genericitem() { + if (GetArenaForAllocation() == nullptr && genericitem_ != nullptr) { + delete genericitem_; + } + genericitem_ = nullptr; +} +inline const ::MSRProto::GenericItemFull_GenericItem& GenericItemFull::_internal_genericitem() const { + const ::MSRProto::GenericItemFull_GenericItem* p = genericitem_; + return p != nullptr ? *p : reinterpret_cast( + ::MSRProto::_GenericItemFull_GenericItem_default_instance_); +} +inline const ::MSRProto::GenericItemFull_GenericItem& GenericItemFull::genericitem() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.genericItem) + return _internal_genericitem(); +} +inline void GenericItemFull::unsafe_arena_set_allocated_genericitem( + ::MSRProto::GenericItemFull_GenericItem* genericitem) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(genericitem_); + } + genericitem_ = genericitem; + if (genericitem) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MSRProto.GenericItemFull.genericItem) +} +inline ::MSRProto::GenericItemFull_GenericItem* GenericItemFull::release_genericitem() { + + ::MSRProto::GenericItemFull_GenericItem* temp = genericitem_; + genericitem_ = 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 ::MSRProto::GenericItemFull_GenericItem* GenericItemFull::unsafe_arena_release_genericitem() { + // @@protoc_insertion_point(field_release:MSRProto.GenericItemFull.genericItem) + + ::MSRProto::GenericItemFull_GenericItem* temp = genericitem_; + genericitem_ = nullptr; + return temp; +} +inline ::MSRProto::GenericItemFull_GenericItem* GenericItemFull::_internal_mutable_genericitem() { + + if (genericitem_ == nullptr) { + auto* p = CreateMaybeMessage<::MSRProto::GenericItemFull_GenericItem>(GetArenaForAllocation()); + genericitem_ = p; + } + return genericitem_; +} +inline ::MSRProto::GenericItemFull_GenericItem* GenericItemFull::mutable_genericitem() { + ::MSRProto::GenericItemFull_GenericItem* _msg = _internal_mutable_genericitem(); + // @@protoc_insertion_point(field_mutable:MSRProto.GenericItemFull.genericItem) + return _msg; +} +inline void GenericItemFull::set_allocated_genericitem(::MSRProto::GenericItemFull_GenericItem* genericitem) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete genericitem_; + } + if (genericitem) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MSRProto::GenericItemFull_GenericItem>::GetOwningArena(genericitem); + if (message_arena != submessage_arena) { + genericitem = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, genericitem, submessage_arena); + } + + } else { + + } + genericitem_ = genericitem; + // @@protoc_insertion_point(field_set_allocated:MSRProto.GenericItemFull.genericItem) +} + +// uint32 Location = 2; +inline void GenericItemFull::clear_location() { + location_ = 0u; +} +inline uint32_t GenericItemFull::_internal_location() const { + return location_; +} +inline uint32_t GenericItemFull::location() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.Location) + return _internal_location(); +} +inline void GenericItemFull::_internal_set_location(uint32_t value) { + + location_ = value; +} +inline void GenericItemFull::set_location(uint32_t value) { + _internal_set_location(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.Location) +} + +// .MSRProto.GenericItemFull.HandId Hand = 3; +inline void GenericItemFull::clear_hand() { + hand_ = 0; +} +inline ::MSRProto::GenericItemFull_HandId GenericItemFull::_internal_hand() const { + return static_cast< ::MSRProto::GenericItemFull_HandId >(hand_); +} +inline ::MSRProto::GenericItemFull_HandId GenericItemFull::hand() const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.Hand) + return _internal_hand(); +} +inline void GenericItemFull::_internal_set_hand(::MSRProto::GenericItemFull_HandId value) { + + hand_ = value; +} +inline void GenericItemFull::set_hand(::MSRProto::GenericItemFull_HandId value) { + _internal_set_hand(value); + // @@protoc_insertion_point(field_set:MSRProto.GenericItemFull.Hand) +} + +// repeated .MSRProto.GenericItemFull containerItems = 4; +inline int GenericItemFull::_internal_containeritems_size() const { + return containeritems_.size(); +} +inline int GenericItemFull::containeritems_size() const { + return _internal_containeritems_size(); +} +inline void GenericItemFull::clear_containeritems() { + containeritems_.Clear(); +} +inline ::MSRProto::GenericItemFull* GenericItemFull::mutable_containeritems(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.GenericItemFull.containerItems) + return containeritems_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >* +GenericItemFull::mutable_containeritems() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.GenericItemFull.containerItems) + return &containeritems_; +} +inline const ::MSRProto::GenericItemFull& GenericItemFull::_internal_containeritems(int index) const { + return containeritems_.Get(index); +} +inline const ::MSRProto::GenericItemFull& GenericItemFull::containeritems(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.GenericItemFull.containerItems) + return _internal_containeritems(index); +} +inline ::MSRProto::GenericItemFull* GenericItemFull::_internal_add_containeritems() { + return containeritems_.Add(); +} +inline ::MSRProto::GenericItemFull* GenericItemFull::add_containeritems() { + ::MSRProto::GenericItemFull* _add = _internal_add_containeritems(); + // @@protoc_insertion_point(field_add:MSRProto.GenericItemFull.containerItems) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >& +GenericItemFull::containeritems() const { + // @@protoc_insertion_point(field_list:MSRProto.GenericItemFull.containerItems) + return containeritems_; +} + +// ------------------------------------------------------------------- + +// Storage + +// string name = 1; +inline void Storage::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& Storage::name() const { + // @@protoc_insertion_point(field_get:MSRProto.Storage.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Storage::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.Storage.name) +} +inline std::string* Storage::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:MSRProto.Storage.name) + return _s; +} +inline const std::string& Storage::_internal_name() const { + return name_.Get(); +} +inline void Storage::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* Storage::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* Storage::release_name() { + // @@protoc_insertion_point(field_release:MSRProto.Storage.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void Storage::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.Storage.name) +} + +// repeated .MSRProto.GenericItemFull items = 2; +inline int Storage::_internal_items_size() const { + return items_.size(); +} +inline int Storage::items_size() const { + return _internal_items_size(); +} +inline void Storage::clear_items() { + items_.Clear(); +} +inline ::MSRProto::GenericItemFull* Storage::mutable_items(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.Storage.items) + return items_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >* +Storage::mutable_items() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.Storage.items) + return &items_; +} +inline const ::MSRProto::GenericItemFull& Storage::_internal_items(int index) const { + return items_.Get(index); +} +inline const ::MSRProto::GenericItemFull& Storage::items(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.Storage.items) + return _internal_items(index); +} +inline ::MSRProto::GenericItemFull* Storage::_internal_add_items() { + return items_.Add(); +} +inline ::MSRProto::GenericItemFull* Storage::add_items() { + ::MSRProto::GenericItemFull* _add = _internal_add_items(); + // @@protoc_insertion_point(field_add:MSRProto.Storage.items) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >& +Storage::items() const { + // @@protoc_insertion_point(field_list:MSRProto.Storage.items) + return items_; +} + +// ------------------------------------------------------------------- + +// CharData_SaveData_Vector3 + +// double x = 1; +inline void CharData_SaveData_Vector3::clear_x() { + x_ = 0; +} +inline double CharData_SaveData_Vector3::_internal_x() const { + return x_; +} +inline double CharData_SaveData_Vector3::x() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.Vector3.x) + return _internal_x(); +} +inline void CharData_SaveData_Vector3::_internal_set_x(double value) { + + x_ = value; +} +inline void CharData_SaveData_Vector3::set_x(double value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.Vector3.x) +} + +// double y = 2; +inline void CharData_SaveData_Vector3::clear_y() { + y_ = 0; +} +inline double CharData_SaveData_Vector3::_internal_y() const { + return y_; +} +inline double CharData_SaveData_Vector3::y() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.Vector3.y) + return _internal_y(); +} +inline void CharData_SaveData_Vector3::_internal_set_y(double value) { + + y_ = value; +} +inline void CharData_SaveData_Vector3::set_y(double value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.Vector3.y) +} + +// double z = 3; +inline void CharData_SaveData_Vector3::clear_z() { + z_ = 0; +} +inline double CharData_SaveData_Vector3::_internal_z() const { + return z_; +} +inline double CharData_SaveData_Vector3::z() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.Vector3.z) + return _internal_z(); +} +inline void CharData_SaveData_Vector3::_internal_set_z(double value) { + + z_ = value; +} +inline void CharData_SaveData_Vector3::set_z(double value) { + _internal_set_z(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.Vector3.z) +} + +// ------------------------------------------------------------------- + +// CharData_SaveData + +// int32 version = 1; +inline void CharData_SaveData::clear_version() { + version_ = 0; +} +inline int32_t CharData_SaveData::_internal_version() const { + return version_; +} +inline int32_t CharData_SaveData::version() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.version) + return _internal_version(); +} +inline void CharData_SaveData::_internal_set_version(int32_t value) { + + version_ = value; +} +inline void CharData_SaveData::set_version(int32_t value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.version) +} + +// string name = 2; +inline void CharData_SaveData::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::name() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.name) +} +inline std::string* CharData_SaveData::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.name) + return _s; +} +inline const std::string& CharData_SaveData::_internal_name() const { + return name_.Get(); +} +inline void CharData_SaveData::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_name() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.name) +} + +// string steamId = 3; +inline void CharData_SaveData::clear_steamid() { + steamid_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::steamid() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.steamId) + return _internal_steamid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_steamid(ArgT0&& arg0, ArgT... args) { + + steamid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.steamId) +} +inline std::string* CharData_SaveData::mutable_steamid() { + std::string* _s = _internal_mutable_steamid(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.steamId) + return _s; +} +inline const std::string& CharData_SaveData::_internal_steamid() const { + return steamid_.Get(); +} +inline void CharData_SaveData::_internal_set_steamid(const std::string& value) { + + steamid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_steamid() { + + return steamid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_steamid() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.steamId) + return steamid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_steamid(std::string* steamid) { + if (steamid != nullptr) { + + } else { + + } + steamid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), steamid, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (steamid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + steamid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.steamId) +} + +// string race = 4; +inline void CharData_SaveData::clear_race() { + race_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::race() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.race) + return _internal_race(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_race(ArgT0&& arg0, ArgT... args) { + + race_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.race) +} +inline std::string* CharData_SaveData::mutable_race() { + std::string* _s = _internal_mutable_race(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.race) + return _s; +} +inline const std::string& CharData_SaveData::_internal_race() const { + return race_.Get(); +} +inline void CharData_SaveData::_internal_set_race(const std::string& value) { + + race_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_race() { + + return race_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_race() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.race) + return race_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_race(std::string* race) { + if (race != nullptr) { + + } else { + + } + race_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), race, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (race_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + race_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.race) +} + +// .MSRProto.CharData.SaveData.GenderId gender = 5; +inline void CharData_SaveData::clear_gender() { + gender_ = 0; +} +inline ::MSRProto::CharData_SaveData_GenderId CharData_SaveData::_internal_gender() const { + return static_cast< ::MSRProto::CharData_SaveData_GenderId >(gender_); +} +inline ::MSRProto::CharData_SaveData_GenderId CharData_SaveData::gender() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.gender) + return _internal_gender(); +} +inline void CharData_SaveData::_internal_set_gender(::MSRProto::CharData_SaveData_GenderId value) { + + gender_ = value; +} +inline void CharData_SaveData::set_gender(::MSRProto::CharData_SaveData_GenderId value) { + _internal_set_gender(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.gender) +} + +// string mapName = 6; +inline void CharData_SaveData::clear_mapname() { + mapname_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::mapname() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.mapName) + return _internal_mapname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_mapname(ArgT0&& arg0, ArgT... args) { + + mapname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.mapName) +} +inline std::string* CharData_SaveData::mutable_mapname() { + std::string* _s = _internal_mutable_mapname(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.mapName) + return _s; +} +inline const std::string& CharData_SaveData::_internal_mapname() const { + return mapname_.Get(); +} +inline void CharData_SaveData::_internal_set_mapname(const std::string& value) { + + mapname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_mapname() { + + return mapname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_mapname() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.mapName) + return mapname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_mapname(std::string* mapname) { + if (mapname != nullptr) { + + } else { + + } + mapname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mapname, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mapname_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mapname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.mapName) +} + +// string nextMap = 7; +inline void CharData_SaveData::clear_nextmap() { + nextmap_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::nextmap() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.nextMap) + return _internal_nextmap(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_nextmap(ArgT0&& arg0, ArgT... args) { + + nextmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.nextMap) +} +inline std::string* CharData_SaveData::mutable_nextmap() { + std::string* _s = _internal_mutable_nextmap(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.nextMap) + return _s; +} +inline const std::string& CharData_SaveData::_internal_nextmap() const { + return nextmap_.Get(); +} +inline void CharData_SaveData::_internal_set_nextmap(const std::string& value) { + + nextmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_nextmap() { + + return nextmap_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_nextmap() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.nextMap) + return nextmap_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_nextmap(std::string* nextmap) { + if (nextmap != nullptr) { + + } else { + + } + nextmap_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nextmap, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (nextmap_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + nextmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.nextMap) +} + +// string oldTransition = 8; +inline void CharData_SaveData::clear_oldtransition() { + oldtransition_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::oldtransition() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.oldTransition) + return _internal_oldtransition(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_oldtransition(ArgT0&& arg0, ArgT... args) { + + oldtransition_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.oldTransition) +} +inline std::string* CharData_SaveData::mutable_oldtransition() { + std::string* _s = _internal_mutable_oldtransition(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.oldTransition) + return _s; +} +inline const std::string& CharData_SaveData::_internal_oldtransition() const { + return oldtransition_.Get(); +} +inline void CharData_SaveData::_internal_set_oldtransition(const std::string& value) { + + oldtransition_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_oldtransition() { + + return oldtransition_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_oldtransition() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.oldTransition) + return oldtransition_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_oldtransition(std::string* oldtransition) { + if (oldtransition != nullptr) { + + } else { + + } + oldtransition_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oldtransition, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (oldtransition_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + oldtransition_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.oldTransition) +} + +// string newTransition = 9; +inline void CharData_SaveData::clear_newtransition() { + newtransition_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::newtransition() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.newTransition) + return _internal_newtransition(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_newtransition(ArgT0&& arg0, ArgT... args) { + + newtransition_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.newTransition) +} +inline std::string* CharData_SaveData::mutable_newtransition() { + std::string* _s = _internal_mutable_newtransition(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.newTransition) + return _s; +} +inline const std::string& CharData_SaveData::_internal_newtransition() const { + return newtransition_.Get(); +} +inline void CharData_SaveData::_internal_set_newtransition(const std::string& value) { + + newtransition_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_newtransition() { + + return newtransition_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_newtransition() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.newTransition) + return newtransition_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_newtransition(std::string* newtransition) { + if (newtransition != nullptr) { + + } else { + + } + newtransition_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), newtransition, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (newtransition_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + newtransition_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.newTransition) +} + +// .MSRProto.CharData.SaveData.Vector3 origin = 10; +inline bool CharData_SaveData::_internal_has_origin() const { + return this != internal_default_instance() && origin_ != nullptr; +} +inline bool CharData_SaveData::has_origin() const { + return _internal_has_origin(); +} +inline void CharData_SaveData::clear_origin() { + if (GetArenaForAllocation() == nullptr && origin_ != nullptr) { + delete origin_; + } + origin_ = nullptr; +} +inline const ::MSRProto::CharData_SaveData_Vector3& CharData_SaveData::_internal_origin() const { + const ::MSRProto::CharData_SaveData_Vector3* p = origin_; + return p != nullptr ? *p : reinterpret_cast( + ::MSRProto::_CharData_SaveData_Vector3_default_instance_); +} +inline const ::MSRProto::CharData_SaveData_Vector3& CharData_SaveData::origin() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.origin) + return _internal_origin(); +} +inline void CharData_SaveData::unsafe_arena_set_allocated_origin( + ::MSRProto::CharData_SaveData_Vector3* origin) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin_); + } + origin_ = origin; + if (origin) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MSRProto.CharData.SaveData.origin) +} +inline ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::release_origin() { + + ::MSRProto::CharData_SaveData_Vector3* temp = origin_; + origin_ = 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 ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::unsafe_arena_release_origin() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.origin) + + ::MSRProto::CharData_SaveData_Vector3* temp = origin_; + origin_ = nullptr; + return temp; +} +inline ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::_internal_mutable_origin() { + + if (origin_ == nullptr) { + auto* p = CreateMaybeMessage<::MSRProto::CharData_SaveData_Vector3>(GetArenaForAllocation()); + origin_ = p; + } + return origin_; +} +inline ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::mutable_origin() { + ::MSRProto::CharData_SaveData_Vector3* _msg = _internal_mutable_origin(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.origin) + return _msg; +} +inline void CharData_SaveData::set_allocated_origin(::MSRProto::CharData_SaveData_Vector3* origin) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete origin_; + } + if (origin) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MSRProto::CharData_SaveData_Vector3>::GetOwningArena(origin); + if (message_arena != submessage_arena) { + origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, origin, submessage_arena); + } + + } else { + + } + origin_ = origin; + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.origin) +} + +// .MSRProto.CharData.SaveData.Vector3 angles = 11; +inline bool CharData_SaveData::_internal_has_angles() const { + return this != internal_default_instance() && angles_ != nullptr; +} +inline bool CharData_SaveData::has_angles() const { + return _internal_has_angles(); +} +inline void CharData_SaveData::clear_angles() { + if (GetArenaForAllocation() == nullptr && angles_ != nullptr) { + delete angles_; + } + angles_ = nullptr; +} +inline const ::MSRProto::CharData_SaveData_Vector3& CharData_SaveData::_internal_angles() const { + const ::MSRProto::CharData_SaveData_Vector3* p = angles_; + return p != nullptr ? *p : reinterpret_cast( + ::MSRProto::_CharData_SaveData_Vector3_default_instance_); +} +inline const ::MSRProto::CharData_SaveData_Vector3& CharData_SaveData::angles() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.angles) + return _internal_angles(); +} +inline void CharData_SaveData::unsafe_arena_set_allocated_angles( + ::MSRProto::CharData_SaveData_Vector3* angles) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angles_); + } + angles_ = angles; + if (angles) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MSRProto.CharData.SaveData.angles) +} +inline ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::release_angles() { + + ::MSRProto::CharData_SaveData_Vector3* temp = angles_; + angles_ = 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 ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::unsafe_arena_release_angles() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.angles) + + ::MSRProto::CharData_SaveData_Vector3* temp = angles_; + angles_ = nullptr; + return temp; +} +inline ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::_internal_mutable_angles() { + + if (angles_ == nullptr) { + auto* p = CreateMaybeMessage<::MSRProto::CharData_SaveData_Vector3>(GetArenaForAllocation()); + angles_ = p; + } + return angles_; +} +inline ::MSRProto::CharData_SaveData_Vector3* CharData_SaveData::mutable_angles() { + ::MSRProto::CharData_SaveData_Vector3* _msg = _internal_mutable_angles(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.angles) + return _msg; +} +inline void CharData_SaveData::set_allocated_angles(::MSRProto::CharData_SaveData_Vector3* angles) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete angles_; + } + if (angles) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MSRProto::CharData_SaveData_Vector3>::GetOwningArena(angles); + if (message_arena != submessage_arena) { + angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, angles, submessage_arena); + } + + } else { + + } + angles_ = angles; + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.angles) +} + +// bool isElite = 12; +inline void CharData_SaveData::clear_iselite() { + iselite_ = false; +} +inline bool CharData_SaveData::_internal_iselite() const { + return iselite_; +} +inline bool CharData_SaveData::iselite() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.isElite) + return _internal_iselite(); +} +inline void CharData_SaveData::_internal_set_iselite(bool value) { + + iselite_ = value; +} +inline void CharData_SaveData::set_iselite(bool value) { + _internal_set_iselite(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.isElite) +} + +// uint32 gold = 13; +inline void CharData_SaveData::clear_gold() { + gold_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_gold() const { + return gold_; +} +inline uint32_t CharData_SaveData::gold() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.gold) + return _internal_gold(); +} +inline void CharData_SaveData::_internal_set_gold(uint32_t value) { + + gold_ = value; +} +inline void CharData_SaveData::set_gold(uint32_t value) { + _internal_set_gold(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.gold) +} + +// uint32 maxHP = 14; +inline void CharData_SaveData::clear_maxhp() { + maxhp_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_maxhp() const { + return maxhp_; +} +inline uint32_t CharData_SaveData::maxhp() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.maxHP) + return _internal_maxhp(); +} +inline void CharData_SaveData::_internal_set_maxhp(uint32_t value) { + + maxhp_ = value; +} +inline void CharData_SaveData::set_maxhp(uint32_t value) { + _internal_set_maxhp(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.maxHP) +} + +// uint32 maxMP = 15; +inline void CharData_SaveData::clear_maxmp() { + maxmp_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_maxmp() const { + return maxmp_; +} +inline uint32_t CharData_SaveData::maxmp() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.maxMP) + return _internal_maxmp(); +} +inline void CharData_SaveData::_internal_set_maxmp(uint32_t value) { + + maxmp_ = value; +} +inline void CharData_SaveData::set_maxmp(uint32_t value) { + _internal_set_maxmp(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.maxMP) +} + +// uint32 currentHP = 16; +inline void CharData_SaveData::clear_currenthp() { + currenthp_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_currenthp() const { + return currenthp_; +} +inline uint32_t CharData_SaveData::currenthp() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.currentHP) + return _internal_currenthp(); +} +inline void CharData_SaveData::_internal_set_currenthp(uint32_t value) { + + currenthp_ = value; +} +inline void CharData_SaveData::set_currenthp(uint32_t value) { + _internal_set_currenthp(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.currentHP) +} + +// uint32 currentMP = 17; +inline void CharData_SaveData::clear_currentmp() { + currentmp_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_currentmp() const { + return currentmp_; +} +inline uint32_t CharData_SaveData::currentmp() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.currentMP) + return _internal_currentmp(); +} +inline void CharData_SaveData::_internal_set_currentmp(uint32_t value) { + + currentmp_ = value; +} +inline void CharData_SaveData::set_currentmp(uint32_t value) { + _internal_set_currentmp(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.currentMP) +} + +// string partyName = 18; +inline void CharData_SaveData::clear_partyname() { + partyname_.ClearToEmpty(); +} +inline const std::string& CharData_SaveData::partyname() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.partyName) + return _internal_partyname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_SaveData::set_partyname(ArgT0&& arg0, ArgT... args) { + + partyname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.partyName) +} +inline std::string* CharData_SaveData::mutable_partyname() { + std::string* _s = _internal_mutable_partyname(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.SaveData.partyName) + return _s; +} +inline const std::string& CharData_SaveData::_internal_partyname() const { + return partyname_.Get(); +} +inline void CharData_SaveData::_internal_set_partyname(const std::string& value) { + + partyname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::_internal_mutable_partyname() { + + return partyname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_SaveData::release_partyname() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.SaveData.partyName) + return partyname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_SaveData::set_allocated_partyname(std::string* partyname) { + if (partyname != nullptr) { + + } else { + + } + partyname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partyname, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (partyname_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + partyname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.SaveData.partyName) +} + +// uint32 partyId = 19; +inline void CharData_SaveData::clear_partyid() { + partyid_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_partyid() const { + return partyid_; +} +inline uint32_t CharData_SaveData::partyid() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.partyId) + return _internal_partyid(); +} +inline void CharData_SaveData::_internal_set_partyid(uint32_t value) { + + partyid_ = value; +} +inline void CharData_SaveData::set_partyid(uint32_t value) { + _internal_set_partyid(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.partyId) +} + +// uint32 playerKills = 20; +inline void CharData_SaveData::clear_playerkills() { + playerkills_ = 0u; +} +inline uint32_t CharData_SaveData::_internal_playerkills() const { + return playerkills_; +} +inline uint32_t CharData_SaveData::playerkills() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.playerKills) + return _internal_playerkills(); +} +inline void CharData_SaveData::_internal_set_playerkills(uint32_t value) { + + playerkills_ = value; +} +inline void CharData_SaveData::set_playerkills(uint32_t value) { + _internal_set_playerkills(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.playerKills) +} + +// double timeWaitedToForgetKill = 21; +inline void CharData_SaveData::clear_timewaitedtoforgetkill() { + timewaitedtoforgetkill_ = 0; +} +inline double CharData_SaveData::_internal_timewaitedtoforgetkill() const { + return timewaitedtoforgetkill_; +} +inline double CharData_SaveData::timewaitedtoforgetkill() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.timeWaitedToForgetKill) + return _internal_timewaitedtoforgetkill(); +} +inline void CharData_SaveData::_internal_set_timewaitedtoforgetkill(double value) { + + timewaitedtoforgetkill_ = value; +} +inline void CharData_SaveData::set_timewaitedtoforgetkill(double value) { + _internal_set_timewaitedtoforgetkill(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.timeWaitedToForgetKill) +} + +// double timeWaitedToForgetSteal = 22; +inline void CharData_SaveData::clear_timewaitedtoforgetsteal() { + timewaitedtoforgetsteal_ = 0; +} +inline double CharData_SaveData::_internal_timewaitedtoforgetsteal() const { + return timewaitedtoforgetsteal_; +} +inline double CharData_SaveData::timewaitedtoforgetsteal() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.SaveData.timeWaitedToForgetSteal) + return _internal_timewaitedtoforgetsteal(); +} +inline void CharData_SaveData::_internal_set_timewaitedtoforgetsteal(double value) { + + timewaitedtoforgetsteal_ = value; +} +inline void CharData_SaveData::set_timewaitedtoforgetsteal(double value) { + _internal_set_timewaitedtoforgetsteal(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.SaveData.timeWaitedToForgetSteal) +} + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// CharData_Companion + +// string scriptName = 1; +inline void CharData_Companion::clear_scriptname() { + scriptname_.ClearToEmpty(); +} +inline const std::string& CharData_Companion::scriptname() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.Companion.scriptName) + return _internal_scriptname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CharData_Companion::set_scriptname(ArgT0&& arg0, ArgT... args) { + + scriptname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:MSRProto.CharData.Companion.scriptName) +} +inline std::string* CharData_Companion::mutable_scriptname() { + std::string* _s = _internal_mutable_scriptname(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.Companion.scriptName) + return _s; +} +inline const std::string& CharData_Companion::_internal_scriptname() const { + return scriptname_.Get(); +} +inline void CharData_Companion::_internal_set_scriptname(const std::string& value) { + + scriptname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* CharData_Companion::_internal_mutable_scriptname() { + + return scriptname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* CharData_Companion::release_scriptname() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.Companion.scriptName) + return scriptname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +} +inline void CharData_Companion::set_allocated_scriptname(std::string* scriptname) { + if (scriptname != nullptr) { + + } else { + + } + scriptname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), scriptname, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (scriptname_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + scriptname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.Companion.scriptName) +} + +// map scriptedSaveVariables = 2; +inline int CharData_Companion::_internal_scriptedsavevariables_size() const { + return scriptedsavevariables_.size(); +} +inline int CharData_Companion::scriptedsavevariables_size() const { + return _internal_scriptedsavevariables_size(); +} +inline void CharData_Companion::clear_scriptedsavevariables() { + scriptedsavevariables_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& +CharData_Companion::_internal_scriptedsavevariables() const { + return scriptedsavevariables_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& +CharData_Companion::scriptedsavevariables() const { + // @@protoc_insertion_point(field_map:MSRProto.CharData.Companion.scriptedSaveVariables) + return _internal_scriptedsavevariables(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* +CharData_Companion::_internal_mutable_scriptedsavevariables() { + return scriptedsavevariables_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* +CharData_Companion::mutable_scriptedsavevariables() { + // @@protoc_insertion_point(field_mutable_map:MSRProto.CharData.Companion.scriptedSaveVariables) + return _internal_mutable_scriptedsavevariables(); +} + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// CharData_QuickSlot + +// .MSRProto.CharData.QuickSlot.QuickSlotTypeId type = 1; +inline void CharData_QuickSlot::clear_type() { + type_ = 0; +} +inline ::MSRProto::CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::_internal_type() const { + return static_cast< ::MSRProto::CharData_QuickSlot_QuickSlotTypeId >(type_); +} +inline ::MSRProto::CharData_QuickSlot_QuickSlotTypeId CharData_QuickSlot::type() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.QuickSlot.type) + return _internal_type(); +} +inline void CharData_QuickSlot::_internal_set_type(::MSRProto::CharData_QuickSlot_QuickSlotTypeId value) { + + type_ = value; +} +inline void CharData_QuickSlot::set_type(::MSRProto::CharData_QuickSlot_QuickSlotTypeId value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.QuickSlot.type) +} + +// uint32 id = 2; +inline void CharData_QuickSlot::clear_id() { + id_ = 0u; +} +inline uint32_t CharData_QuickSlot::_internal_id() const { + return id_; +} +inline uint32_t CharData_QuickSlot::id() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.QuickSlot.id) + return _internal_id(); +} +inline void CharData_QuickSlot::_internal_set_id(uint32_t value) { + + id_ = value; +} +inline void CharData_QuickSlot::set_id(uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.QuickSlot.id) +} + +// ------------------------------------------------------------------- + +// CharData + +// .MSRProto.CharData.SaveData saveData = 1; +inline bool CharData::_internal_has_savedata() const { + return this != internal_default_instance() && savedata_ != nullptr; +} +inline bool CharData::has_savedata() const { + return _internal_has_savedata(); +} +inline void CharData::clear_savedata() { + if (GetArenaForAllocation() == nullptr && savedata_ != nullptr) { + delete savedata_; + } + savedata_ = nullptr; +} +inline const ::MSRProto::CharData_SaveData& CharData::_internal_savedata() const { + const ::MSRProto::CharData_SaveData* p = savedata_; + return p != nullptr ? *p : reinterpret_cast( + ::MSRProto::_CharData_SaveData_default_instance_); +} +inline const ::MSRProto::CharData_SaveData& CharData::savedata() const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.saveData) + return _internal_savedata(); +} +inline void CharData::unsafe_arena_set_allocated_savedata( + ::MSRProto::CharData_SaveData* savedata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(savedata_); + } + savedata_ = savedata; + if (savedata) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MSRProto.CharData.saveData) +} +inline ::MSRProto::CharData_SaveData* CharData::release_savedata() { + + ::MSRProto::CharData_SaveData* temp = savedata_; + savedata_ = 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 ::MSRProto::CharData_SaveData* CharData::unsafe_arena_release_savedata() { + // @@protoc_insertion_point(field_release:MSRProto.CharData.saveData) + + ::MSRProto::CharData_SaveData* temp = savedata_; + savedata_ = nullptr; + return temp; +} +inline ::MSRProto::CharData_SaveData* CharData::_internal_mutable_savedata() { + + if (savedata_ == nullptr) { + auto* p = CreateMaybeMessage<::MSRProto::CharData_SaveData>(GetArenaForAllocation()); + savedata_ = p; + } + return savedata_; +} +inline ::MSRProto::CharData_SaveData* CharData::mutable_savedata() { + ::MSRProto::CharData_SaveData* _msg = _internal_mutable_savedata(); + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.saveData) + return _msg; +} +inline void CharData::set_allocated_savedata(::MSRProto::CharData_SaveData* savedata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete savedata_; + } + if (savedata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MSRProto::CharData_SaveData>::GetOwningArena(savedata); + if (message_arena != submessage_arena) { + savedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, savedata, submessage_arena); + } + + } else { + + } + savedata_ = savedata; + // @@protoc_insertion_point(field_set_allocated:MSRProto.CharData.saveData) +} + +// repeated string visitedMaps = 2; +inline int CharData::_internal_visitedmaps_size() const { + return visitedmaps_.size(); +} +inline int CharData::visitedmaps_size() const { + return _internal_visitedmaps_size(); +} +inline void CharData::clear_visitedmaps() { + visitedmaps_.Clear(); +} +inline std::string* CharData::add_visitedmaps() { + std::string* _s = _internal_add_visitedmaps(); + // @@protoc_insertion_point(field_add_mutable:MSRProto.CharData.visitedMaps) + return _s; +} +inline const std::string& CharData::_internal_visitedmaps(int index) const { + return visitedmaps_.Get(index); +} +inline const std::string& CharData::visitedmaps(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.visitedMaps) + return _internal_visitedmaps(index); +} +inline std::string* CharData::mutable_visitedmaps(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.visitedMaps) + return visitedmaps_.Mutable(index); +} +inline void CharData::set_visitedmaps(int index, const std::string& value) { + visitedmaps_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.visitedMaps) +} +inline void CharData::set_visitedmaps(int index, std::string&& value) { + visitedmaps_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:MSRProto.CharData.visitedMaps) +} +inline void CharData::set_visitedmaps(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + visitedmaps_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:MSRProto.CharData.visitedMaps) +} +inline void CharData::set_visitedmaps(int index, const char* value, size_t size) { + visitedmaps_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:MSRProto.CharData.visitedMaps) +} +inline std::string* CharData::_internal_add_visitedmaps() { + return visitedmaps_.Add(); +} +inline void CharData::add_visitedmaps(const std::string& value) { + visitedmaps_.Add()->assign(value); + // @@protoc_insertion_point(field_add:MSRProto.CharData.visitedMaps) +} +inline void CharData::add_visitedmaps(std::string&& value) { + visitedmaps_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:MSRProto.CharData.visitedMaps) +} +inline void CharData::add_visitedmaps(const char* value) { + GOOGLE_DCHECK(value != nullptr); + visitedmaps_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:MSRProto.CharData.visitedMaps) +} +inline void CharData::add_visitedmaps(const char* value, size_t size) { + visitedmaps_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:MSRProto.CharData.visitedMaps) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +CharData::visitedmaps() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.visitedMaps) + return visitedmaps_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +CharData::mutable_visitedmaps() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.visitedMaps) + return &visitedmaps_; +} + +// repeated .MSRProto.Stat statList = 3; +inline int CharData::_internal_statlist_size() const { + return statlist_.size(); +} +inline int CharData::statlist_size() const { + return _internal_statlist_size(); +} +inline void CharData::clear_statlist() { + statlist_.Clear(); +} +inline ::MSRProto::Stat* CharData::mutable_statlist(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.statList) + return statlist_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat >* +CharData::mutable_statlist() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.statList) + return &statlist_; +} +inline const ::MSRProto::Stat& CharData::_internal_statlist(int index) const { + return statlist_.Get(index); +} +inline const ::MSRProto::Stat& CharData::statlist(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.statList) + return _internal_statlist(index); +} +inline ::MSRProto::Stat* CharData::_internal_add_statlist() { + return statlist_.Add(); +} +inline ::MSRProto::Stat* CharData::add_statlist() { + ::MSRProto::Stat* _add = _internal_add_statlist(); + // @@protoc_insertion_point(field_add:MSRProto.CharData.statList) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Stat >& +CharData::statlist() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.statList) + return statlist_; +} + +// repeated string knownSpells = 4; +inline int CharData::_internal_knownspells_size() const { + return knownspells_.size(); +} +inline int CharData::knownspells_size() const { + return _internal_knownspells_size(); +} +inline void CharData::clear_knownspells() { + knownspells_.Clear(); +} +inline std::string* CharData::add_knownspells() { + std::string* _s = _internal_add_knownspells(); + // @@protoc_insertion_point(field_add_mutable:MSRProto.CharData.knownSpells) + return _s; +} +inline const std::string& CharData::_internal_knownspells(int index) const { + return knownspells_.Get(index); +} +inline const std::string& CharData::knownspells(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.knownSpells) + return _internal_knownspells(index); +} +inline std::string* CharData::mutable_knownspells(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.knownSpells) + return knownspells_.Mutable(index); +} +inline void CharData::set_knownspells(int index, const std::string& value) { + knownspells_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.knownSpells) +} +inline void CharData::set_knownspells(int index, std::string&& value) { + knownspells_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:MSRProto.CharData.knownSpells) +} +inline void CharData::set_knownspells(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + knownspells_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:MSRProto.CharData.knownSpells) +} +inline void CharData::set_knownspells(int index, const char* value, size_t size) { + knownspells_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:MSRProto.CharData.knownSpells) +} +inline std::string* CharData::_internal_add_knownspells() { + return knownspells_.Add(); +} +inline void CharData::add_knownspells(const std::string& value) { + knownspells_.Add()->assign(value); + // @@protoc_insertion_point(field_add:MSRProto.CharData.knownSpells) +} +inline void CharData::add_knownspells(std::string&& value) { + knownspells_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:MSRProto.CharData.knownSpells) +} +inline void CharData::add_knownspells(const char* value) { + GOOGLE_DCHECK(value != nullptr); + knownspells_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:MSRProto.CharData.knownSpells) +} +inline void CharData::add_knownspells(const char* value, size_t size) { + knownspells_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:MSRProto.CharData.knownSpells) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +CharData::knownspells() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.knownSpells) + return knownspells_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +CharData::mutable_knownspells() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.knownSpells) + return &knownspells_; +} + +// repeated .MSRProto.GenericItemFull items = 5; +inline int CharData::_internal_items_size() const { + return items_.size(); +} +inline int CharData::items_size() const { + return _internal_items_size(); +} +inline void CharData::clear_items() { + items_.Clear(); +} +inline ::MSRProto::GenericItemFull* CharData::mutable_items(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.items) + return items_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >* +CharData::mutable_items() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.items) + return &items_; +} +inline const ::MSRProto::GenericItemFull& CharData::_internal_items(int index) const { + return items_.Get(index); +} +inline const ::MSRProto::GenericItemFull& CharData::items(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.items) + return _internal_items(index); +} +inline ::MSRProto::GenericItemFull* CharData::_internal_add_items() { + return items_.Add(); +} +inline ::MSRProto::GenericItemFull* CharData::add_items() { + ::MSRProto::GenericItemFull* _add = _internal_add_items(); + // @@protoc_insertion_point(field_add:MSRProto.CharData.items) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::GenericItemFull >& +CharData::items() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.items) + return items_; +} + +// repeated .MSRProto.Storage storages = 6; +inline int CharData::_internal_storages_size() const { + return storages_.size(); +} +inline int CharData::storages_size() const { + return _internal_storages_size(); +} +inline void CharData::clear_storages() { + storages_.Clear(); +} +inline ::MSRProto::Storage* CharData::mutable_storages(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.storages) + return storages_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Storage >* +CharData::mutable_storages() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.storages) + return &storages_; +} +inline const ::MSRProto::Storage& CharData::_internal_storages(int index) const { + return storages_.Get(index); +} +inline const ::MSRProto::Storage& CharData::storages(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.storages) + return _internal_storages(index); +} +inline ::MSRProto::Storage* CharData::_internal_add_storages() { + return storages_.Add(); +} +inline ::MSRProto::Storage* CharData::add_storages() { + ::MSRProto::Storage* _add = _internal_add_storages(); + // @@protoc_insertion_point(field_add:MSRProto.CharData.storages) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::Storage >& +CharData::storages() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.storages) + return storages_; +} + +// repeated .MSRProto.CharData.Companion companions = 7; +inline int CharData::_internal_companions_size() const { + return companions_.size(); +} +inline int CharData::companions_size() const { + return _internal_companions_size(); +} +inline void CharData::clear_companions() { + companions_.Clear(); +} +inline ::MSRProto::CharData_Companion* CharData::mutable_companions(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.companions) + return companions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_Companion >* +CharData::mutable_companions() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.companions) + return &companions_; +} +inline const ::MSRProto::CharData_Companion& CharData::_internal_companions(int index) const { + return companions_.Get(index); +} +inline const ::MSRProto::CharData_Companion& CharData::companions(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.companions) + return _internal_companions(index); +} +inline ::MSRProto::CharData_Companion* CharData::_internal_add_companions() { + return companions_.Add(); +} +inline ::MSRProto::CharData_Companion* CharData::add_companions() { + ::MSRProto::CharData_Companion* _add = _internal_add_companions(); + // @@protoc_insertion_point(field_add:MSRProto.CharData.companions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_Companion >& +CharData::companions() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.companions) + return companions_; +} + +// repeated string viewedHelpTips = 8; +inline int CharData::_internal_viewedhelptips_size() const { + return viewedhelptips_.size(); +} +inline int CharData::viewedhelptips_size() const { + return _internal_viewedhelptips_size(); +} +inline void CharData::clear_viewedhelptips() { + viewedhelptips_.Clear(); +} +inline std::string* CharData::add_viewedhelptips() { + std::string* _s = _internal_add_viewedhelptips(); + // @@protoc_insertion_point(field_add_mutable:MSRProto.CharData.viewedHelpTips) + return _s; +} +inline const std::string& CharData::_internal_viewedhelptips(int index) const { + return viewedhelptips_.Get(index); +} +inline const std::string& CharData::viewedhelptips(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.viewedHelpTips) + return _internal_viewedhelptips(index); +} +inline std::string* CharData::mutable_viewedhelptips(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.viewedHelpTips) + return viewedhelptips_.Mutable(index); +} +inline void CharData::set_viewedhelptips(int index, const std::string& value) { + viewedhelptips_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:MSRProto.CharData.viewedHelpTips) +} +inline void CharData::set_viewedhelptips(int index, std::string&& value) { + viewedhelptips_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:MSRProto.CharData.viewedHelpTips) +} +inline void CharData::set_viewedhelptips(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + viewedhelptips_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:MSRProto.CharData.viewedHelpTips) +} +inline void CharData::set_viewedhelptips(int index, const char* value, size_t size) { + viewedhelptips_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:MSRProto.CharData.viewedHelpTips) +} +inline std::string* CharData::_internal_add_viewedhelptips() { + return viewedhelptips_.Add(); +} +inline void CharData::add_viewedhelptips(const std::string& value) { + viewedhelptips_.Add()->assign(value); + // @@protoc_insertion_point(field_add:MSRProto.CharData.viewedHelpTips) +} +inline void CharData::add_viewedhelptips(std::string&& value) { + viewedhelptips_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:MSRProto.CharData.viewedHelpTips) +} +inline void CharData::add_viewedhelptips(const char* value) { + GOOGLE_DCHECK(value != nullptr); + viewedhelptips_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:MSRProto.CharData.viewedHelpTips) +} +inline void CharData::add_viewedhelptips(const char* value, size_t size) { + viewedhelptips_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:MSRProto.CharData.viewedHelpTips) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +CharData::viewedhelptips() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.viewedHelpTips) + return viewedhelptips_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +CharData::mutable_viewedhelptips() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.viewedHelpTips) + return &viewedhelptips_; +} + +// map quests = 9; +inline int CharData::_internal_quests_size() const { + return quests_.size(); +} +inline int CharData::quests_size() const { + return _internal_quests_size(); +} +inline void CharData::clear_quests() { + quests_.Clear(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& +CharData::_internal_quests() const { + return quests_.GetMap(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& +CharData::quests() const { + // @@protoc_insertion_point(field_map:MSRProto.CharData.quests) + return _internal_quests(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* +CharData::_internal_mutable_quests() { + return quests_.MutableMap(); +} +inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* +CharData::mutable_quests() { + // @@protoc_insertion_point(field_mutable_map:MSRProto.CharData.quests) + return _internal_mutable_quests(); +} + +// repeated .MSRProto.CharData.QuickSlot quickslots = 10; +inline int CharData::_internal_quickslots_size() const { + return quickslots_.size(); +} +inline int CharData::quickslots_size() const { + return _internal_quickslots_size(); +} +inline void CharData::clear_quickslots() { + quickslots_.Clear(); +} +inline ::MSRProto::CharData_QuickSlot* CharData::mutable_quickslots(int index) { + // @@protoc_insertion_point(field_mutable:MSRProto.CharData.quickslots) + return quickslots_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_QuickSlot >* +CharData::mutable_quickslots() { + // @@protoc_insertion_point(field_mutable_list:MSRProto.CharData.quickslots) + return &quickslots_; +} +inline const ::MSRProto::CharData_QuickSlot& CharData::_internal_quickslots(int index) const { + return quickslots_.Get(index); +} +inline const ::MSRProto::CharData_QuickSlot& CharData::quickslots(int index) const { + // @@protoc_insertion_point(field_get:MSRProto.CharData.quickslots) + return _internal_quickslots(index); +} +inline ::MSRProto::CharData_QuickSlot* CharData::_internal_add_quickslots() { + return quickslots_.Add(); +} +inline ::MSRProto::CharData_QuickSlot* CharData::add_quickslots() { + ::MSRProto::CharData_QuickSlot* _add = _internal_add_quickslots(); + // @@protoc_insertion_point(field_add:MSRProto.CharData.quickslots) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MSRProto::CharData_QuickSlot >& +CharData::quickslots() const { + // @@protoc_insertion_point(field_list:MSRProto.CharData.quickslots) + return quickslots_; +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace MSRProto + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::MSRProto::Stat_SubStat_SubStatId> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MSRProto::Stat_SubStat_SubStatId>() { + return ::MSRProto::Stat_SubStat_SubStatId_descriptor(); +} +template <> struct is_proto_enum< ::MSRProto::Stat_StatId> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MSRProto::Stat_StatId>() { + return ::MSRProto::Stat_StatId_descriptor(); +} +template <> struct is_proto_enum< ::MSRProto::GenericItemFull_HandId> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MSRProto::GenericItemFull_HandId>() { + return ::MSRProto::GenericItemFull_HandId_descriptor(); +} +template <> struct is_proto_enum< ::MSRProto::CharData_SaveData_GenderId> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MSRProto::CharData_SaveData_GenderId>() { + return ::MSRProto::CharData_SaveData_GenderId_descriptor(); +} +template <> struct is_proto_enum< ::MSRProto::CharData_QuickSlot_QuickSlotTypeId> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::MSRProto::CharData_QuickSlot_QuickSlotTypeId>() { + return ::MSRProto::CharData_QuickSlot_QuickSlotTypeId_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_savedata_2eproto diff --git a/src/game/server/save/protosave.cpp b/src/game/server/save/protosave.cpp index 4b353902..ab3df99f 100644 --- a/src/game/server/save/protosave.cpp +++ b/src/game/server/save/protosave.cpp @@ -1,5 +1,5 @@ #include "protosave.h" -#include "savedata.pb.h" +#include "proto/savedata.pb.h" #include "inc_weapondefs.h" #include "stats/stats.h"